链表的C语言实现之单链表的查找运算

C语⾔之单链表的插⼊、删除与查找单链表是⼀种链式存取的数据结构，⽤⼀组地址任意的存储单元存放线性表中的数据元素。

要实现对单链表中节点的插⼊、删除与查找的功能，就要先进⾏的单链表的初始化、创建和遍历，进⽽实现各功能，以下是对单链表节点的插⼊、删除、查找功能的具体实现：#include<stdio.h>#include<stdlib.h>#include<string.h>typedef int ElemType;/***链表通⽤类型*ElemType 代表⾃定义的数据类型*struct Node *next 代表结构体指针（指向下⼀个结构体，完成链表动作）*/typedef struct Node{ElemType data;struct Node *next;}Node;/*==========单链表的初始化================*//**头结点指针数据域设置为空*/void initList(Node **pNode){*pNode=NULL;}/*===========单链表的创建=================*//**功能实现：通过⽤户不断输⼊数据，创建链表*利⽤游标俩个指针（p1,p2），将申请下的数据块(存⼊⽤户输⼊数据)，链接起来*/Node *create(Node *pHead){Node *p1;Node *p2;p1=p2=(Node *)malloc(sizeof(Node)); //申请内存空间memset(p1,0,sizeof(Node)); //存⼊数据域清空scanf("%d",&p1->data);p1->next=NULL;while(p1->data>0){ //输⼊负数结束if(pHead==NULL)pHead=p1;elsep2->next=p1;p2=p1;p1=(Node *)malloc(sizeof(Node));memset(p1,0,sizeof(Node));scanf("%d",&p1->data);p1->next=NULL;}return pHead;}/*=================链表的遍历==================*//***从头结点开始，不断遍历出数据域的内容将表遍历*/void printList(Node *pHead){if(NULL==pHead)printf("链表为空\n");else{while(pHead!=NULL){printf("%d ",pHead->data);pHead=pHead->next;}}printf("\n");}/*===============插⼊节点==================*//***Node **pNode 传⼊头结点空间地址*int i 传⼊要插⼊的结点位置*/void insert_data(Node **pNode,int i){Node *temp;Node *target;Node *p;int item;int j=1;printf("输⼊要插⼊的节点值:");scanf("%d",&item);target=*pNode;for(;j<i-1;target=target->next,++j); //不断移动target位置，到要插⼊结点位置，temp=(Node *)malloc(sizeof(Node)); //申请内存空间temp->data=item; //存⼊要存⼊的数据位置p=target->next;target->next=temp;temp->next=p;}/*===============删除节点====================*//***删除结点后，释放内存空间free(temp)*/void delete_data(Node **pNode,int i){Node *target;Node *temp;int j=1;target=*pNode;for(;j<i-1;target=target->next,++j);temp=target->next;target->next=temp->next;free(temp);}/*===============查找结点====================*/int search_data(Node *pNode,int elem){Node *target;int i=1;for(target=pNode;target->data!=elem && target->next!=NULL;++i,target=target->next); if(target->next==NULL)return 0;elsereturn i;}int main(){int i;Node *pHead=NULL;initList(&pHead);pHead=create(pHead);printList(pHead);printf("输⼊插⼊节点位置\n");scanf("%d",&i);insert_data(&pHead,i);printList(pHead);printf("输⼊删除节点位置\n");scanf("%d",&i);delete_data(&pHead,i);printList(pHead);printf("输⼊查找节点\n");scanf("%d",&i);printf("节点所在位置：%d",search_data(pHead,i));return 0;}通过以上各功能的实现，希望对⼤家单链表的学习有所帮助。

C语⾔单链表实现⽅法详解本⽂实例讲述了C语⾔单链表实现⽅法。

