循环链表&双向链表数据结构

1、循环链表结构

void LINKLIST(LINKLIST *rear,DATATYPE2 x) { LINKLIST *p;

p=(LINKLIST *)mailloc(sizeof(LINKLIST)); p->data=x;

p->next=NULL;

if( rear->next==rear)

{ rear->netx=p;

rear=p;

}

else

{ p->next=rear->nexr->next;

rear->next->next=p;

}

主函数

main()

{ LINKLIST *rear,*head,*p,*q;

head=rcreate();

q=head->next;

while(q->next!=NULL)

q=q->next;

q->next=head;

rear=q;

LINKLIST(rear,'m');

p=rear->next;

q=p->next;

while(q!=p)

{ printf("%c",q->data);

q=p->next;

}

2双向链表结构

typedefstruct node

{ DATATYPE2 data;

struct node *next, *prior;

}DLINKLIST;

双向链表插入操作

void DINSERT(DLINKLIST *P,DATATYPE2 x) { DLINKLIST *s;

s=(DLINKLIST *)malloc(sizeof(DLINKLIST)); s->data=x;

p->prior->next=s;

s->prior=p->prior;

s->next=p;

p->prior=s;

}

双向链表删除操作

void DDELETE(DLINKLIST) { p->prior->next=p->next; p->next->prior=p->prior; free(p);

}

数据结构—链表应用能力测评

任务：编写一个能向表尾插入结点，并输出链表中所有数据元素的小程序

#ifndef _LINKLIST #define _LINKLIST #include using namespace std ; struct node { int data ; struct node *next ; }; typedef struct node *PLIST; typedef struct node NODE; /*创建链表，并初始化链表元素*/ PLIST createList_link() { PLIST head ,tail ,temp; int elem = -1; head = new NODE; //初始化头结点 if( head == NULL) { cout<<"分配空间失败,链表创建失败"<next = NULL; tail = head ; while(1) { cin >> elem ; if(elem == 0 ) break ; temp = new NODE ; if(temp == NULL) { cout<<"分配空间失败,链表创建失败"<data = elem ; temp->next = NULL ; tail->next = temp ; tail = temp; } return head ;

} void printList_link(PLIST head ) { /*在此处完成任务，输出head为表头的单链表数据元素*/ //begin PLIST p =new NODE; p=head->next; while(p){ printf("%d ",p->data); p=p->next; } //end } void insertDataTail(PLIST head , int insData ) { /*在此处完成任务，在head为表头的单链表表尾插入数据元素insData*/ //begin PLIST p; p=head->next; while(p->next!=NULL){ p=p->next; } PLIST q = new NODE; //初始化结点 p->next=q; q->data=insData; q->next=NULL; //end } #endif

数据结构单链表详解

数据结构的概念：数据的逻辑结构+ 数据的存储结构+ 数据的操作；数据的数值：=====》数据===》数值型数据整形浮点数ASCII 非数值型数据图片声音视频字符 =====》数据元素=====》基本项组成（字段，域，属性）的记录。数据的结构：逻辑结构 ----》线性结构（线性表，栈，队列） ----》顺序结构 ----》链式结构 ----》非线性结构(树，二叉树，图) ----》顺序结构 ----》链式结构存储结构 -----》顺序存储 -----》链式存储 -----》索引存储 -----》哈希存储==散列存储数据的操作：增删改查 DS ====》数据结构===》DS = (D,R); 数据结构中算法： 1、定义：有穷规则的有序集合。 2、特性：有穷性确定性

输入输出 3、算法效率的衡量时间复杂度计算===》算法中可执行依据的频度之和，记为：T(n)。是时间的一种估计值不是准确值。计算结果的分析：1 将最终结果的多项式中常数项去掉 2 只保留所有多项式中最高阶的项 3 最后的最高阶项要去掉其常数项时间复杂度的量级关系：常量阶====》对数阶===》线性阶===》线性对数阶====》平方阶===》立方阶===》指数阶以上关系可以根据曲线图来判断算法对时间复杂度的要求空间复杂度计算====》算法执行过程中所占用的存储空间的量级，记为：D（n）。计算方法是在运行过程中申请的动态内存的量级计算。 ///////////////////////////////////////////////////////////////////////////////////////////////// 线性表顺序存储====》顺序表（数组）链式存储====》单链表特征：对于非空表，a0是表头没有前驱。 an-1 是表尾没有后继 ai的每个元素都有一个直接前驱和直接后继基本操作：创建表=====》增加元素====》删除元素====》改变元素值====》查询元素 1、顺序表的操作 1.1 创建顺序表=====》定义个指定类型的数组====》int a[100] ={0};

数据结构单链表基本操作代码

实验一单链表 #include "stdio.h" #include "stdlib.h" typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; void creatLNode(LinkList &head) { int i,n; LNode *p; head=(LNode*)malloc(sizeof(LNode)); head->next=NULL; printf("请输入链表的元素个数："); scanf("%d",&n); for(i=n;i>0;i--) { p=(LNode*)malloc(sizeof(LNode)); printf("第%d个元素：",i); scanf("%d",&p->data); p->next=head->next; head->next=p; } } void InsertLNode(LinkList &L) { LNode *p=L; int i,j=0,e; printf("请输入你要插入的位置（超过链表长度的默认插在最后！）："); scanf("%d",&i); printf("请输入你要插入的元素："); scanf("%d",&e); while (p->next&&jnext; ++j; }

LNode *s; s=(LNode*)malloc(sizeof(LNode)); s->data=e; s->next=p->next; p->next=s; } int DeleteLNode(LinkList &L,int i,int &e) { LNode *p; p=L; LNode *q; int j=0; while (p->next&&jnext; ++j; } if(!(p->next)||j>i-1) { printf("删除位置不合理!\n"); return 0; } q=p->next; p->next=q->next; e=q->data; free(q); return e; } void DeleteCF(LinkList &L) { LNode *p,*s,*r; p=L->next; while(p!=NULL) { r=p; s=r->next; while(s!=NULL) { if(p->data==s->data) { r->next=s->next; s=s->next;

数据结构课程设计单链表操作

《数据结构课程设计》报告题目：单链表操作专业：计算机科学与技术班级：单链表操作针对带头结点的单循环链表，编写实现以下操作的算法函数。

实现要求： ⑴单链表建立函数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;idata=A[j]; p->next=move->next; move->next=p; move=move->next; } return head; //返回头指针

数据结构课程设计单链表

目录 1 选题背景 (2) 2 方案与论证 (3) 2.1 链表的概念和作用 (3) 2.3 算法的设计思想 (4) 2.4 相关图例 (5) 2.4.1 单链表的结点结构 (5) 2.4.2 算法流程图 (5) 3 实验结果 (6) 3.1 链表的建立 (6) 3.2 单链表的插入 (6) 3.3 单链表的输出 (7) 3.4 查找元素 (7) 3.5 单链表的删除 (8) 3.6 显示链表中的元素个数（计数） (9) 4 结果分析 (10) 4.1 单链表的结构 (10) 4.2 单链表的操作特点 (10) 4.2.1 顺链操作技术 (10) 4.2.2 指针保留技术 (10) 4.3 链表处理中的相关技术 (10) 5 设计体会及今后的改进意见 (11) 参考文献 (12) 附录代码： (13)

1 选题背景陈火旺院士把计算机60多年的发展成就概括为五个“一”：开辟一个新时代----信息时代，形成一个新产业----信息产业，产生一个新科学----计算机科学与技术，开创一种新的科研方法----计算方法，开辟一种新文化----计算机文化，这一概括深刻影响了计算机对社会发展所产生的广泛而深远的影响。数据结构和算法是计算机求解问题过程的两大基石。著名的计算机科学家P.Wegner指出，“在工业革命中其核心作用的是能量，而在计算机革命中其核心作用的是信息”。计算机科学就是“一种关于信息结构转换的科学”。信息结构（数据结构）是计算机科学研究的基本课题，数据结构又是算法研究的基础。

2 方案与论证 2.1 链表的概念和作用链表是一种链式存储结构，链表属于线性表，采用链式存储结构，也是常用的动态存储方法。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。以“结点的序列”表示线性表称作线性链表（单链表）单链表是链式存取的结构，为找第 i 个数据元素，必须先找到第 i-1 个数据元素。因此，查找第 i 个数据元素的基本操作为：移动指针，比较 j 和 i 单链表 1、链接存储方法链接方式存储的线性表简称为链表（Linked List）。链表的具体存储表示为： ① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的） ② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)）注意：链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。 2、链表的结点结构 ┌───┬───┐ │data │next │ └───┴───┘ data域--存放结点值的数据域 next域--存放结点的直接后继的地址（位置）的指针域（链域）注意： ①链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。 ②每个结点只有一个链域的链表称为单链表（Single Linked List）。

数据结构(C语言)单链表的基本操作

实验名称：实验一单链表的基本操作实验目的熟练掌握线性表两类存储结构的描述方法。实验内容从键盘读入若干个整数，建一个整数单链表，并完成下列操作：（1）打印该链表；（2）在链表中插入一个结点，结点的数据域从键盘读入，打印该链表；（3）在链表中删除一个结点，被删结点的位置从键盘读入，打印该链表；（4）在链表中做查找：从键盘读入要查找的整数，将该整数在链表中的位置打印出来，若要查找的整数不在链表中，返回一个信息。算法设计分析（一）数据结构的定义单链表存储结构定义为： struct Node; typedef struct Node * pnode; struct Node { int info; pnode link; }; typedef struct Node * LinkList; （二）总体设计程序由主函数、创建单链表函数、链表长度函数、链表打印函数、插入正整数函数、删除函数、查询函数组成。其功能描述如下：（1）主函数：调用各个函数以实现相应功能 int main(void) //主函数 { printf("单链表的基本操作实验：\n"); struct list *pnode; pnode = creat(); //创建 print(pnode); //输出 insert(pnode); //插入 print(pnode); //输出 _delete(pnode); //删除 print(pnode); //输出 _located(pnode); //查找 print(pnode); //输出 return 0 ; } （三）各函数的详细设计： Function1: struct list *creat()//创建链表；

双向链表实验报告

13软工转本1 钱剑滨实验报告双向链表实验报告信息工程系 13软工转本1 日期 2016年03月12日姓名钱剑滨学号 13131116 电话一、实验内容编写关于双向链表操作的C语言程序，要求包含双向链表的创建（生成）、输出（遍历）、查找、任意位置插入、有顺序插入、删除、等。二、实验步骤 1.分析操作所需思路，熟练运用单链表的各种特点。 2.编写程序，利用函数特性进行操作。 3.运行程序，纠正错误，对预测结果进行验证。 4.分析总结单链表的优缺点，并可以做到熟练掌握双向链表的各种操作。三、设计概要 1.本实验包含了7个函数： a)主函数main() b)创建链表函数Listcreate() c)数据输出函数Listprint() d)查找数据函数Listlocate() e)无序插入函数Listinsert_discretion () f)有序插入函数Listinsert_order g)删除数据函数Listdelete() 2.明确函数的功能； a)Listcreate() 创建一个可控长度的斐波那契数列的双向链表。 b)Listprint() 将此链表中的数据全部输出。 c)Listlocate() 查找此链表中任意位置元素的值。 d)Listinsert_discretion ()向此链表的某个位置插入一组数据。 e)Listinsert_order() 向数列中插入一个数，使插入后的数列任然有序 f)Listdelete() 将此链表的某个位置的一组数据删除。

