数据结构 头插法和尾插法建立链表(各分有无头结点)

数据结构   头插法和尾插法建立链表(各分有无头结点)
数据结构   头插法和尾插法建立链表(各分有无头结点)

实验一链表的建立及基本操作方法实现

一、【实验目的】

1、理解和掌握单链表的类型定义方法和结点生成方法。

2、掌握利用头插法和尾插法建立单链表和显示单链表元素的算法。

3、掌握单链表的查找(按序号)算法。

4、掌握单链表的插入、删除算法。

二、【实验内容】

1、利用头插法和尾插法建立一个无头结点单链表,并从屏幕显示单链表元素列表。

2、利用头插法和尾插法建立一个有头结点单链表,并从屏幕显示单链表元素列表。

3、将测试数据结果用截图的方式粘贴在程序代码后面。

重点和难点:

1)尾插法和头插法建立单链表的区别。

2)建立带头结点和无头结点单链表的区别。

3)带头结点和无头结点单链表元素显示方法的区别

三、【算法思想】

1) 利用头插法和尾插法建立一个无头结点单链表

链表无头结点,则在创建链表时,初始化链表指针L=NULL。

当用头插法插入元素时,首先要判断头指针是否为空,若为空,则直接将新结点赋给L,新结点next指向空,即L=p,p->next=NULL,若表中已经有元素了,则将新结点的next 指向首结点,然后将新结点赋给L即(p->next=L,L=p)。

当用尾插法插入元素时,首先设置一个尾指针tailPointer以便随时指向最后一个结点,初始化tailPointer和头指针一样即tailPointer=L。插入元素时,首先判断链表是否为空,若为空,则直接将新结点赋给L即L=p,若不为空,else将最后一个元素的next指向新结点即tailPointer->next=p,然后跳出这个if,else语句,将新结点next指向空,并且将tailPointer 指向新结点即p->next=NULL,tailPointer=p。

2) 利用头插法和尾插法建立一个有头结点单链表

链表有头结点,则在创建链表时,初始化链表指针L->next = NULL。与无头结点区别在于,判断链表为空是根据L->next是否为空。

用头插法插入元素时,要判断链表是否为空,若为空则将新结点next指向空,作为表尾,若不为空,则直接插入,将新结点next指向头结点next的指向,再将头结点next指向

新结点即p->next=L->next,L->next=p。

用尾插法插入元素时,首先也要设置一个尾指针tailPointer以便随时指向最后一个结点,初始化tailPointer=L,与无头结点区别就只是插入第一个元素时有区别。插入元素时,不需要判断链表是否为空,直接进行插入,代码tailPointer->next=p,p->next=NULL,tailPointer=p。

3)带头结点和无头结点单链表元素显示方法的区别:

区别在于,显示时带头结点是从头结点next开始即p=L->next,而无头结点链表是直接从L开始即p=L。

四、【源程序代码】

1) 利用头插法和尾插法建立一个无头结点单链表

#include

#include

typedef struct LNode{

int data;

struct LNode *next;

}LNode, *LinkList;

/* 尾插法*/

void creatListTailInsert(LinkList &L, int n){

LinkList p, tailPointer;

int i;//计数

L = (LinkList)malloc(sizeof(LNode));

if(!L) exit(0); //分配空间失败则退出程序

L = NULL; //no headcrunode

tailPointer = L; //把尾赋给尾指针

printf("taillist(%d):",n);

for(i = 0;i < n; i++){

p = (LinkList)malloc(sizeof(LNode));

if(!p) exit(0);

scanf("%d",&(p->data));

if(L == NULL) L = p; //当链表为空,L赋给第一个结点

else tailPointer->next = p; //将新结点插入尾部;

p->next = NULL;

tailPointer = p; //插入的结点变为尾结点

}

}

/* 头插法*/

void creatListHeadInsert(LinkList &L, int n){

LinkList p;

int i;//计数

L = (LinkList)malloc(sizeof(LNode));

if(!L) exit(0); //分配空间失败则退出程序

L = NULL; //no headcrunode

printf("headlist(%d):",n);

for(i = 0;i < n; i++){

//创建新结点

p = (LinkList)malloc(sizeof(LNode));

if(!p) exit(0);

scanf("%d",&(p->data));

if(L != NULL) p->next = L;

else p->next = NULL;

L = p; //将头结点next指向赋给新结点

}

}

/* 依次显示表中所有元素*/

void getAllElem(LinkList &L, int n){

LinkList p;

int i = 0;

p = L;

while(p && i < n){

printf("%d ",p->data);

p = p->next;

i++;

}

printf("\n");

}