分享给⼤家供⼤家参考，具体如下：slist.h#ifndef __SLIST_H__#define __SLIST_H__#include<cstdio>#include<malloc.h>#include<assert.h>typedef int ElemType;typedef struct Node { //定义单链表中的结点信息ElemType data; //结点的数据域struct Node *next; //结点的指针域}Node,*PNode;typedef struct List { //定义单链表的链表信息PNode first; //first指向单链表中的第⼀个结点PNode last; //last指向单链表中的最后⼀个结点size_t size; //记录单链表中的结点个数}List;void InitList(List *list);//初始化单链表void push_back(List *list, ElemType x);//在单链表的末尾插⼊元素void push_front(List *list, ElemType x);//在单链表的头部插⼊元素void show_list(List *list);//打印单链表void pop_back(List *list);//删除单链表的最后⼀个元素void pop_front(List *list);//删除单链表的第⼀个元素void insert_val(List *list, ElemType val);//将数据元素插⼊到单链表中（要求此时单链表中的数据元素顺序排列）Node* find(List *list, ElemType x);//查找单链表中数据值为x的结点int length(List *list);//求单链表的长度void delete_val(List *list, ElemType x);//按值删除单链表中的某个数据元素void sort(List *list);//对单链表进⾏排序void reverse(List *list);//逆置单链表void clear(List *list);//清除单链表void destroy(List *list);//摧毁单链表#endif //__SLIST_H__slist.cpp#include"slist.h"void InitList(List *list) {list->first = list->last = (Node*)malloc(sizeof(Node)); //头结点assert(list->first != NULL);list->first->next = NULL;list->size = 0;}void push_back(List *list, ElemType x) {//step 1：创建⼀个新的结点Node *s = (Node*)malloc(sizeof(Node));assert(s != NULL);s->data = x;s->next = NULL;//step 2：将新结点插⼊单链表的表尾list->last->next = s;list->last = s;//step 3：更新单链表的长度list->size++;}void push_front(List *list, ElemType x) {//step 1：创建⼀个新的结点Node *s = (Node*)malloc(sizeof(Node));assert(s != NULL);s->data = x;s->next = NULL;//step 2：将新结点插⼊单链表的表头s->next = list->first->next;list->first->next = s;//step 3：判断插⼊的结点是否是单链表的第⼀个结点，若是更新链表的尾指针if (list->size == 0)list->last = s;//step 4：更新单链表的长度list->size++;}void show_list(List *list) {//step 1：指针p指向单链表的第⼀个结点Node *p = list->first->next;//step 2：循环打印结点的信息while (p != NULL) {printf("%d->", p->data);p = p->next;}printf("Nul.\n");}void pop_back(List *list) {//step 1：判断单链表是否为空if (list->size == 0) return;//step 2：定义指针p使其指向⽬标结点的前⼀个结点Node *p = list->first;//从头结点开始while (p->next != list->last)p = p->next;//step 3：删除⽬标结点free(list->last);list->last = p;list->last->next = NULL;//step 4：更新单链表的长度list->size--;}void pop_front(List *list) {//step 1：判断单链表是否为空if (list->size == 0) return;//step 2：定义指针p使其指向⽬标结点的前⼀个结点Node *p = list->first->next;//step 3：删除⽬标结点list->first->next = p->next;free(p);//step 4：判断删除的结点是否是单链表的最后⼀个结点，若是则更新单链表的尾指针 if (list->size == 1)list->last = list->first;//step 4：更新单链表的长度list->size--;}void insert_val(List *list, ElemType x) {//step 1：创建⼀个新的结点Node *s = (Node*)malloc(sizeof(Node));assert(s != NULL);s->data = x;s->next = NULL;//step 2：定义指针p使其指向待插⼊位置的前⼀个结点Node *p = list->first;//从头结点开始while (p->next != NULL && p->next->data < s->data)p = p->next;//step 3：判断结点的待插⼊位置是否是表尾，若是则更新单链表的尾指针if (p->next == NULL)list->last = s;//step 4：插⼊结点s->next = p->next;p->next = s;//step 5：更新单链表长度list->size++;}Node* find(List *list, ElemType x) {//step 1：指针p指向单链表的第⼀个结点Node *p = list->first->next;//step 2：按照循环顺序查找链表结点while (p != NULL && p->data != x)p = p->next;return p;}int length(List *list) {return list->size;}void delete_val(List *list, ElemType x) {//step 1：判断单链表是否为空if (list->size == 0) return;//step 2：确定结点在单链表中的位置，并判断其是否存在于单链表中Node *p = find(list, x);if (p == NULL) {printf("要删除的数据不存在！\n");return;}//step 3：判断结点位置是否是表尾if (p == list->last)//是表尾pop_back(list);else {//不是表尾Node *q = p->next;p->data = q->data;p->next = q->next;free(q);list->size--;}}void sort(List *list) {//step 1：判断单链表中的结点数是否为0或1if (list->size == 0 || list->size == 1) return;//step 2：将单链表中第⼀个结点之后的链表部分截出，⽅便重新按顺序插⼊链表之中Node *s = list->first->next; // 指针s指向单链表的第⼀个节点Node *p = s->next;//q指向s后⾯的结点list->last = s;//单链表的尾指针指向单链表的第⼀个结点list->last->next = NULL;//截断链表//step 3：将截出的链表中的结点根据其数据域⼤⼩重新插⼊到原来链表中while (p != NULL) {s = p;p = p->next;Node *q = list->first;while (q->next != NULL && q->next->data < s->data)q = q->next;if (q->next == NULL)//判断q此时指向的是否是单链表的最后⼀个结点，若是则更新链表的尾指针list->last = s;//将结点重新插⼊链表s->next = q->next;q->next = s;}}void reverse(List *list) {//step 1：判断单链表中的结点数是否为0或1if (list->size == 0 || list->size == 1) return;//step 2：将单链表中第⼀个结点之后的链表部分截出，然后将截出的链表中的结点按头插法重新插⼊到原链表中 Node *p = list->first->next;Node *q = p->next;list->last = p;list->last->next = NULL;while (q != NULL) {p = q;q = q->next;p->next = list->first->next;list->first->next = p;}}void clear(List *list) {//step 1：判断单链表是否为空if (list->size == 0) return;//step 2：释放单链表中的每⼀个结点Node *p = list->first->next;while (p != NULL) {list->first->next = p->next;free(p);p = list->first->next;}//step 3：头指针和尾指针重新都指向头结点list->last = list->first;//step 4：更新链表长度list->size = 0;}void destroy(List *list) {//step 1：清空单链表clear(list);//step 2：释放头结点free(list->first);//step 3：头指针和尾指针都赋值为空list->first = list->last = NULL;}main.cpp#include"slist.h"void main() {List mylist;InitList(&mylist);ElemType item;Node *p = NULL;int select = 1;while (select) {printf("*******************************************\n"); printf("*[1] push_back [2] push_front *\n");printf("*[3] show_list [4] pop_back *\n");printf("*[5] pop_front [6] insert_val *\n");printf("*[7] find [8] length *\n");printf("*[9] delete_val [10] sort *\n");printf("*[11] reverse [12] clear *\n");printf("*[13*] destroy [0] quit_system *\n"); printf("*******************************************\n"); printf("请选择：>>");scanf("%d", &select);if (select == 0) break;switch (select) {case 1:printf("请输⼊要插⼊的数据（-1结束）:>");while (scanf("%d", &item), item != -1) {push_back(&mylist, item);}break;case 2:printf("请输⼊要插⼊的数据（-1结束）:>");while (scanf("%d", &item), item != -1) {push_front(&mylist, item);}break;case 3:show_list(&mylist);break;case 4:pop_back(&mylist);break;case 5:pop_front(&mylist);break;case 6:printf("请输⼊要插⼊的数据:>");scanf("%d", &item);insert_val(&mylist, item);break;case 7:printf("请输⼊要查找的数据:>");scanf("%d", &item);p = find(&mylist, item);if (p == NULL)printf("要查找的数据在单链表中不存在！\n"); break;case 8:printf("单链表的长度为%d\n", length(&mylist)); break;case 9:printf("请输⼊要删除的值:>");scanf("%d", &item);delete_val(&mylist, item);break;case 10:sort(&mylist);break;case 11:reverse(&mylist);break;case 12:clear(&mylist);break;//case 13://destroy(&mylist);//break;default:printf("选择错误,请重新选择！\n");break;}}destroy(&mylist); //程序结束，摧毁链表}附：单链表优化版本slist.h#ifndef __SLIST_H__#define __SLIST_H__#include<cstdio>#include<malloc.h>#include<assert.h>typedef int ElemType;typedef struct Node { //定义单链表中的结点信息ElemType data; //结点的数据域struct Node *next; //结点的指针域}Node,*PNode;typedef struct List { //定义单链表的链表信息PNode first; //first指向单链表中的第⼀个结点PNode last; //last指向单链表中的最后⼀个结点size_t size; //记录单链表中的结点个数}List;void InitList(List *list);//初始化单链表void push_back(List *list, ElemType x);//在单链表的末尾插⼊元素void push_front(List *list, ElemType x);//在单链表的头部插⼊元素void show_list(List *list);//打印单链表void pop_back(List *list);//删除单链表的最后⼀个元素void pop_front(List *list);//删除单链表的第⼀个元素void insert_val(List *list, ElemType val);//将数据元素插⼊到单链表中（要求此时单链表中的数据元素顺序排列）Node* find(List *list, ElemType x);//查找单链表中数据值为x的结点int length(List *list);//求单链表的长度void delete_val(List *list, ElemType x);//按值删除单链表中的某个数据元素void sort(List *list);//对单链表进⾏排序void reverse(List *list);//逆置单链表void clear(List *list);//清除单链表void destroy(List *list);//摧毁单链表//代码优化Node* CreateNode(ElemType x); //创建⼀个单链表结点Node* begin(List *list); //返回单链表的第⼀个结点Node* end(List *list); //返回单链表中最后⼀个结点的下⼀个结点void insert(List *list, Node *pos, ElemType x); //在单链表的特定位置（pos）插⼊新的结点#endif //__SLIST_H__slist.cpp#include"slist.h"void InitList(List *list) {list->first = list->last = (Node*)malloc(sizeof(Node)); //头结点assert(list->first != NULL);list->first->next = NULL;list->size = 0;}//push_back的优化void push_back(List *list, ElemType x) {insert(list, end(list), x);}//push_front的优化void push_front(List *list, ElemType x) {insert(list, begin(list), x);}void show_list(List *list) {//step 1：指针p指向单链表的第⼀个结点Node *p = list->first->next;//step 2：循环打印结点的信息while (p != NULL) {printf("%d->", p->data);p = p->next;}printf("Nul.\n");}void pop_back(List *list) {//step 1：判断单链表是否为空if (list->size == 0) return;//step 2：定义指针p使其指向⽬标结点的前⼀个结点Node *p = list->first;//从头结点开始while (p->next != list->last)p = p->next;//step 3：删除⽬标结点free(list->last);list->last = p;list->last->next = NULL;//step 4：更新单链表的长度list->size--;}void pop_front(List *list) {//step 1：判断单链表是否为空if (list->size == 0) return;//step 2：定义指针p使其指向⽬标结点的前⼀个结点Node *p = list->first->next;//step 3：删除⽬标结点list->first->next = p->next;free(p);//step 4：判断删除的结点是否是单链表的最后⼀个结点，若是则更新单链表的尾指针 if (list->size == 1)list->last = list->first;//step 4：更新单链表的长度list->size--;}//insert_val的优化void insert_val(List *list, ElemType x) {//step 1：创建⼀个新的结点Node *s = CreateNode(x);//step 2：定义指针p使其指向待插⼊位置的前⼀个结点Node *p = list->first;//从头结点开始while (p->next != NULL && p->next->data < s->data)p = p->next;//step 3：判断结点的待插⼊位置是否是表尾，若是则更新单链表的尾指针if (p->next == NULL)list->last = s;//step 4：插⼊结点s->next = p->next;p->next = s;//step 5：更新单链表长度list->size++;}Node* find(List *list, ElemType x) {//step 1：指针p指向单链表的第⼀个结点Node *p = list->first->next;//step 2：按照循环顺序查找链表结点while (p != NULL && p->data != x)p = p->next;return p;}int length(List *list) {return list->size;}void delete_val(List *list, ElemType x) {//step 1：判断单链表是否为空if (list->size == 0) return;//step 2：确定结点在单链表中的位置，并判断其是否存在于单链表中Node *p = find(list, x);if (p == NULL) {printf("要删除的数据不存在！\n");return;}//step 3：判断结点位置是否是表尾if (p == list->last)//是表尾pop_back(list);else {//不是表尾Node *q = p->next;p->data = q->data;p->next = q->next;free(q);list->size--;}}void sort(List *list) {//step 1：判断单链表中的结点数是否为0或1if (list->size == 0 || list->size == 1) return;//step 2：将单链表中第⼀个结点之后的链表部分截出，⽅便重新按顺序插⼊链表之中Node *s = list->first->next; // 指针s指向单链表的第⼀个节点Node *p = s->next;//q指向s后⾯的结点list->last = s;//单链表的尾指针指向单链表的第⼀个结点list->last->next = NULL;//截断链表//step 3：将截出的链表中的结点根据其数据域⼤⼩重新插⼊到原来链表中while (p != NULL) {s = p;p = p->next;Node *q = list->first;while (q->next != NULL && q->next->data < s->data)q = q->next;if (q->next == NULL)//判断q此时指向的是否是单链表的最后⼀个结点，若是则更新链表的尾指针list->last = s;//将结点重新插⼊链表s->next = q->next;q->next = s;}}void reverse(List *list) {//step 1：判断单链表中的结点数是否为0或1if (list->size == 0 || list->size == 1) return;//step 2：将单链表中第⼀个结点之后的链表部分截出，然后将截出的链表中的结点按头插法重新插⼊到原链表中 Node *p = list->first->next;Node *q = p->next;list->last = p;list->last->next = NULL;while (q != NULL) {p = q;q = q->next;p->next = list->first->next;list->first->next = p;}}void clear(List *list) {//step 1：判断单链表是否为空if (list->size == 0) return;//step 2：释放单链表中的每⼀个结点Node *p = list->first->next;while (p != NULL) {list->first->next = p->next;free(p);p = list->first->next;}//step 3：头指针和尾指针重新都指向头结点list->last = list->first;//step 4：更新链表长度list->size = 0;}void destroy(List *list) {//step 1：清空单链表clear(list);//step 2：释放头结点free(list->first);//step 3：头指针和尾指针都赋值为空list->first = list->last = NULL;}//优化Node* CreateNode(ElemType x) {Node *s = (Node*)malloc(sizeof(Node));assert(s != NULL);s->data = x;s->next = NULL;return s;}Node* begin(List *list) {return list->first->next;}Node* end(List *list) {return list->last->next;}void insert(List *list, Node *pos, ElemType x) {//step 1：创建⼀个新的结点Node *s = CreateNode(x);//step 2：确定带插⼊位置Node *p = list->first;while (p->next != pos)p = p->next;//step 3：插⼊结点s->next = p->next;p->next = s;//step 4：判断结点是否插⼊到链表的表尾，若是则更新单链表的表尾指针 if (pos == NULL)list->last = s;//step 5：更新单链表长度list->size++;}main.cpp#include"slist.h"void main() {List mylist;InitList(&mylist);ElemType item;Node *p = NULL;int select = 1;while (select) {printf("*******************************************\n");printf("*[1] push_back [2] push_front *\n");printf("*[3] show_list [4] pop_back *\n");printf("*[5] pop_front [6] insert_val *\n");printf("*[7] find [8] length *\n");printf("*[9] delete_val [10] sort *\n");printf("*[11] reverse [12] clear *\n");printf("*[13*] destroy [0] quit_system *\n");printf("*******************************************\n");printf("请选择：>>");scanf("%d", &select);if (select == 0) break;switch (select) {case 1:printf("请输⼊要插⼊的数据（-1结束）:>");while (scanf("%d", &item), item != -1) {push_back(&mylist, item);}break;case 2:printf("请输⼊要插⼊的数据（-1结束）:>");while (scanf("%d", &item), item != -1) {push_front(&mylist, item);}break;case 3:show_list(&mylist);break;case 4:pop_back(&mylist);break;case 5:pop_front(&mylist);break;case 6:printf("请输⼊要插⼊的数据:>");scanf("%d", &item);insert_val(&mylist, item);break;case 7:printf("请输⼊要查找的数据:>");scanf("%d", &item);p = find(&mylist, item);if (p == NULL)printf("要查找的数据在单链表中不存在！\n");break;case 8:printf("单链表的长度为%d\n", length(&mylist));break;case 9:printf("请输⼊要删除的值:>");scanf("%d", &item);delete_val(&mylist, item);break;case 10:sort(&mylist);break;case 11:reverse(&mylist);break;case 12:clear(&mylist);break;//case 13://destroy(&mylist);//break;default:printf("选择错误,请重新选择！\n");break;}}destroy(&mylist); //程序结束，摧毁链表}希望本⽂所述对⼤家C语⾔程序设计有所帮助。