四、程序设计 1.函数前包含的头文件名、结点类型定义、全局变量和函数声明 #include #include typedef struct number //定义结构体 { struct number *prior； int num; struct number *next; }number; number *head; //定义全局变量头节点 int k = 0; //k记录元素个数，防止溢出 /*函数声明*/ void Listcreate(); //建立链表 void Listprint(); //全体输出 void Listlocate(); //查找 void Listinsert_discretion(); //任意位置插入 void Listinsert_order(); //有顺序插入 void Listdelete(); //删除 2.主函数main() void main() { int select; printf("1、输入斐波那契数列的个数\n"); printf("2、全部输出数列\n"); printf("3、查找定位数列的元素\n"); printf("4、添加数列元素\n"); printf("5、插入顺序数列元素\n"); printf("6、删除数列元素\n"); printf("-------------------------------------\n"); while (1) { printf("请选择序号\n"); scanf("%d", &select); switch (select) { case 1: Listcreate(); break; //链表创建 case 2: Listprint(); break; //全链表输出 case 3: Listlocate(); break; //元素查找 case 4: Listinsert_discretion(); break; //任意位置插入

数据结构链表代码

#include typedef struct lnode{ int data; lnode *next; }lnode; void initlist(lnode *&head){ head=new lnode; head->next=NULL; }//带头结点空链表的判断条件 /*void initlistn(lnode *&head,int n){ initlist1(head); lnode *s; for(int i=0;i>s->data; s->next=head->next; head->next=s; } }//逆序*/ void initlistn(lnode *&head,int n){ initlist(head); lnode *p=head,*s; for(int i=0;i>s->data; s->next=NULL; p->next=s; p=s; } }//正序 void print(lnode *head){ lnode *p=head->next; while(p){ cout<data<<' '; p=p->next; } cout<next;j++;}