void main(){

LinkList headList;

LinkList tailList;

int count; //插入元素个数

printf("count=");

scanf("%d",&count);

creatListHeadInsert(headList, count);

creatListTailInsert(tailList, count);

printf("headList:");

getAllElem(headList, count);

printf("tailList:");

getAllElem(tailList, count);

}

2) 利用头插法和尾插法建立一个有头结点单链表

#include

#include

typedef struct LNode{

int data;

struct LNode *next;

}LNode, *LinkList;

/* 尾插法 */

void creatListTailInsert(LinkList &L, int n){

LinkList p, tailPointer;

int i;//计数

L = (LinkList)malloc(sizeof(LNode));

if(!L) exit(0); //分配空间失败则退出程序 L->next = NULL; //headcrunode

tailPointer = L; //把尾赋给尾指针

printf("taillist(%d):",n);

for(i = 0;i < n; i++){

p = (LinkList)malloc(sizeof(LNode));

if(!p) exit(0);

scanf("%d",&(p->data));

p->next = tailPointer->next;

tailPointer->next = p;

tailPointer = p; //插入的结点变为尾结点

}

}

/* 头插法 */

void creatListHeadInsert(LinkList &L, int n){

LinkList p;

int i;//计数

L = (LinkList)malloc(sizeof(LNode));

if(!L) exit(0); //分配空间失败则退出程序 L->next = NULL; //headcrunode

printf("headlist(%d):",n);

for(i = 0;i < n; i++){

//创建新结点

p = (LinkList)malloc(sizeof(LNode));

if(!p) exit(0);

scanf("%d",&(p->data));

p->next = L->next; //将头结点 next指向赋给新结点 L->next = p;

}

}

/* 依次显示表中所有元素 */

void getAllElem(LinkList &L, int n){

LinkList p;

int i = 0;

p = L->next;

while(p && i < n){

printf("%d ",p->data);

p = p->next;

i++;

}

printf("\n");

}

void main(){

LinkList headList;

LinkList tailList;

int count; //插入元素个数

printf("count=");

scanf("%d",&count);

creatListHeadInsert(headList, count);

creatListTailInsert(tailList, count);

printf("headList:");

getAllElem(headList, count);

printf("tailList:");

getAllElem(tailList, count);

}

五、【数据测试】

输入:8 //插入8个元素

输入八个数字

头插法和尾插法区别在于,头插法输入数据是逆序存入,尾插法是顺序存入;

带头结点和不带头结点在数据显示上基本没区别,区别在于初始化链表和插入元素时,头指针的操作不同。

1) 利用头插法和尾插法建立一个无头结点单链表

2) 利用头插法和尾插法建立一个有头结点单链表

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

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

#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

数据结构习题及答案精编版

第一章 1.在数据结构中,从逻辑上可以把数据结构分为(C ) A.动态结构和静态结构 B. 紧凑结构和非紧凑结构 C.线性结构和非线性结构 D. 内部结构和外部结构 ● 2.在数据结构中,与所使用的计算机无关的是( A ) A. 逻辑结构 B. 存储结构 C. 逻辑和存储结构 D. 物理结构 3.下面程序的时间复杂度为____O(mn)_______。 for (int i=1; i<=m; i++) for (int j=1; j<=n; j++ ) S+=i 第二章线性表 ●链表不具备的特点是(A) A 可以随机访问任一结点(顺序) B 插入删除不需要移动元素 C 不必事先估计空间 D 所需空间与其长度成正比 2. 不带头结点的单链表head为空的判定条件为(A ),带头结点的单链表head为空的判定条件为(B ) A head==null B head->next==null C head->next==head D head!=null ●3.在线性表的下列存储结构中,读取元素花费时间最少的是(D) A 单链表 B 双链表 C 循环链表 D 顺序表 ● 4.对于只在表的首、尾两端进行手稿操作的线性表,宜采用的存储结构为(C) A 顺序表 B 用头指针表示的单循环链表 C 用尾指针表示的单循环链表 D 单链表 ● 5.在一个具有n 个结点的有序单链表中插入一个新的结点,并保持链表元素仍然有序, 则操作的时间复杂度为( D ) A O(1) B O(log2n) C O(n2) D O(n) ● 6.在一个长度为n (n>1)的单链表上,设有头和尾两个指针,执行(B)操作与链表的长 度有关 A 删除单链表中第一个元素 B 删除单链表中最后一个元素 C 在第一个元素之前插入一个新元素 D 在最后一个元素之后插入一个新元素 ●7.与单链表相比,双向链表的优点之一是(D) A 插入删除操作更简单 B 可以进行随机访问 C 可以省略表头指针或表尾指针 D 顺序访问相邻结点更容易 ●8.若list是某带头结点的循环链表的头结点指针,则该链表最后那个链结点的指针域 (头结点的地址)中存放的是( B ) A list的地址 B list的内容 C list指的链结点的值 D 链表第一个链结点的地址 ●9.若list1和list2分别为一个单链表与一个双向链表的第一个结点的指针,则( B ) A list2比list1占用更多的存储单元 B list1与list2占用相同的存储单元 C list1和list2应该是相同类型的指针变量 D 双向链表比单链表占用更多的存储单元 10.链表中的每个链结点占用的存储空间不必连续,这句话正确吗? (不正确) 11. 某线性表采用顺序存储结构,元素长度为4,首地址为100,则下标为12的(第13个)元素的存储地址为148。V 100+4*12=148 11.在顺序表的(最后一个结点之后)插入一个新的数据元素不必移动任何元素。 12.若对线性表进行的操作主要不是插入删除,则该线性表宜采用(顺序)存储结构,若频繁地对线性表进行插入和删除操作,则该线性表宜采用( 链 )存储结构。