实验截图（1）void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图（2）bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图（3）bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图（4）编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图（5）运行得到结果实验截图（6）。

C语⾔单链表的基本操作（增删改查）这是尾插法单链表，单链表⽐较适合⽤来做队列和栈，因为在链表的头和尾时的增删改查的时间复杂度为O(1)，⽽在链表内部的增删改查的平均时间复杂度为O(n)。

#include "stdio.h"#include "stdlib.h"//提供malloc()和free()#include "string.h"#include "time.h"//提供strcpy()，time()等//1.⽤结构体创建链表节点//⼀个⽤来存放数据，另⼀个存放指针struct Node{int data; //数据域struct Node* next; //指针域(指向节点的指针）};//2.全局定义链表头尾指针，⽅便调⽤struct Node* head = NULL;struct Node* end = NULL;//3.向链表添加数据void AddListTill(int a ){//创建⼀个节点struct Node* temp = (struct Node*)malloc(sizeof(struct Node)); //此处注意强制类型转换//节点数据进⾏赋值temp->data = a;temp->next = NULL;//连接分两种情况1.⼀个节点都没有2.已经有节点了，添加到尾巴上if(NULL == head){head = temp;//end=temp;}else{end->next=temp;//end=temp; //尾结点应该始终指向最后⼀个}end=temp; //尾结点应该始终指向最后⼀个}//4.遍历链表并输出void ScanList(){struct Node *temp = head; //定义⼀个临时变量来指向头while (temp != NULL){printf("%d\n",temp->data);temp = temp->next; //temp指向下⼀个的地址即实现++操作}}//5.查找指定的数据是否在链表内struct Node* FindNode(int a ){struct Node *temp = head;while(temp != NULL){if(a == temp->data){return temp;}temp = temp->next;}//没找到return NULL;}//6.删除链表void FreeList(){struct Node *temp = head; //定义⼀个临时变量来指向头while (temp != NULL){struct Node* pt = temp;temp = temp->next; //temp指向下⼀个的地址即实现++操作free(pt); //释放当前}//头尾清空，不然下次的头就接着0x10head = NULL;end = NULL;}//7.在指定位置处插⼊数据void AddListRand(int index,int a){if (NULL == head){printf("链表没有节点\n");return;}struct Node* pt = FindNode(index);if(NULL == pt) //没有此节点{printf("没有指定节点\n");return;}//有此节点//创建临时节点，申请内存struct Node* temp =(struct Node *)malloc(sizeof(struct Node));//节点成员进⾏赋值temp->data = a;temp->next = NULL;//连接到链表上 1.找到的节点在尾部 2.找到的节点在中间if (pt == end){//尾巴的下⼀个指向新插⼊的节点end->next = temp;//新的尾巴end = temp;}else{//先连后⾯（先将要插⼊的节点指针指向原来找到节点的下⼀个） temp->next = pt->next;//后连前⾯pt->next = temp;}}//8.删除链表末尾数据void DeleteListTail(){if (NULL == end){printf("链表为空，⽆需删除\n");return;}//链表不为空//链表有⼀个节点if (head == end){free(head);head = NULL;end = NULL;}else{//找到尾巴前⼀个节点struct Node* temp = head;while (temp->next != end){temp = temp->next;}//找到了，删尾巴//释放尾巴free(end);//尾巴迁移end=temp;//尾巴指针为NULLend->next = NULL;}}//9.删除链表的第⼀个数据void DeleteListHead(){ //记住旧头struct Node* temp = head;//链表检测if (NULL == head){printf("链表为空\n");return;}head = head->next; //头的第⼆个节点变成新的头free(temp);}//10.删除链表指定的数据void DeleteListRand(int a){//链表判断是不是没有东西if(NULL == head){printf("链表没东西\n");return;}//链表有东西，找这个节点struct Node* temp = FindNode(a);if(NULL == temp){printf("查⽆此点\n");return;}//找到了,且只有⼀个节点if(head == end){free(head);head = NULL;end = NULL;}else if(head->next == end) //有两个节点{//看是删除头还是删除尾if(end == temp){DeleteListTail();}else if(temp == head){DeleteListHead();}}else//多个节点{//看是删除头还是删除尾if(end == temp)DeleteListTail();else if(temp == head)DeleteListHead();else//删除中间某个节点{ //找要删除temp前⼀个，遍历struct Node* pt = head;while(pt->next != temp){pt=pt->next;}//找到了//让前⼀个直接连接后⼀个跳过指定的即可 pt->next = temp->next;free(temp);}}}//主函数void main(){struct Node *pFind;srand((unsigned)time(NULL));int i;//创建20个节点for(i = 0; i < 20; i++)AddListTill(i); //添加数据//AddListTill(rand());AddListRand(4,86); //在指定位置4增加节点14//DeleteListHead(); //删除⼀个头结点//DeleteListTail(); //删除⼀个尾结点DeleteListRand(4); //删除4节点ScanList(); //遍历输出链表//FreeList(); //删除链表pFind = FindNode(5); //查找5节点if (pFind != NULL){printf("找到%d\n",pFind->data); //找到节点并且输出该节点数据 }else{printf("No Find!\n");}}以下是排序算法的时间和空间复杂度表：。