if(!p||j>i-1) return; lnode *s=new lnode; s->data=e; s->next=p->next; p->next=s; }//插入 void deletelist(lnode *&head,int i,int &e){ lnode *p=head; int j=0; while(p->next&&jnext;j++;} if(!p->next||j>i-1) return; lnode *q=p->next; e=q->data; p->next=q->next; }//删除 void main(void){ lnode *head; initlistn(head,10); print(head); inserlist(head,6,200); print(head); int e; deletelist(head,8,e); print(head); }

数据结构与算法问题分析与源代码之单链表

单链表 1 题目编写一个程序，实现链表的各种基本运算，包括：链表操作：初始化链表、输出链表、输出链表长度和释放链表链表元素操作：插入元素、删除元素、输出元素（注意元素的位置） 2 目标熟悉单链表的定义及其基本操作的实现 3 设计思想链表由多个结点通过next 指针连接成一个完整的数据结构，每个几点包括一个数据域和一个指向下一个结点的next 指针。通过对指针的改写与结点的增减，我们可以实现单链表的插入、删除、输入、输出、求长等操作。 4 算法描述（1 ）初始化链表：输入元素个数n ，分配n 个结点空间，输入元素值，按元素顺序初始化next 指针，使之连接成串，尾指针赋值NULL 。（2 ）输出链表：从表头开始沿next 指针遍历各结点，每次访问结点输出结点数据值，直至next 为空。（3 ）输出链表长度：从表头开始沿next 指针遍历各结点，每次访问结点计数器加一，直至next 为空，返回计数器值。（4 ）释放链表：沿next 指针从前向后依次释放结点，直至next 指空。（5 ）插入元素：指针沿next 指向移动指定位，新分配一个空间并存入数据，其next 赋值为当前指针指向结点的next ，修改当前指针指向结点的next 指向新加结点。（6 ）删除元素：指针沿next 指向移动指定位，修改待删结点的前一结点的next 指针指向待删结点的下一结点，保存数值，释放删除结点。（7 ）输出元素：指针沿next 指向移动指定位，指针指向结点数据区，读出数值返回。 5 程序结构图 6源程序 #i nclude

