本科课程数据结构与算法实验2——单链表与双向循环链表的插入删除操作(C++实现）

篇首语：本文由编程笔记#小编为大家整理，主要介绍了本科课程数据结构与算法实验2——单链表与双向循环链表的插入删除操作(C++实现）相关的知识，希望对你有一定的参考价值。

大家好&＃xff0c;我是【1&＃43;1&＃61;王】&＃xff0c; 热爱java的计算机&＃xff08;人工智能&＃xff09;渣硕研究生在读。
如果你也对java、人工智能等技术感兴趣&＃xff0c;欢迎关注&＃xff0c;抱团交流进大厂&＃xff01;&＃xff01;&＃xff01;
Good better best, never let it rest, until good is better, and better best.

近期会把自己本科阶段的一些课程设计、实验报告等分享出来&＃xff0c;供大家参考&＃xff0c;希望对大家有帮助。

博客更新至专栏【课程设计实验报告】&＃xff1a;https://blog.csdn.net/weixin_43598687/category_11640051.html

1. 掌握线性表的链表表示&＃xff1b;
2. 实现单链表的插入操作
3. 实现单链表的删除操作
4. 实现双向链表的插入操作
5. 实现双向链表的删除操作

1. 实验任务

a. 完成单链表的建立、插入和删除
b. 完成双向链表的建立、插入和删除

2. 程序设计

1&＃xff09; 数据输入&＃xff08;输入哪些数据、个数、类型、来源、输入方式&＃xff09;
节点个数&＃xff1a;count&＃xff1b;
节点元素值&＃xff1a;temp&＃xff1b;
要插入节点的位置和数值&＃xff1a;num1、Data&＃xff1b;
要删除节点的位置&＃xff1a;num2&＃xff1b;
2&＃xff09; 数据存储&＃xff08;输入数据在内存中的存储&＃xff09;
动态分配内存&＃xff08;pNode pNew &＃61; (pNode)malloc(sizeof(Node));&＃xff09;
3&＃xff09; 数据处理&＃xff08;说明处理步骤。若不是非常简单&＃xff0c;需要绘制流程图&＃xff09;




4&＃xff09; 数据输出&＃xff08;贴图&＃xff1a;程序运行结果截图。图幅大小适当&＃xff0c;不能太大&＃xff09;

1. 操作系统&＃xff1a;WINDOWS 10
2. 开发工具&＃xff1a;VC&＃43;&＃43; 2013
3. 实验设备&＃xff1a;PC

1. 单链表的插入删除操作

• pNode CreatList(); //创建链表函数
• void TravelseList(pNode); //遍历链表函数
• bool Insert_Node(pNode, int, int); //插入节点
• int Del_Node(pNode, int); //删除节点

#include<iostream>
using namespace std;
typedef struct node

int data;
struct node *pNext;
Node, *pNode;
pNode CreatList(); //创建链表函数
void TravelseList(pNode); //遍历链表函数
bool Insert_Node(pNode, int, int); //插入节点
int Del_Node(pNode, int); //删除节点
int main()

pNode pHead &＃61; NULL; //struct Node *pHead&＃61;NULL
int Data;
int num;
pHead &＃61; CreatList();
TravelseList(pHead);
cout << "输入要插入的位置和数据&＃xff1a;";
cin >> num >> Data;
Insert_Node(pHead, num, Data);
TravelseList(pHead);
cout << "输入要删除的位置&＃xff1a;";
cin >> num;
Del_Node(pHead, num);
TravelseList(pHead);
system("pause");
return 0;

//创建链表
pNode CreatList()

int count; //节点个数
int temp; //临时存储用户输入的节点的数据
pNode pHead &＃61; (pNode)malloc(sizeof(Node)); //不存放有效数据的头结点
pNode pTail &＃61; pHead; //链表的最后一个节点
pTail->pNext &＃61; NULL; //最后一个节点指针置为空
cout << "输入节点个数" << endl;
cin >> count;
for (int i &＃61; 0; i < count; i&＃43;&＃43;)

cout << "输入第" << i &＃43; 1 << "个节点的数值" << endl;
cin >> temp;
pNode pNew &＃61; (pNode)malloc(sizeof(Node)); //给新节点分配空间
pNew->data &＃61; temp;
pTail->pNext &＃61; pNew;
pNew->pNext &＃61; NULL;
pTail &＃61; pNew;

return pHead;

void TravelseList(pNode pHead)

cout << "链表的数据如下&＃xff1a;";
pNode p &＃61; pHead->pNext;
while (p !&＃61; NULL)

cout << p->data << " ";
p &＃61; p->pNext;

cout << endl;
return;

//插入
bool Insert_Node(pNode pHead, int front, int Data)

int i &＃61; 0;
pNode _node &＃61; pHead;
pNode pSwap; //交换指针
if ((front < 1) && (_node !&＃61; NULL))

return false;

while (i < front - 1)

_node &＃61; _node->pNext;
&＃43;&＃43;i;

pNode pNew &＃61; (pNode)malloc(sizeof(Node));
pNew->data &＃61; Data;
pSwap &＃61; _node->pNext;
pNew &＃61; _node->pNext;
pSwap &＃61; pNew->pNext;
return true;

//删除
int Del_Node(pNode pHead, int back)

int i &＃61; 0;
int Data;
pNode _node &＃61; pHead;
pNode pSwap;
if ((back < 1) && (NULL &＃61;&＃61; _node->pNext))

printf("删除失败&＃xff01;\\n");
return 0;

while (i < back - 1)

_node &＃61; _node->pNext;
&＃43;&＃43;i;

pSwap &＃61; _node->pNext;
Data &＃61; pSwap->data;
_node->pNext &＃61; _node->pNext->pNext;
free(pSwap);
return Data;



2. 双向循环链表的插入删除操作

头文件

#ifndef _DOUBLELINKLIST_H_
#define _DOUBLELINKLIST_H_
//
// 在此处包含 C 标准库头文件
//
#include <stdio.h>
#include<malloc.h>
//
// 在此处包含其他头文件
//

//
// 在此处定义数据结构
//
typedef int ElemType; // 链表中元素的类型
typedef struct DuLNode
ElemType data; // 数据域
struct DuLNode* prior; // 前趋指针
struct DuLNode* next; // 后继指针
DuLinkList;
//
// 在此处声明函数
//
int InsertBefore(DuLinkList* pListHead, int i, ElemType Elem);
int Delete(DuLinkList* pListHead, int i, ElemType* pElem);
#endif /* _DOUBLELINKLIST_H_ */


cpp文件

#include "DoubleLinkList.h"
#include
using namespace std;
int main(int argc, char* argv[])

int i;
ElemType Elem;
DuLinkList* pListHead; // 双向循环链表的表头指针&＃xff0c;指向表头节点
DuLinkList* pListNode; // 双向循环链表节点指针
//
// 初始化双向循环链表的表头节点
//
pListHead &＃61; (DuLinkList*)malloc(sizeof(DuLinkList));
pListHead->prior &＃61; pListHead;
pListHead->next &＃61; pListHead;
//
// 初始化双向循环链表的节点
//
for (i &＃61; 8; i>0; i--)

pListNode &＃61; (DuLinkList*)malloc(sizeof(DuLinkList));
pListNode->data &＃61; i;
pListNode->next &＃61; pListHead->next;
pListNode->prior &＃61; pListHead;
pListHead->next->prior &＃61; pListNode;
pListHead->next &＃61; pListNode;

//
// 在第 i 个节点之前插入一个节点
//
InsertBefore(pListHead, 3, 88);
InsertBefore(pListHead, 20, 15); // 插入位置非法。插入失败。
//
// 删除第 i 个节点
//
Delete(pListHead, 3, &Elem);
Delete(pListHead, 20, &Elem); // 删除位置非法。删除失败。
//
// 销毁双向循环链表
//
while (pListHead->next !&＃61; pListHead)

pListNode &＃61; pListHead->next;
pListHead->next &＃61; pListNode->next;
pListNode->next->prior &＃61; pListHead;
free(pListNode);

free(pListHead);
return 0;

/*
功能&＃xff1a;
在第 i 个节点之前插入一个节点。
参数&＃xff1a;
pListHead -- 双向循环链表的表头指针
i -- 插入节点的位置。从 1 开始计数。
Elem -- 插入节点的值。
返回值&＃xff1a;
如果插入成功返回 1
如果插入失败返回 0
*/
int InsertBefore(DuLinkList* pListHead, int i, ElemType Elem)

DuLinkList* pListNode&＃61;NULL; // 节点指针
//
// TODO: 在此添加代码
//
if (i <&＃61; 0 && i > 8)
cout << "插入非法" << endl;
else

DuLinkList* s &＃61; (DuLinkList*)malloc(sizeof(DuLNode));
s->data &＃61; Elem;
s->prior &＃61; pListNode->prior;
pListNode->prior->next &＃61; s;
s->next &＃61; pListNode;
pListNode->prior &＃61; s;

return 0;

/*
功能&＃xff1a;
删除第 i 个节点。
参数&＃xff1a;
pListHead -- 双向循环链表的表头指针
i -- 删除节点的位置。从 1 开始计数。
pElem -- 返回被删除节点的值。
返回值&＃xff1a;
如果删除成功返回 1
如果删除失败返回 0
*/
int Delete(DuLinkList* pListHead, int i, ElemType* pElem)

DuLinkList* pListNode; // 节点指针
//
// TODO: 在此添加代码
//
if (i <&＃61; 0 && i > 8)
cout << "插入非法" << endl;
else

pElem &＃61; pListNode->data;
pListNode->prior->next &＃61; pListNode->next;
pListNode->next->prior &＃61; pListNode->prior;
free(pListNode);

return 0;



博客更新至专栏【课程设计实验报告】&＃xff1a;https://blog.csdn.net/weixin_43598687/category_11640051.html