数据结构 单链表详解

数据结构的概念: 数据的逻辑结构+ 数据的存储结构+ 数据的操作; 数据的数值:=====》数据===》数值型数据整形浮点数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};

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 ( )函数向系统申请分配一个节点。

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

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

实现要求: ⑴单链表建立函数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班 学号:201421012731 学生姓名:邓雪 指导教师:杨红颖 完成时间:2015年12月25号

一、实验目的: (1)动态地建立单链表; (2)掌握线性表的基本操作:求长度、插入、删除、查找在链式存储结构上的实现; (3)熟悉单链表的应用,明确单链表和顺序表的不同。 二、实验环境: Windows 8.1 Microsoft Visual c++ 6.0 三、实验内容及要求: 建立单链表,实现如下功能: 1、建立单链表并输出(头插法建立单链表); 2、求表长; 3、按位置查找 4、按值查找结点; 5、后插结点; 6、前插结点 7、删除结点; 四、概要设计: 1、通过循环,由键盘输入一串数据。创建并初始化一个单链表。 2、编写实现相关功能函数,完成子函数模块。 3、调用子函数,实现菜单调用功能,完成顺序表的相关操作。

五、代码: #include #include typedef char datatype; typedef struct node { datatype data; struct node *next; }linklist; linklist *head,*p; //头插法建立单链表 linklist *Creatlistf() { char ch; linklist *head,*s; head=NULL; ch=getchar(); printf("请输入顺序表元素(数据以$结束):\n"); while(ch!='$') { s=(linklist *)malloc(sizeof(linklist)); s->data=ch; s->next=head; head=s; ch=getchar(); } return head; } //求单链表的长度 void get_length(struct node *head) { struct node *p=head->next; int length=0;

数据结构课程设计单链表

目录 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)。

单链表基本操作实验

实验2 链表的操作 实验容: 1)基础题:编写链表基本操作函数,链表带有头结点 (1)CreatList_h()//用头插法建立链表 (2)CreateList_t()//用尾插法建立链表 (3)InsertList()向链表的指定位置插入元素 (4)DeleteList()删除链表中指定元素值 (5)FindList()查找链表中的元素 (6)OutputList()输出链表中元素 2)提高题: (1)将一个头节点指针为heada的单链表A分解成两个单链表A和B,其头结点指针分别为heada和headb,使得A表中含有原单链表A中序号为奇数的元素,B表中含有原链表A中序号为偶数的元素,且保持原来的相对顺序。 (2)将一个单链表就地逆置。 即原表(a1,a2,。。。。。。 an),逆置后新表(an,an-1,。。。。。。。a1) /* 程序功能 :单链表基本功能操作 编程者 :天啸 日期 :2016-04-14 版本号 :3.0 */ #include #include typedef struct List { int data; struct List *next; }List; void CreatList_h(List *L) //头插法 { int i = 0; int n = 0; int goal; List *p; printf("请输入数据的个数:\n"); scanf("%d",&n); L -> next = NULL; for(i=0;i