#i nclude typedef struct LNode { int data; struct LNode *n ext; }LNode,*Li nkList; Lin kList Ini tList_Li nk(L in kList L) { L=(L in kList)malloc(sizeof(LNode)); L->data = 0; L->next = NULL; return L; } void Createlist(L in kList L) { int n; int i; int temp; LinkList T; printf(" 输入链表元素个数:"); scanf("%d",&n); L->data=n; printf(" 输入元素值:\n"); T=L; for (i=n;i>0;i--) { LinkList p=(LinkList)malloc(sizeof(LNode)); scanf("%d",&temp); p->next=T->next; p->data = temp; T->next=p; T=p; L->data++; } printf(" 成功建立链表"); } void DestroyList_Link(LinkList L) { LinkList p = L,q = L; while(p) { p = p->next; free(q);

数据结构单链表、双链表的逆置算法

数据结构与算法的课程设计课程设计题目：数据结构的逆置算法院系名称：信息技术学院专业（班级）：计算机2班姓名：学号：指导教师：

实验内容：分别用一维数组，单链表，双链表实现逆置（一）使用一维数组实现逆置 1.需求分析：定义一个一维数组（整型），用for语句实现循环，给数组元素赋值，并将数组元素逆序输出。 2.详细设计： main() { int a[3],i; /*定义元素个数为3的一维数组*/ for(i=0;i<3;i++) scanf("%d",&a[i]); for(i=2;i>=0;i--) printf("%d ",a[i]); getch(); } 3.运行及调试： 4.附录： #include void main() { int a[3],i; /*定义一维数组*/ for(i=0;i<3;i++) scanf("%d",&a[i]); for(i=2;i>=0;i--) printf("%d ",a[i]); getch(); } （二）单链表实现逆置 1.需求分析：创建一个单链表并实现逆序输出 2.详细设计：定义的所有数据类型，对每个操作写出伪码算法；对主程序和其他模块也都写出伪码算法。（1）单链表的定义 typedef struct node