实验截图（1）void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图（2）bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图（3）bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图（4）编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图（5）运行得到结果实验截图（6）。

实现单链表的各种基本运算。

单链表是一种常用的数据结构，它由一个头指针和一些节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。

单链表具有插入、删除、查找、排序等基本运算。

下面将介绍如何实现单链表的各种基本运算。

1. 创建单链表
首先需要定义一个节点结构，包含数据域和指针域。

然后声明一个头指针，表示单链表的头节点。

接着输入节点数据，逐个创建新节点，并将其插入链表中。

2. 插入节点
在单链表中插入节点有两种情况：插入到链表头部和插入到链表尾部。

插入节点时需要先找到插入位置的前一个节点，然后修改前一个节点的指针域，将其指向新节点，再修改新节点的指针域，将其指向插入位置的后一个节点。

3. 删除节点
在单链表中删除节点也有两种情况：删除链表头部的节点和删除链表任意位置的节点。

删除节点时需要先找到删除位置的前一个节点，然后修改前一个节点的指针域，将其指向待删除节点的后一个节点，最后释放待删除节点的空间。

4. 查找节点
在单链表中查找节点时需要从头节点开始遍历链表，逐个比较节点值，直到找到目标节点或者遍历到链表尾部为止。

5. 排序
单链表排序可以采用冒泡排序、选择排序、快速排序等多种算法。

