双向循环链表,最易读懂的插入,删除,查找,并且显示长度
#include
#include
typedef struct list
{
int data;
struct list *left,*next;
}List;
////*************** 建立空链表*******************/////
List * CreatList( void )
{
List * head=(List *)malloc(sizeof(List));
if(head==NULL)
{
printf("分配失败！\n");
return 0;
}
head->left=head->next=head; //双向链表结束标志为，尾到了头！
return head;
}
int InsertList(List * head,int value) //头结点是确定的，不需要每次都返回头结点了！！！{
List *newnode,*p;
if(head==NULL)
{
//你建立的是个带头结点的表，如果表是头是空，那么应该报错了！
printf("no head node！\n");
return -1;
}
newnode=(List *)malloc(sizeof(List));
if(newnode==NULL)
{
printf("分配失败！\n");
return -1;
}
newnode->data=value;
p=head ;
while(p->next!=head) //这里是为了找到表尾
{
p=p->next;
}
/**//**//**//**//**//**//**//**//**//**//**//**//**//**/
/***************将数据插入表尾位置*********************/ /**/ newnode->next=p->next ; /**/
/**/ p->next=newnode; /**/
/**/ newnode->left=p; /**/
/**//**//**//**//**//**//**//**//**//**//**//**//**//**/
////free(newnode); //这个结点（指针）你还要用，不能释放。
return 0;
}
void Find(List *head,int find)///查找并显示位置
{
List *p;
int i=0;
p=head;
while(p!=head)
{
p=p->next;
i+=1;
if(p->data==find)
{
printf("要查找的数%d 是第%d 个\n",find,i);
}
}
if(p->data!=find && p->next==head)
{
printf("连表里没有要查找的数%d！\n",find);
}
}
void print(List *head)//打印链表，并显示长度
{
//head=(List *)malloc(sizeof(List)); 遍历表不需要新分配空间！这样做会丢失掉原有的地址！！改成如下：
int i=0;
List *p=head->next ;
while(p!=head) //head一直要保证不变，这样，你才能正常转一圈
{
printf("%d ",p->data);
p=p->next;
i+=1;
}
printf("链表长度为%d \n",i);
printf("\n");
}
List * Delete(List *head ,int x)///删除数据操作
{
List *p;
int i=0;
p=head->next;
p=p->next;
while(p->next!=head)
{
p=p->next;
i+=1;
if(p->data!=x && p->next==head)
{
printf("没有要删除的数%d！\n",x);
}
else if(p->data==x)
{
/**//**//**//**//**//**//**//**//**//**//**//**//**//**/
/*************** 将数据删除操作*********************/
/**/ p->left->next=p->next; /**/
/**/ p->next->left=p->left; /**/
/**/ p=p->next; /**/
/**//**//**//**//**//**//**//**//**//**//**//**//**//**/
printf("要删除的数%d 是第%d 个\n",x,i);
}
}
return head;
}
int main()
{
List *head=NULL;
//CreatList(head); 这句带不回来指针值的！！！
head= CreatList();
InsertList(head,10);
print(head); //
Delete(head,10);
print(head);
Find(head,10);
return 0;
}
C语言链表的建立、插入和删除
数组作为存放同类数据的集合，给我们在程序设计时带来很多的方便，增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定，不能在程序中进行调整，这样一来，在程序设计中针对不同问题有时需要3 0个大小的数组，有时需要5 0个数组的大小，难于统一。我们只能够根据可能的最大需求来定义数组，常常会造成一定存储空间的浪费。我们希望构造动态的数组，随时可以调整数组的大小，以满足不同问题的需要。链表就是我们需要的动态数组。它是在程序的执行过程中根据需要有数据存储就向系统要求申请存储空间，决不构成对存储区的浪费。 链表是一种复杂的数据结构，其数据之间的相互关系使链表分成三种：单链表、循环链表、双向链表，下面将逐一介绍。 7.4.1 单链表 图7 - 3是单链表的结构。 单链表有一个头节点h e a d，指向链表在内存的首地址。链表中的每一个节点的数据类型为结构体类型，节点有两个成员：整型成员（实际需要保存的数据）和指向下一个结构体类型节点的指针即下一个节点的地址（事实上，此单链表是用于存放整型数据的动态数组）。链表按此结构对各节点的访问需从链表的头找起，后续节点的地址由当前节点给出。无论在表中访问那一个节点，都需要从链表的头开始，顺序向后查找。链表的尾节点由于无后续节点，其指针域为空，写作为N U L L。 图7 - 3还给出这样一层含义，链表中的各节点在内存的存储地址不是连续的，其各节点的地址是在需要时向系统申请分配的，系统根据内存的当前情况，既可以连续分配地址，也可以跳跃式分配地址。 看一下链表节点的数据结构定义： struct node { int num; struct node *p; } ; 在链表节点的定义中，除一个整型的成员外，成员p是指向与节点类型完全相同的指针。在链表节点的数据结构中，非常特殊的一点就是结构体内的指针域的数据类型使用了未定义成功的数据类型。这是在C中唯一规定可以先使用后定义的数据结构。 ?单链表的创建过程有以下几步： 1 ) 定义链表的数据结构。 2 ) 创建一个空表。 3 ) 利用m a l l o c ( )函数向系统申请分配一个节点。 4 ) 将新节点的指针成员赋值为空。若是空表，将新节点连接到表头；若是非空表，将新 节点接到表尾。 5 ) 判断一下是否有后续节点要接入链表，若有转到3 )，否则结束。 ?单链表的输出过程有以下几步 1) 找到表头。
双向循环链表的建立插入与删除
创建双向循环链表的源代码： #include
L->Length ++; } } //结点的输出 void Display( DuLinkList L) { DuLinkList p; printf("双向循环链表中的结点的数据为:"); for(p=L->next ;p->next !=L;) { printf("%d",p->data); printf(" 、"); p=p->next ; } printf("%d\n",p->data ); } int main() { DuLinkList L; int n,i; InitList(&L) ; printf("你想创建几个循环节点就输入几就行啦，请输入:"); scanf("%d",&n); Create(L,n); Display(L); } 双向循环链表插入源代码： #include
《数据结构》实验报告 设计循环单链表
《数据结构》实验报告 1、实验名称:设计循环单链表 2、实验日期: 2013-3-26 3、基本要求： 1）循环单链表的操作，包括初始化、求数据元素个数、插入、删除、取数据元素； 2）设计一个测试主函数实际运行验证所设计循环单链表的正确性。 4、测试数据： 依次输入1，2，3，4，5，6，7，8，9，10，删除5，再依次输出数据元素。 5、算法思想或算法步骤: 主函数主要是在带头结点的循环单链表中删除第i个结点，其主要思想是在循环单链表中寻找到第i-1个结点并由指针p指示，然后让指针s指向a[i]结点，并把数据元素a[i]的值赋给x，最后把a[i]结点脱链，并动态释放a[i]结点的存储空间。 6、模块划分： 1）头文件LinList.h。头文件LinList.h中包括：结点结构体定义、初始化操作、求当前数据个数、插入一个结点操作、删除一个结点操作以及取一个数据元素操作； 2）实现文件dlb.cpp。包含主函数void main(void)，其功能是测试所设计的循环单链表的正确性。
7、数据结构： 链表中的结点的结构体定义如下： typedef struct Node { DataType data; struct Node *next; }SLNode; 8、源程序： 源程序存放在两个文件中，即头文件LinList.h和实现文件dlb.cpp。//头文件LinList.h typedef struct Node { DataType data; struct Node *next; }SLNode; void ListInitiate(SLNode **head) //初始化 { *head=(SLNode *)malloc(sizeof(SLNode)); //申请头结点，由head指示其地址 (*head)->next=*head; }
数据结构--单链表的插入和删除
单链表的插入和删除实验日志 指导教师刘锐实验时间2010 年10 月11 日 学院数理专业数学与应用数学 班级学号姓名实验室S331-A 实验题目：单链表的插入和删除 实验目的：了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。 实验要求：建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。 实验主要步骤： 1、分析、理解程序(相关程序见附录) 。 2、调试程序，并设计输入字符串数据（如：aa, bb , cc , dd, ee，#），测试程序的如下功能： 不允许重复字符串的插入；根据输入的字符串，找到相应的结点并删除。 3、修改程序： （1）增加插入结点的功能。 （2）将建立链表的方法改为头插入法。 实验结果： 1、不允许重复字符串的插入功能结果如下：
3、删除和插入结点的功能如下：
心得体会： 通过这次实验我学会了单链表的建立和删除，基本了解了线性表的逻辑结构和链式存储结构，掌握了单链表的基本算法，使我受益匪浅。在调试程序的过程中，遇见了一系列的问题，后来在同学的帮助下，修改了几个语句后，终于把它给调试出来了。有时候一个标点符号的问题就可能导致程序无法运行。所以在分析调试程序的时候一定要仔细。 附加程序代码： 1、调试之后的程序如下（其中蓝色字体部分为修改过的）： #include"stdio.h" #include"string.h" #include"stdlib.h" #include"ctype.h" typedef struct node //定义结点 { char data[10]; //结点的数据域为字符串 struct node *next; //结点的指针域 }ListNode; typedef ListNode * LinkList; // 自定义LinkList单链表类型 LinkList CreatListR1(); //函数，用尾插入法建立带头结点的单链表ListNode *LocateNode(); //函数，按值查找结点
数据结构课程设计单链表操作
《数据结构课程设计》报告 题目：单链表操作 专业：计算机科学与技术 班级： 单链表操作 针对带头结点的单循环链表，编写实现以下操作的算法函数。
实现要求： ⑴单链表建立函数create：先输入数据到一维数组A[M]中，然后根据一维 数组A[M]建立一个单循环链表，使链表中个元素的次序与A[M]中各元素的次序相同，要求该函数的时间复杂度为O(m)； ⑵定位查找函数Locate：在所建立的单循环链表中查找并返回值为key的 第1个元素的结点指针；若找不到，则返回NULL； ⑶求出该链表中值最大和次大的元素值，要求该算法的时间复杂度为O(m)， 最大和次大的元素值通过指针变量带回，函数不需要返回值； ⑷将链表中所有值比key(值key通过形参传入)小的结点作为值为key的结 点前驱，所有值比key大的结点作为值为key的结点后继，并尽量保持原有结点之间的顺序，要求该算法的时间复杂度为O(m); ⑸设计一个菜单，具有上述处理要求和退出系统功能。 ⒈本人完成的工作： 一、定义结构体：LNode 二、编写以下函数： （1）建立单循环链表 （2）建立定位查找函数 （3）求出链表中最大和次大值 （4）将链表中的值和输入的Key比较，小的作为key前驱结点，大的作为key 的后继结点 三、设计具有上述处理要求和退出系统菜单 ⒉所采用的数据结构：单链表 数据结构的定义： typedef struct Node //定义结点的结构体 { DataType data; //数据域 struct Node *next; //指针域
}LNode; //结点的类型 ⒊所设计的函数 （1）Create(void) LNode *Create(void) //建立单循环链表，链表头结点head作为返回值{ int i,j,n,A[M]; //建立数组A【M】 LNode *head,*p,*move; head=(LNode*)malloc(sizeof(LNode)); //创建空单循环链表head->next=head; move=head; printf("请输入数组元素的个数："); //输入数组 scanf("%d",&n); printf("请输入数组："); for(i=0;i
用双向循环链表求解约瑟夫环
用双向循环链表求解约瑟夫环 学校：东北大学 专业：计算机科学与技术
1.问题描述 Josephus排列问题定义如下：假设n个竞赛者排成一个环形。给定一个正整数m≤n，从第1人开始，沿环计数，第m人出列。这个过程一直进行到所有人都出列为止。最后出列者为优胜者。全部出列次序定义了1，2，…n的一个排列。称为（n，m）Josephus排列。例如，（7，3）Josephus排列为3,6,2,7,5,1,4。【实验要求】 设计求解Josephus排列问题程序。 （1）采用顺序表、单链表或双向循环链表等数据结构。 （2）采用双向循环链表实现Josephus排列问题，且奇数次顺时针轮转，偶数次逆时针轮转。 （3）推荐采用静态链表实现Josephus排列问题。 2.需求分析 本程序要求根据输入的人数n和给定的正整数m，求得约瑟夫排列，且奇数次顺时针轮转，偶数次逆时针轮转。故可利用双向循环链表建立存储结构，利用双向循环链表的遍历与删除操作实现功能要求。 3.概要设计 1.抽象数据类型定义： typedef struct DuLNode { int data; struct DuLNode *prior; struct DuLNode *next; }DuLNode,*DuLinkList; //定义双向循环链表 2.基本操作 int InitList_Dul(DuLinkList &L) //建立一个只含头结点的空双向循环链表 int CreateList_DuL(DuLinkList &L,int n) //建立一个带头结点的含n个元素的 双向循环链表L int ListDelete_DuL(DuLinkList &L,DuLinkList x) //删除指针x指向的结点 3.设计思路 首先建立一个双向循环链表作为存储结构，每个结点的数据域存储每个人的编号，然后根据给定的m值对整个链表进行遍历，找到所要找的结点后，输出该结点的数据域的值，并在双向循环链表中删除该结点，重复这样的操作，一直到所有的人都出列，依次输出的数列即为所求的Josephus排列。 4.详细设计 typedef struct DuLNode { int data; struct DuLNode *prior;
数据结构循环链表插入和删除源代码代码
typedef struct LNode//结点类型 { int data;//数值域 struct LNode *next;//指针域 }CrLNode,*CrLinklist; #include"Base.h" #include"construct.h" #include"circulate_operation.c" int main() { CrLinklist L; int i,choice,n,e; printf("请输入链表元素个数:"); scanf("%d",&n); L=Initlist_L(n); printf("请选择执行语句，选择输入1，执行插入操作或选择输入2，执行删除操作:"); scanf("%d",&choice); switch(choice) { case 1: { printf("请输入插入元素的位置:"); scanf("%d",&i); if(i<=0||i>n) printf("您输入的值不合法"); else printf("请输入插入元素的值："); scanf("%d",&e); L=ListInsert_L(L,i,e); printf("插入后的链表为："); printlist_L(L); };break; case 2: { printf("请输入删除元素的位置:"); scanf("%d",&i); if(i<=0||i>n) printf("您输入的值不合法"); else L=ListDelete_L(L,i); printf("删除后的链表为");
printlist_L(L); };break; } } CrLinklist Initlist_L(int n)//创建带头结点的单链表 { CrLinklist L; CrLinklist P; int i; L=(CrLinklist)malloc(sizeof(CrLNode)); L->next=L;/* 先建立一个带头结点的单链表*/ printf("请输入%d个数据\n",n); for(i=n;i>0;--i) { P=(CrLinklist)malloc(sizeof(CrLNode)); /* 生成新结点*/ scanf("%d",&P->data); /* 输入元素值*/ P->next=L->next; /* 插入到表头*/ L->next=P; } return L; } CrLinklist ListInsert_L(CrLinklist L,int i,int e)//单链表的插入 { CrLinklist P,S; int j; P=L; j=0; while(P&&j
单链表转换成双向循环链表
#include
int i=-1; List *p,*data1,*q,*Last; data1=(List *)malloc(sizeof(List)); p=(List *)malloc(sizeof(List)); q=(List *)malloc(sizeof(List)); data1=head->next;//记住第一个数据地址 p=head->next; while(p->next!=NULL) { q=p; //q是前一个节点 p=p->next; //p是后一个节点 p->pre=q; //后一个节点的【前继指针】指向前一个节点的地址} Last=p; //p 就是【最后一个数据】的地址 data1->pre=Last; //【第一个元素】的【前继指针】指向【最后一个元素】的地址Last->next=data1; //【最后一个元素】的【后继指针】指向【第一个元素】的地址//双向链表构成 p=Last; printf("\n\n"); while(p->data!=1) { printf("%d ",p->data); p=p->pre; } printf("%d \n",p->data); }
双向链表基本操作
双向链表 输入一个双向链表，显示些双向链表并对此双向链表排序运行结果： 源程序： #include
typedef struct Link/*双向链表结构体*/ { int data; struct Link *lift; struct Link *right; }linkx,*linky; linky Init();/*建立双向链表*/ void PrLink(linky p);/*输出双向链表*/ linky Sort(linky head);/*对双向链表排序*/ linky Swap(linky head,linky one,linky two);/*任意交换双向链表两个结点的地址*/ void main(void) { linky head; head=Init(); head=Sort(head); PrLink(head); } linky (Init())/*建立链表*/ { linky p,q,head; int n=0; head=p=q=(linky)malloc(sizeof(linkx)); printf("排序前的链表: "); scanf("%d",&p->data);/*输入数据*/ head->lift=NULL; n++; while(n!=10)/*一直输入到规定的数字个数停止*/ { q=p;
p=(linky)malloc(sizeof(linkx)); scanf("%d",&p->data);/*输入数据*/ q->right=p; p->lift=q; n++; } p->right=NULL; return(head); } linky Swap(linky head,linky one,linky two)/*任意交换两个结点*/ {linky temp; if(one->lift==NULL&&two->right==NULL)/*首和尾巴的交换*/ { if(one->right==two)/*只有两个结点的情况下*/ { two->right=one; two->lift=NULL; one->lift=two; one->right=NULL; head=two; } else/*有间隔的首尾交换*/ { one->right->lift=two; two->lift->right=one; two->right=one->right; one->lift=two->lift; two->lift=one->right=NULL; head=two;/*尾结点成为头结点*/ }
C++链表的插入删除及查找
/*从键盘读入一个字符串，把它存入一个链表（每个结点存储1个字符），并按相反的次序将字符串输出到显示屏。 要求至少写出以下方法或函数，初始化链表、插入结点、删除结点、查找、显示、销毁链表*/ #include
return; } if(n==1) { s->next=head; head->last=s; head=s; return; } p=head; for(int i=1;i
第三章 单链表 题目和答案
第2章自测卷答案 一、填空 1.顺序表中逻辑上相邻的元素的物理位置相互相邻。单链表中逻辑上相邻的元素的物理位置不 相邻。 2.在单链表中，除了首元结点外，任一结点的存储位置由其直接前驱结点值域指示。 3．在n个结点的单链表中要删除已知结点*p，需找到它的地址。 二、判断正误（在正确的说法后面打勾，反之打叉） 1. 链表的每个结点中都恰好包含一个指针。X 2. 链表的物理存储结构具有同链表一样的顺序。X 3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。X 4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。Y 5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。Y 6. 顺序存储方式的优点是存储密度大，且插入、删除运算效率高。X 7. 线性表在物理存储空间中也一定是连续的。X 8. 线性表在顺序存储时，逻辑上相邻的元素未必在存储的物理位置次序上相邻。X 9. 顺序存储方式只能用于存储线性结构。X 10. 线性表的逻辑顺序与存储顺序总是一致的。X 三、单项选择题 （A）1. 链接存储的存储结构所占存储空间： （A）分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针 （B）只有一部分，存放结点值 （C）只有一部分，存储表示结点间关系的指针 （D）分两部分，一部分存放结点值，另一部分存放结点所占单元数 （B）2. 链表是一种采用存储结构存储的线性表； （A）顺序（B）链式（C）星式（D）网状 （D）3. 线性表若采用链式存储结构时，要求内存中可用存储单元的地址: （A）必须是连续的（B）部分地址必须是连续的 （C）一定是不连续的（D）连续或不连续都可以 （B）4．线性表Ｌ在情况下适用于使用链式结构实现。 （Ａ）需经常修改Ｌ中的结点值（Ｂ）需不断对Ｌ进行删除插入 （Ｃ）Ｌ中含有大量的结点（Ｄ）Ｌ中结点结构复杂 （C）5．单链表的存储密度 （Ａ）大于1；（Ｂ）等于1；（Ｃ）小于1；（Ｄ）不能确定 （A）6、在单链表的一个结点中有个指针。
双向循环链表list
list是双向循环链表，，每一个元素都知道前面一个元素和后面一个元素。在STL 中，list和vector 一样，是两个常被使用的容器。和vector不一样的是，list不支持 对元素的任意存取。list中提供的成员函数与vector类似，不过list提供对表首元素的操作 push_front、pop_front，这是vector不具备的。禾口vector另一点不同的是，list的迭代器不会存在失效的情况，他不像vector会保留备份空间，在超过容量额度时重新全部分配内存，导致迭代器失效；list没有备份空间的概念，出入一个元素就申请一个元素的空间，所以它的迭代器不会失效。还是举《C++之vector》中的 例子： int data[6]={3,5,7,9,2,4}; list< int> lidata(data, data+6); lidata.push_back(6); list初始化时，申请的空间大小为6，存放下了data中的6个元素，当向lidata插入第7个元素“6”，list申请新的节点单元，插入到list链表中，数据存放结构如图1所示： 插入节点"6拆之后的list 图1 list的存储结构 list每次增加一个元素，不存在重新申请内存的情况，它的成本是恒定的。而vector每当增加关键元素的时候，都需要重新申请新的更大的内存空间，会调用元素的自身的复制构造函数，存在构造成本。在销毁旧内存的时候，会调用析构函数, 存在析构成本。所以在存储复杂类型和大量元素的情况下，list比vector更有优势！ List是一个双向链表,双链表既可以向前又向后链接他的元素。
数据结构实验 建立双向循环链表以及插入删除操作
实验一 要求：①建立双向循环链表 ②实现链表的插入、删除 运行程序点此处Demo_1.exe 实验程序源代码： #include "stdafx.h" #include
p->next =q; q->prior=p; q->next=L; L->prior =q; p=q; L->Length ++; } } //查找元素的位置 DuLinkList GetElemP(DuLinkList h,int i) { int j; DuLinkList p=h; for(j=1;j<=i;j++) p=p->next ; return p; } //结点的插入 status Listinsert(DuLNode *m,int i,int e) { //在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长 DuLinkList p,q; if(i<1||i>(m->Length)) // i值不合法 return ERROR; p=GetElemP(m,i); if(!p) return ERROR; q=(DuLinkList)malloc(sizeof(DuLNode)); if(!q) return OVERFLOW; q->data=e; q->prior=p->prior; p->prior->next=q; q->next=p; p->prior=q; m->Length++; printf("您在双向循环链表第%d个位置之前插入了一结点元素:%d\n",i,e); return OK; } //结点的删除 status ListDelete(DuLinkList L,int i) { //删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
在单向链表中删除偶元素结点
实验报告名称：线性表及其应用 实验目的： 1．掌握单向链表的存储特点及其实现。 2．掌握单向链表的插入、删除算法及其应用算法的程序实现。实验报告（实验内容、实验步骤、实验运行结果分析、实验小结） 实验内容： 在单向链表中删除所有的偶数元素结点。 #include
} void shanou(link head) { link p,q; q=head; p=head->next; while(p) { if((p->data%2!=0)) { p=p->next; q=q->next; } else {q->next=p->next; p=p->next; } } printf("shanou后的链式表为：\n"); p=head->next; while(p) {printf("%3d",p->data); p=p->next; } printf("\n"); } void main() {link head; int n; printf("请输入线性表L的长度:\n"); scanf("%d",&n); head=createlink(n); print(head); shanou(head); } 运行结果：
循环双向链表
#include
typedef struct node { ElemType data; struct node *prior, *next; }DLink; void InitList(DLink **L); //初始化运算 int GetLength(DLink *L); //求表长运算 int GetElem(DLink *L, int num, ElemType *e); //求线性表中第i个元素运算int Locate(DLink *L, ElemType x); //按值查找运算 int InsElem(DLink *L, ElemType x, int i); //插入节电运算 int DelElem(DLink *L, int num); //删除结点运算 void DispList(DLink *L); //输出线性表 #endif [cpp] view plaincopyprint? #include
链表的插入、删除实例,C语言 结构体
int main() { pNode pHead = NULL; // 定义初始化头节点，等价于struct Node *pHead == NULL int data; // 作为Insert_Node函数的第三个参数 int num; // 作为Inset_Node函数第二个参数 int choose; int return_val; pHead = CreateList(); // 创建一个非循环单链表，并将该链表的头结点的地址付给pHead printf("你输入的数据是："); TraverseList(pHead); // 调用遍历链表函数 printf("是否还要进行如下操作：\n"); printf("1.插入数据 2.删除数据\n"); printf("请输入："); scanf("%d",&choose); switch (choose) { case 1: { printf("请输入要在第几个节点前插入数据："); scanf("%d",&num); printf("请输入要插入的数据："); scanf("%d",&data); if(Insert_Node(pHead,num,data) == true) { printf("插入成功\n插入后的数据是：\n"); TraverseList(pHead); } else { printf("插入失败\n"); } printf("操作完成后的数据是："); TraverseList(pHead); break; } case 2: { printf("请输入要删除第几个节点的数据："); scanf("%d",&num); return_val = Del_Node(pHead,num); if (return_val == 0) {
数据结构C语言版 循环链表表示和实现
数据结构C语言版循环链表表示和实现.txt37真诚是美酒，年份越久越醇香浓烈；真诚是焰火，在高处绽放才愈显美丽；真诚是鲜花，送之于人，手有余香。/* 数据结构C语言版循环链表表示和实现 P35 编译环境：Dev-C++ 4.9.9.2 日期：2011年2月10日 */ #include
链表的C语言实现之删除结点
链表的C语言实现之删除结点 假如我们已经知道了要删除的结点p的位置，那么要删除p结点时只要令p结点的前驱结点的链域由存储p结点的地址该为存储p的后继结点的地址，并回收p结点即可。 以下便是应用删除算法的实例： #include ＜stdio.h＞ #include ＜malloc.h＞ #include ＜string.h＞ #define N 10 typedef struct node { char name[20]; struct node *link; }stud; stud * creat(int n) /*建立新的链表的函数*/ { stud *p,*h,*s; int i; if((h=(stud *)malloc(sizeof(stud)))==NULL) { printf("不能分配内存空间!"); exit(0); } h-＞name[0]=’\0’; h-＞link=NULL; p=h; for(i=0;i＜n;i ) { if((s= (stud *) malloc(sizeof(stud)))==NULL) { printf("不能分配内存空间!"); exit(0); } p-＞link=s; printf("请输入第%d个人的姓名",i 1); scanf("%s",s-＞name); s-＞link=NULL; p=s; } return(h); } stud * search(stud *h,char *x) /*查找函数*/ {
stud *p; char *y; p=h-＞link; while(p!=NULL) { 软件开发网 y=p-＞name; if(strcmp(y,x)==0) return(p); else p=p-＞link; } if(p==NULL) printf("没有查找到该数据!"); } stud * search2(stud *h,char *x) /*另一个查找函数，返回的是上一个查找函数的直接前驱结点的指针，*/ /*h为表头指针，x为指向要查找的姓名的指针*/ /*其实此函数的算法与上面的查找算法是一样的，只是多了一个指针s，并且s总是指向指针p所指向的结点的直接前驱，*/ /*结果返回s即是要查找的结点的前一个结点*/ { stud *p,*s; char *y; p=h-＞link; s=h; while(p!=NULL) { y=p-＞name; if(strcmp(y,x)==0) return(s); else { p=p-＞link; s=s-＞link; } } if(p==NULL) printf("没有查找到该数据!"); } void del(stud *x,stud *y) /*删除函数，其中y为要删除的结点的指针，x为要删除的结点的前一个结点的指针*/ { stud *s;
- 双向链表基本操作
- 数据结构实验 建立双向循环链表以及插入删除操作
- 双向链表的基本操作和应用实验报告
- 双向循环链表使用实例
- 双向循环链表
- 用双向循环链表求解约瑟夫环
- 双向循环链表
- 双向循环链表
- 双向链表和循环链表
- 双向循环链表list
- 双向循环链表,最易读懂的插入,删除,查找,并且显示长度
- 数据结构实验建立双向循环链表以及插入删除操作
- 双向循环链表操作-二叉树和树操作-图的创建及相关操作的实现(7)
- 循环双向链表
- 双向循环链表操作-二叉树和树操作-图的创建及相关操作的实现(3)
- 第五讲循环链表和双向链表
- 双向循环链表的建立插入与删除
- 双向循环链表操作-二叉树和树操作-图的创建及相关操作的实现(2)
- 用C++编写的双向链表程序示例
- 《数据结构》循环链表双向链表解析