{ int data;/*数据域为整型*/ struct node* next; /*定义结点的指针域*/ }LinkList;/*数据结点*/ （2）头插法建立单链表 Tnode *CreatList() { Tnode *head; /*头指针*/ LinkList *p;/*工作指针/ int ip; head=(Tnode *)malloc(sizeof(Tnode)); head->next=NULL;/*链表开始为空*/ printf("please input the number:\n"); scanf("%d",&ip); /*向链表中添加元素*/ while(ip!=000) { p=(LinkList *)malloc(sizeof(LinkList));/*生成新结点*/ p->data=ip; /*将值赋给新生结点*/ p->next=head->next; head->next=p; scanf("%d",&ip); } if(ip==000) /*当输入的数值为000时结束*/ printf("\nthe ip is end!\n\n"); return head; } （3）读取链表中的数据 void ReadList(Tnode *head) { LinkList *p; p=head->next; while(p) { printf("%d ",p->data); p=p->next; } printf("\n"); } （4）链表的倒置 void ExchangeList(Tnode *head) { LinkList *r,*s; r=head->next; head->next=NULL; while(r) { s=r->next; r->next=head->next; head->next=r; r=s;

数据结构双向链表实战应用(c语言源程序)

#include #include typedef struct nodes { char data; struct nodes *front; struct nodes *next; }*LinkList; int main(void) { int i=0; LinkList head_1=0,head_2=0; LinkList InitList(void);//创建不带头接点的双链表 void OutPutList(LinkList head); LinkList ChangeList(LinkList head,int m);//假如head指向abcde,如输入2，cdeab,如输入-2，则为deabc void FreeList(LinkList head); head_1=InitList(); OutPutList(head_1); printf("请输入想要移动的位数i\n"); scanf("%d",&i); head_2=ChangeList(head_1,i); OutPutList(head_2); FreeList(head_1); return 0;

} LinkList InitList(void) { int i=1; char ch;//判断是否还输入 LinkList head=0,r,t;//r指向新创建的结点,t指向r的前一个结点 head=(struct nodes *)malloc(sizeof(struct nodes)); if(!head) { printf("存储空间分配失败\n"); return 0; } head->front=head; head->next=head; head->data='a'; t=r=head; while(1) { r=(struct nodes *)malloc(sizeof(struct nodes)); if(!r) { printf("存储空间分配失败\n"); return 0; }

数据结构习题

第1章绪论一、判断题 1.数据的逻辑结构与数据元素本身的内容和形式无关。（√） 2.一个数据结构是由一个逻辑结构和这个逻辑结构上的一个基本运算集构成的整体。（√） 3.数据元素是数据的最小单位。（×） 4.数据的逻辑结构和数据的存储结构是相同的。（×） 5.程序和算法原则上没有区别，所以在讨论数据结构时可以通用。（×） 6.从逻辑关系上讲，数据结构主要分为线性结构和非线性结构两类。（√） 7.数据的存储结构是数据的逻辑结构的存储映象。（√） 8.数据的物理结构是指数据在计算机内实际的存储形式。（√） 9.数据的逻辑结构是依赖于计算机的。（×） 10.算法是对解题方法和步骤的描述。（√）二、填空题 1.数据有逻辑结构和存储结构两种结构。 2.数据逻辑结构除了集合以外，还包括线性结构、树形结构和图形结构。 3.数据结构按逻辑结构可分为两大类，它们是线性结构和非线性结构。 4.树形结构和图形结构合称为非线性结构。 5.在树形结构中，除了树根结点以外，其余每个结点只有1个前驱结点。 6.在图形结构中，每个结点的前驱结点数和后继结点数可以任意多个。 7.数据的存储结构又叫物理结构。 8.数据的存储结构形式包括顺序存储、链式存储、索引存储和散列存储。 9.线性结构中的元素之间存在一对一的关系。 10.树形结构中的元素之间存在一对多的关系。 11.图形结构的元素之间存在多对多的关系。 12.数据结构主要研究数据的逻辑结构、存储结构和算法（或运算） 3个方面的内容。 13.数据结构被定义为（D，R），其中D是数据的有限集合，R是D上的关系有限集合。 14.算法是一个有穷指令的集合。 15.算法效率的度量可以分为事先估算法和事后统计法。 16.一个算法的时间复杂度是算法输入规模的函数。 17.算法的空间复杂度是指该算法所耗费的存储空间，它是该算法求解问题规模的n的函数。 18.若一个算法中的语句频度之和为T(n)=6n+3nlog2n,则算法的时间复杂度为O（ nlog2n）。 19.若一个算法的语句频度之和为T(n)=3n+nlog2+n2,则算法的时间复杂度为O（n2）。 20.数据结构是一门研究非数值计算的程序问题中计算机的操作对象，以及它们之间的关系和运算的学科。三、选择题 1

数据结构C语言版循环链表表示和实现

数据结构C语言版循环链表表示和实现.txt37真诚是美酒，年份越久越醇香浓烈；真诚是焰火，在高处绽放才愈显美丽；真诚是鲜花，送之于人，手有余香。/* 数据结构C语言版循环链表表示和实现 P35 编译环境：Dev-C++ 4.9.9.2 日期：2011年2月10日 */ #include #include #include typedef int ElemType; // 线性表的单链表存储结构 typedef struct LNode { ElemType data; struct LNode *next; }LNode, *LinkList; // 要好好区分什么是头结点((*L)->next)，尾结点(*L)，以及第一个结 // 点(*L)->next->next,设立尾指针的单循环链表(头尾相接，即头结点 // 与尾结点是一样的，它们都没数据域. // 构造一个空的循环链表L int InitList_CL(LinkList *L) { // 产生头结点,并使L指向此头结点 *L = (LinkList)malloc(sizeof(struct LNode)); if(!*L) exit(0); // 指针域指向头结点，这样就构成了一个循环，空表循环，*L为表尾 (*L)->next = *L; return 1; } // 销毁循环链表L int DestroyList_CL(LinkList *L) { LinkList q, p = (*L)->next; // p指向头结点 while(p != *L) // 没到表尾，*L为表尾 { q = p->next; free(p);

实验四双向链表

实验名称：实验四双向或循环链表的基本操作一、实验项目名称：双向或循环链表的基本操作二、实验目的 1）通过实验理解双向链表或循环链表的结构。 2）通过实验掌握双向链表或循环链表的基本操作。三、实验基本原理 1、数据结构 2、算法思想 1.构思：双向循环链表的创建建立在双向链表上，所以建立双向循环表每个结点都有三个属性：数据域、上个结点、下个结点，其中第一个结点的上一个结点是最后一个结点，最后一个结点的下一个结点就是第一个结点，所以就构成了双向循环链表。双链表的单元类型定义 Type struct DuLNode { Elemtype data; Struct DuLNode *prior;//建立表头结点 Struct DuLNode *next;//建立表尾结点 } DuLNode,*DuLinkList;

3、算法描述 ①建立一个双链表，输入元素。由p和s两个指针来存放元素。以0判断是否结束，如果不为0 ，则继续，为0则截止。 s->data=e; s->next=p->next; s->prior=p; p->next->prior=s; p->next=s; p=s; ②查找元素：首先判断位置是否合法(p->data!=e&& p->next!=head)若合法进行查找运算。需要引用DuLinkList,（DuLinkList &L）输入要查找的元素的位置，判断双链表中是否有该元素，如果是则输出该元素，如果没有，则提示没有该元素。 ③插入元素：判断位置是否合法(i<1||i>L.Length)，若合法进行查插入运算。需要引用DuLinkList,（DuLinkList &L）输入要插入的元素及其位置，插入数据然后输出数据。 ④删除元素：判断位置是否合法(i<1||i>L.Length)，若合法进行查删除运算。输入要插入的元素及其位置，删除该数据。本程序实现双链表的创建、查找、插入、删除、显示、菜单为主的六个函数组成。四、主要仪器设备及耗材电脑运行环境：visual C++6.0 五、实验步骤（1）打开visual C++，新建工程console application工程，新建文件C++ source file。（2）输入自己的程序代码（3）如果有报错则修改程序。无则组建调试六、实验数据及处理结果 1、程序清单

链表的基本操作-数据结构实验报告

大学数据结构实验报告课程名称数据结构实验第（四）次实验实验名称链表的基本操作学生姓名于歌专业班级学号实验成绩指导老师（签名）日期2018年10月01日一、实验目的 1. 学会定义单链表的结点类型，实现对单链表的一些基本操作和具体的函数定义，了解并掌握单链表的类定义以及成员函数的定义与调用。 2. 掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。二、实验要求 1．预习C语言中结构体的定义与基本操作方法。 2．对单链表的每个基本操作用单独的函数实现。 3．编写完整程序完成下面的实验内容并上机运行。 4．整理并上交实验报告。三、实验内容： 1．编写程序完成单链表的下列基本操作：（1）初始化单链表La （2）在La中插入一个新结点（3）删除La中的某一个结点（4）在La中查找某结点并返回其位置（5）打印输出La中的结点元素值（6）清空链表（7）销毁链表 2 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、 Lb合并成一个有序单链表Lc。四、思考与提高： 1．如果上面实验内容2中合并的表内不允许有重复的数据该如何操作？ 2．如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb，Lc，使得Lb中只含La表中奇数结点，Lc中含有La表的偶数结点？五、实验设计 1．编写程序完成单链表的下列基本操作：（1）初始化单链表La LinkList InitList() {

int i,value,n; LinkList H=(LinkList)malloc(sizeof(LNode)); LinkList P=H; P->next=NULL; do{ printf("请输入链表的长度:"); scanf("%d",&n); if(n<=0) printf("输入有误请重新输入！\n"); }while(n<=0); printf("请输入各个元素:\n"); for(i=0; idata=value; P->next=NEW; NEW->next=NULL; P=NEW; } printf("链表建立成功！\n"); return H->next; } （2）在La中插入一个新结点 LinkList InsertList(LinkList L,int i,ElemType value) { LinkList h,q,t=NewLNode(t,value); int x=0; h=q=L; if(i==1) t->next=h, h=t; else { while(x++next; t->next=q->next; q->next=t; } printf("插入成功！\n"); return h; } （3）删除La中的某一个结点

数据结构实验链表

实验名称：链表班级：学号___________姓名：报告日期：一、实验目的及要求 1. 掌握单链表的存储结构形式及其描述。 2. 掌握单链表的建立、查找、插入和删除操作。二、实验内容 1. 编写函数，实现随机产生或键盘输入一组元素，建立一个带头结点的单链表（无序）。 2. 编写函数，实现遍历单链表。 3. 编写函数，实现把单向链表中元素逆置（不允许申请新的结点空间）。 4. 编写函数，建立一个非递减有序单链表。 5. 编写函数，利用以上算法，建立两个非递减有序单链表，然后合并成一个非递减链表。 6. 编写函数，在非递减有序单链表中插入一个元素使链表仍然有序。 7. 编写函数，实现在非递减有序链表中删除值为x的结点。 8. 编写一个主函数，在主函数中设计一个简单的菜单，分别调试上述算法。三、实验结果

四、实验总结：这次实验使我在已经掌握单链表的存储结构，单链表的建立、查找、插入和删除操作的思想的基础上，可以对其利用C语言进行编程的实现，不仅对单链表的有关内容有了更深的理解，同时也对C语言编程的学习有了很大的进步。期间也遇到不少麻烦，；例如在编好程序后，编译运行时出现很多错误，但是在同学和网络的帮助下，将其成功解决。此外，需要注意的就是在用C语言进行编程时，一定要细心，注意基础知识的积累。同时算法思想也很重要。源代码： #include #include typedef int ElemType;

typedef struct LNode { ElemType data; struct LNode *next; }LNode,*Linklist; void Createlist(Linklist &L) { Linklist p,s; ElemType x; L=(Linklist)malloc(sizeof(LNode)); L->next=NULL; p=L; scanf("%d",&x); while(x) { s=(Linklist)malloc(sizeof(LNode)); s->data=x; s->next=NULL; p->next=s; p=s; scanf("%d",&x);} } void printlist(Linklist &L) { Linklist p; p=L; while(p->next!=NULL){ p=p->next; printf("%d ",p->data);} printf("\n"); } void nizhi(Linklist &L) { Linklist p,s; p=L->next; L->next=NULL; while(p) { s=p; p=p->next; s->next=L->next; L->next=s;} } void charu(Linklist &L,ElemType x)

循环链表&双向链表 数据结构