其中最简单的是冒泡排序，即从头节点开始遍历链表，逐个比较相邻节点的值，如果前一个节点的值大于后一个节点的值，则交换两个节点的值，直到遍历到链表尾部为止。

以上就是单链表的各种基本运算的实现方法，其它高级运算（如合并链表、反转链表等）可以在此基础上进一步扩展。

c++单链表冒泡排序（交换结点），链表增删改查，运算符重载#include <iostream>#include <stdlib.h>#include <time.h>#include <fstream>#include <string>using namespace std;//类class List{public://构造器初始化，⽣成头节点List(){head = new Node;head->next = NULL;}//成员函数void createList();void insertList(int data);void travelList(int chance);void input();int addNode();void deleteData(int addNum);void ifClear();void clearList();//重载下标int operator[](int idx);//重载+friend List operator+(List& List_1, List& List_2);//重载-friend List operator-(List& List_1, List& List_2);//重载<<friend ostream& operator<<(ostream& os, List& list);//重载>>friend istream& operator>>(istream& is, List& list);//冒泡排序void bubbleSortList(List& list);private://数据成员struct Node{int data; //数据域struct Node* next; //指针域} *head;//头指针int num;//链表元素个数};//头插法⽣成节点void List::insertList(int data){Node* cur = new Node;//插⼊数据cur->data = data;//插⼊节点cur->next = head->next;head->next = cur;}//调⽤insertList输⼊数据，⽣成链表void List::input(){cout << "请输⼊链表数量长度：";cin >> num;srand(time(NULL));for (int i = 0; i < num; i++){insertList(rand() % 100);}}//任意位置插⼊节点int List::addNode()int d, idx;cout << "请输⼊你要插⼊的节点数据:";cin >> d;cout << "请输⼊你要插⼊的节点位置: ";cin >> idx;Node* tp = NULL;Node* link = head;//寻找插⼊位置if (idx<1 || idx>num + 1){cout << "操作⾮法" << endl;return num;}else{for (int i = 0; i < idx; i++){tp = link;link = link->next;}Node* cur = new Node;tp->next = cur;cur->data = d;cur->next = link;travelList(1);return ++num;}}ofstream mycout1("D:/text1.txt");ofstream mycout2("D:/text2.txt");//遍历链表并将数据存⼊⽂件void List::travelList(int chance){Node* temp = head->next; //防⽌头指针地址改变while (temp != NULL){cout << temp->data << " ";if (chance == 1)mycout1 << temp->data << " ";elsemycout2 << temp->data << " ";temp = temp->next;}cout << endl;}//删除节点void List::deleteData(int addNum){int i, j = 0;cout << "请问您要删除第⼏个数据: ";cin >> i;Node* tp = NULL;Node* link = head;//link为删除节点后⾯的⼀个节点，temp为删除节点 if (addNum < i || i < 0)cout << "操作⾮法！！" << endl;else{while (link->next){tp = link->next; //第⼀个节点j++;if (i == j) //找的删除的节点{link->next = tp->next;delete tp;break;}link = link->next;}travelList(1);}}//清空链表void List::clearList()Node* tp = NULL;Node* ph = head->next;while (head->next){tp = ph;ph = ph->next;delete tp;head->next = ph;}travelList(1);cout << endl;}//询问是否清空void List::ifClear(){string i;if (!head->next){cout << "链表已清空" << endl; }else{cout << "是否清空链表（是/否）：";cin >> i;if (i == "是"){clearList();cout << "链表清空完成" << endl; }elsecout << "链表未清空" << endl; }}//冒泡排序void List::bubbleSortList(List& list){//求list链表长度lenint len=0;//临时指针pheadNode* phead = list.head->next;while (phead){len++;phead = phead->next;}//冒泡排序for (int i=0;i<len-1; i++){//phead指向头结点phead = list.head;//ph1指向⾸元结点Node* ph1 = phead->next;//ph2指向⾸元结点的后继Node* ph2 = ph1->next;//进⼊循环冒出最⼤的数for (int j = 0; j < len - 1 - i; j++){//如果前⾯的值⼤于后⾯的值则交换if (ph1->data > ph2->data){phead->next = ph2;ph1->next = ph2->next;ph2->next = ph1;//结点交换后，ph1与ph2位置颠倒回来 Node* temp = ph1;ph1 = ph2;ph2 = temp;}//如果不需要交换,三指针移动phead = phead->next;ph1 = ph1->next;ph2 = ph2->next;}//打印结点数据phead = list.head->next;while (phead){cout << phead->data << " ";phead = phead->next;}cout << endl;}//下标重载int List::operator[](int idx){//临时指针temp，为了防⽌头指针改变Node* temp = head;//如果下标⼩于链表长度进⾏取值if (idx < num){for (int i = 0; i < idx; i++){temp = temp->next;}}return temp->data;}//+ 重载List operator +(List & List_1, List & List_2){//由链表1⽣成链表3List List_3;//⽣成临时指针temp_1List::Node* temp_1 = List_1.head->next;//把链表1的值给链表3while (temp_1){List_3.insertList(temp_1->data);temp_1 = temp_1->next;}//⽣成临时指针temp_2List::Node* temp_2 = List_2.head->next;//把链表2的值给链表3while (temp_2){List_3.insertList(temp_2->data);temp_2 = temp_2->next;}return List_3;}//- 重载List operator -(List & List_1, List & List_2){//⽣成链表4List List_4;//⽣成临时指针temp_1,temp_2List::Node* temp_1 = List_1.head->next;List::Node* temp_2 = List_2.head->next;//flag为1链表2有链表1的值，为0则没有int flag = 0;//⽐较链表⼀和链表⼆，不等就将数据存⼊List_4 while (temp_1){//临时指针temp_2回溯temp_2 = List_2.head->next;while (temp_2){//判断是否有相同值if (temp_1->data == temp_2->data){flag = 1;break;}//指针移动temp_2 = temp_2->next;}//没有相同值List_4则插⼊数据if (!flag){List_4.insertList(temp_1->data);//指针移动,开始下⼀轮对⽐temp_1 = temp_1->next;flag = 0;}return List_4;}//重载<<ostream& operator<<(ostream & os, List & list) {list.bubbleSortList(list);return os;}//重载>>istream &operator>>(istream & is, List & list) {int size, i=0;cout << "(输⼊链表长度):";is >> size;//当i<size时录⼊数据while (i < size){int data;is >> data;//插⼊数据list.insertList(data);i++;}return is;}int main(){//初始化，⽣成List_1List List_1;//输⼊链表长度List_1.input();//遍历链表，并存⼊text1⽂件List_1.travelList(1);//添加节点并返回总结点数int addNum = List_1.addNode();//删除节点List_1.deleteData(addNum);//初始化，⽣成List_2List List_2;//输⼊链表长度List_2.input();//遍历链表，并存⼊text2⽂件List_2.travelList(2);//重载下标cout << "取链表2的第⼆个元素：";cout << List_2[2]<<endl;//重载+List List_3;List_3 = List_1 + List_2;cout << "两链表+为：";List_3.bubbleSortList(List_3);//重载-List List_4;List_4 = List_1 - List_2;cout << "两链表-为：";List_4.bubbleSortList(List_4);//重载<<cout << "cout<<List_4：";cout << List_4 << endl;//重载>>List List_5;cout << "cin>>List_5";cin >> List_5;cout << "链表List_5: " << List_5;//询问是否清空链表1List_1.ifClear();//关闭打开的⽂件mycout1.close();mycout2.close();return 0;}⽤类创建单链表时，可以将结构体封装为私有成员，在构造函数中初始化链表极为⽅便；链表的删除操作需要先进⾏遍历，并且遍历途中不能随意改变头结点的位置，所以在进⾏链表的操作时，皆需要临时变量防⽌头指针改变；除此之外，在进⾏冒泡排序时，需要画图理清逻辑，虽然⽐较过后，链表的连接⽅式改变了，但是ph1与ph2位置颠倒，需要互换回来，使下⼀次⽐较正常运⾏；运算符“+”号重载时，如果直接由链表1⽣成链表3，在进⾏减操作时，会发现链表1随链表3的改变⽽改变了，导致在进⾏“-”操作时出错，后在“+”操作时，对链表3进⾏逐⼀赋值，问题得到解决。