{ printf("请输入第%d个数:\n",i+1); scanf("%d",&goal); p = (struct List*)malloc(sizeof(struct List)); p -> data = goal; p -> next = L->next; //将L指向的地址赋值给p; L -> next = p; } } void CreateList_t(List *L) //尾插法 { int i; int n; int goal; List *p; List *q=L; printf("请输入数据的个数:\n"); scanf("%d",&n); for (i=0;i data = goal; q -> next = p; q = p; } q -> next = NULL; } void InsList(List *L,int i,int e) //插入 { List *s; List *p = L; int j = 0; while (p&&jnext; ++j; } s = (struct List*)malloc(sizeof(struct List)); s -> data = e; //插入L中

数据结构(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()//创建链表;

数据结构链表代码

#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);

单链表完整算法

// 包含头文件 #include #include #include // 为结点数据类型和结构体类型起别名 typedefint datatype; typedefstructLinkNode { datatype data; // 数据域 structLinkNode *next; // 指针域存放下一个结点的地址}LNode,*LinkList; LinkList L; // 单链表的头指针 // 1.用头插法创建单链表 LinkListCreateListHead(int n) { // 创建头结点 LNode *L = (LNode *)malloc(sizeof(LNode)); L->next = NULL; // 设置指针域为空

LinkList p; // p指向新结点 for(inti=n;i>0;i--) // 先插入最后一个结点,插入次序与逻辑次序相反 { // 生成新结点 p = (LNode *)malloc(sizeof(LNode)); // 从键盘输入新结点的值 printf("请输入要插入第%d结点的值:\n",i); scanf("%d", &p->data); p->next = L->next; // 让L原来的后继结点成为p的后继结点 L->next = p; // p成为L新的后继结点 } return L; // 返回单链表的头指针 } // 2.用尾插法创建单链表 LinkListCreateListTail(int n) {

// 生成头结点 L = (LNode *)malloc(sizeof(LNode)); L->next = NULL;// 设置指针域为空 // p指向新结点,q指向尾结点 LinkList p, q = L; // 依次在末尾插入n个结点 for(inti=1;i<=n;i++) { // 生成新结点p p = (LNode *)malloc(sizeof(LNode)); // 从键盘输入新结点的值 printf("请输入第%d个结点的值:\n", i); scanf("%d",&p->data); p ->next = NULL; // 新结点(也是尾结点)的指针域为空 // 把新结点链接到单链表的末尾 q->next = p;

数据结构双向链表实战应用(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、目的:通过上级操作,进一步了解线性表的存储结构以及基本运算。 2、内容: (1)、题目要求 编写程序,创建一个链表,实现链表的插、删除、查找和输出等功能。(2)、分析算法 单链表的建立,使用动态建立链表,有头插法建表和尾插法建表。 头插法建表: input_font() { head=NULL; datatype ch; puts("请输入您的数据,想结束输入,请键入“#”"); fflush(stdin); ch=getchar(); while(ch!='#') { p=(linklist *)malloc(sizeof(linklist)); p->c=ch; p->next=head; head=p; length++; puts("恭喜,你的数据输入正确!请继续操作!"); fflush(stdin); ch=getchar(); }

尾插法建表: input_end() { head=(linklist *)malloc(sizeof(linklist)); r=head; datatype ch; puts("请输入您的数据,想结束输入,请键入“#”"); fflush(stdin); ch=getchar(); while(ch!='#') { p=(linklist *)malloc(sizeof(linklist)); p->c=ch; r->next=p; r=p; length++; puts("恭喜,你的数据输入正确!请继续操作!"); fflush(stdin); ch=getchar(); } r->next=NULL; } (3)、流程图: 函数层次:

数据结构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. 编写函数,实现遍历单链表。 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)

头插法与尾插法

#include #include typedef char DataType; //假设节点的数据类型为字符 typedef struct node{ //节点类型定义 DataType data; //节点的数据域 struct node *next; //节点的指针域 }ListNode; typedef ListNode* LinkList; ListNode *p; //指向某一节点的指针LinkList head; //单链表的头指针 //头插法 LinkList createListF(void); LinkList createListF(void){ //返回单链表的头指针 char ch; LinkList head; //头指针 ListNode *s; //工作指针 head = NULL; //链表开始为空

while (ch != '\n') { s = (ListNode*)malloc(sizeof(ListNode)); //生成新节点 s->data = ch; //将读入的数据放入新节点的数据域中 s->next = head; head = s; ch = getchar(); //读入下一个字符} return head; } //尾插法 LinkList createListR(void); LinkList createListR(void){ //返回头指针 char ch; LinkList head; //头指针 ListNode *s,*r; //工作指针 head = NULL; //链表开始为空 r = NULL; //尾指针初始值为空

相关文档
最新文档