单链表的基本操作（查找，插⼊，删除）这周⽼师给的作业跟上周貌似差不多。

只是⽤了单链表。

完成单链表的基本操作函数。

1) 初始化单链表2) 给定的数据元素存放在⼀维数组中，分别完成头插法和尾插法建⽴单链表3) 将数据元素从键盘依次输⼊，分别完成头插法和尾插法建⽴单链表4) 输出单链表的长度5) 实现按位查找和按值查找6) 实现插⼊和删除操作7) 实现遍历单链表操作#include <cstdio>#include <cstring>#include <cstdlib>//查找1.内容2.序号//插⼊//删除typedef struct student{int num;char name[10];}STU;typedef struct Node{STU data;struct Node * next;}Node;void denglu(Node *L);//登录函数void chazhao(Node *L);//查找函数void Printf(Node *L);//输出函数void CreateFromHead(Node *L);//头插法void CreateFormTail(Node *L);//尾插法void panduan(Node *L);//判断头插还是尾插void Get(Node *L);//按序号结点查找void Locate(Node *L);//按内容查找（值）void Inslist(Node *L);//插⼊void Dellist(Node *L);//删除void Dellist(Node *L)//删除{system("CLS");int n;printf("请输⼊要删除的结点\n");scanf("%d",&n);if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Dellist(L);}Node *pre,*r;int k=0;pre=L;while(pre->next !=NULL&&k<n-1){pre=pre->next;k=k+1;}if(pre->next==NULL){printf("没有找到该结点,请重新输⼊\n");Dellist(L);}r=pre->next;pre->next=r->next;free(r);printf("删除成功!\n");denglu(L);}void Inslist(Node *L)//插⼊{system("CLS");int n;printf("请输⼊在第⼏个位置插⼊数据\n");scanf("%d",&n);printf("请输⼊插⼊的学号,姓名\n");int num1;char name1[10];scanf("%d %s",&num1,name1);Node *pre,*s;int k=0;if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Inslist(L);}pre=L;while(pre!=NULL&&k<n-1){pre=pre->next;k=k+1;}if(pre==NULL){printf("⽆法找到该节点,请重新输⼊\n");Inslist(L);}s=(Node*)malloc(sizeof(Node));strcpy(s->data .name ,name1);s->data.num=num1;s->next =pre->next ;pre->next =s;printf("插⼊成功!\n");denglu(L);}void Locate(Node *L)//按内容查找（值）{system("CLS");int n;printf("请输⼊要查找的学号\n");scanf("%d",&n);Node *p;p=L->next;while(p!=NULL){if(p->data.num!=n){p=p->next;}elsebreak;}printf("你要查找的学号所对应的信息为%d %s\n",p->data.num,p->);denglu(L);}void Get(Node *L)//按序号结点查找{system("CLS");int n;printf("请输⼊你要查找的结点\n");scanf("%d",&n);if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Get(L);}Node *p;p=L;int j=0;while((p->next!=NULL)&&(j<n)){p=p->next;j++;}if(n==j){printf("你要查找的结点的储存位置的数据为%d %s\n",p->data.num,p->); }denglu(L);}void Printf(Node *L){int q=0;Node *p=L->next;while(p!=NULL){q++;printf("%d %s\n",p->data.num,p->); p=p->next;}printf("单链表长度为%d\n",q);denglu(L);}void chazhao(Node *L){printf("1.按序号查找\n");printf("2.按内容查找\n");printf("3.返回主界⾯\n");int aa;scanf("%d",&aa);switch(aa){case 1:Get(L);case 2:Locate(L);case 3:denglu(L);break;default:printf("输⼊错误请重新输⼊\n");chazhao(L);}}void denglu(Node *L){int a;printf("请选择你要做什么\n");printf("1.查找\n");printf("2.插⼊\n");printf("3.删除\n");printf("4.打印现有的学⽣信息及单链表长度\n"); printf("5.退出\n");scanf("%d",&a);switch(a){case 1:chazhao(L);case 2:Inslist(L);case 3:Dellist(L);case 4:Printf(L);case 5:printf("谢谢使⽤\n");exit(0);default:printf("输⼊错误请重新输⼊\n");denglu(L);}}void CreateFromHead(Node *L)//头插法{Node *s;int n;//n为元素个数printf("请输⼊元素个数\n");scanf("%d",&n);printf("请输⼊学号姓名\n");for(int i=1;i<=n;i++){s=(Node *)malloc(sizeof(Node));scanf("%d %s",&s->data.num,s->); s->next=L->next;L->next=s;}}void CreateFormTail(Node *L)//尾插法{Node *s,*r;r=L;int n;//n为元素个数printf("请输⼊元素个数\n");scanf("%d",&n);printf("请输⼊学号姓名\n");for(int i=1;i<=n;i++){s=(Node *)malloc(sizeof(Node));scanf("%d %s",&s->data.num,s->);r->next=s;r=s;if(i==n){r->next=NULL;}}}Node *InitList(Node *L)//初始化单链表{L=(Node *)malloc(sizeof(Node));L->next=NULL;return L;}void panduan(Node *L){int q;printf("请选择⽤哪种⽅式建⽴链表\n");printf("1.头插法\n");printf("2.尾插法\n");scanf("%d",&q);switch(q){case (1):CreateFromHead(L);printf("输⼊成功！\n");break;case (2):CreateFormTail(L);printf("输⼊成功！\n");break;default:printf("输⼊错误请重新输⼊\n");panduan(L);}}int main(){Node *L=NULL;L=InitList(L);panduan(L);denglu(L);return 0;}ps.贴上来的代码空格有点⼩奇怪啊。

《数据结构》实验报告一题目：单链表的查找、插入与删除班级：电子0802学号：姓名：日期：2011.03.08 程序名：cqq1.c一、上机实验的问题和要求：单链表的查找、插入与删除。

设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。

具体实现要求：1.从键盘输入20个整数，产生不带表头的单链表，并输入结点值。

2.从键盘输入1个整数，在单链表中查找该结点的位置。

若找到，则显示“找到了”；否则，则显示“找不到”。

3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。

4.从键盘输入1个整数，表示欲删除结点的位置，输出单链表所有结点值，观察输出结果。

5.将单链表中值重复的结点删除，使所得的结果表中个结点值均不相同，输出单链表所有结点值，观察输出结果。

6.删除其中所有数据值为偶数的结点，输出单链表所有结点值，观察输出结果。

7.把单链表变成带表头结点的循环链表，输出循环单链表所有结点值，观察输出结果。

8.（★）将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素，而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表A和单链表B的所有结点值，观察输出结果。

二、程序设计的基本思想，原理和算法描述：1、基本操作函数link * get(link *l, int i)；//创建链表link * ins (link *l, int a,int i) //在链表内插入值link * find(link *l, int a)；//在链表内查找值link * del(link *l, int i); //在链表内删除值link * delrepeat( link *l); //在链表内删除重复值link * deleven(link *l); //删除链表内偶数值link * rotate(link *l); //形成循环链表void divide(link *l); //分解成两个链表cout<<endl;2、基本操作cout<<"请选择您要的操作：";cout<<" 1、插入";cout<<" 2、查找";cout<<" 3、删除";cout<<" 4、删除重复结点";cout<<" 5、删除偶数结点";cout<<" 6、构建循环链表";cout<<" 7、分解为两个链表";cout<<" 0、退出";三、源程序及注释：#include <iostream>using namespace std;typedef struct node{int data;struct node *next;}link;void print1(link *l);link * get(link *l, int i){link *p;int j=0;p=l;while((j<i) && (p->next!=NULL)){p=p->next;j++;}if(j==i)return p;elsereturn NULL;}link * ins (link *l, int a,int i){link *p,*s;p=get(l,i-1);if(p==NULL)cout<<"输入有误"<<endl;else{s=(link *)malloc(sizeof(link));s->data=a;s->next=p->next;p->next=s;}return l;}link * find(link *l, int a){link *p;int i=0;int j=0;p=l;while(p!=NULL){i++;if(p->data!=a)p=p->next;else{cout<<"您查找的数据在第"<<i-1<<"个位置."<<endl;j=1;p=p->next;}}if(j!=1)cout<<"您查找的数据不在线性表中."<<endl;return l;}link * del(link *l, int i){link *p,*s;p=get(l,i-1);if(p==NULL)cout<<"输入有误"<<endl;else{s=p->next;p->next=s->next;free(s);}return l;}link * delrepeat( link *l) // 删除相同元素并释放内存{link *s, *r, *t;if ( l-> next == NULL )return l;s = l-> next;while ( s-> next ){t = s; r = s-> next;while ( t-> next ){if ( s-> data == r-> data ){t-> next = r-> next;free(r);r = t-> next;}else{t = t-> next;r = t-> next;}}s = s-> next;if ( !s )return l;}return l;}link * deleven(link *l){link *q=l;link *p=l->next;while(p){if(p->data%2==0){link *r=p;q->next=p->next;p=p->next;free(r);}{p=p->next;q=q->next;}}return l;}link * rotate(link *l){link * p=l;while(p->next)p=p->next;p->next=l;link * t=l->next;while(t!=l){t=t->next;}cout<<"已经变为循环链表，其他操作将受影响,程序结束！"<<'\n';return l;}void divide(link *l){link * a=l;link * b=(link *)malloc(sizeof(node));b->next=NULL;link *Lb=b;int i=1;link * La=l;link * p=l->next;while(p){if(i++%2==0){La->next=p->next;p->next=NULL;Lb->next=p;Lb=Lb->next;p=La->next;}{p=p->next;La=La->next;}}cout<<"链表a";print1(a);cout<<"链表b";print1(b);}void print1(link *l){int i,k;int a;link *p,*q;cout<<"当前线性表为："<<endl;p=l;p=p->next;if(l!=NULL)do{cout<<p->data<<" ";p=p->next;}while(p!=NULL);cout<<endl;}link * print(link *l){int i,k;int a;link *p,*q;cout<<"当前线性表为："<<endl;p=l;p=p->next;if(l!=NULL)do{cout<<p->data<<" ";p=p->next;}while(p!=NULL);cout<<endl;cout<<"请选择您要的操作：";cout<<" 1、插入";cout<<" 2、查找";cout<<" 3、删除";cout<<" 4、删除重复结点";cout<<" 5、删除偶数结点";cout<<" 6、构建循环链表";cout<<" 7、分解为两个链表";cout<<" 0、退出";cout<<endl;cin>>k;if(k==1){cout<<"请输入您要插入的数据值：";cin>>a;cout<<"请输入您要插入的位置：";cin>>i;p=ins(l,a,i);q=print(l);}else if(k==2){cout<<"请输入您要查找的数据值：";cin>>a;p=find(l,a);q=print(l);}else if(k==3){cout<<"请输入您要删除的数据的位置：";cin>>i;p=del(l,i);q=print(l);}else if(k==4){cout<<"删除重复结点后的";p=delrepeat(l);q=print(l);}else if(k==5){cout<<"删除偶数结点后的";p=deleven(l);q=print(l);}else if(k==6){p=rotate(l);q=print(l);}else if(k==7){divide(l);}else if(k==0);else{cout<<"输入错误!"<<endl;}return l;}int main(){cout<<"请输入20个整数："<<endl;int ch[20];int i;//link *head;link *r,*p,*q,*l;l=(link *)malloc(sizeof(link));l->next=NULL;r=l;for(i=0;i<20;i++){cin>>ch[i];p=(link *)malloc(sizeof(link));p->data=ch[i];p->next=NULL;r->next=p;r=r->next;}q=print(l);return 0;}四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：1、本次实验采用C++语言，程序基本能实现实验所要求的操作功能，但是首次使用C++来完成所有链表的操作，有很多小细节不够注意，比如定义结点与结点的使用，需要多操作，多熟悉语。