数据结构实验1.2:带表头结点单链表的相关操作

合集下载

单链表的基本操作实验报告

单链表的基本操作实验报告

单链表的基本操作实验报告单链表的基本操作实验报告引言:单链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。

在本次实验中,我们将学习和实践单链表的基本操作,包括创建链表、插入节点、删除节点以及遍历链表等。

一、实验目的本次实验的主要目的是掌握单链表的基本操作,包括链表的创建、插入节点、删除节点和遍历链表。

通过实践操作,加深对单链表的理解,并掌握如何应用单链表解决实际问题。

二、实验过程1. 创建链表首先,我们需要创建一个空链表。

链表可以通过一个头节点来表示,头节点不存储数据,只用于标识链表的起始位置。

我们可以定义一个指针变量head,将其指向头节点。

2. 插入节点在链表中插入节点是常见的操作。

我们可以选择在链表的头部、尾部或者指定位置插入节点。

插入节点的过程可以分为以下几个步骤:a. 创建一个新节点,并为其赋值;b. 找到要插入位置的前一个节点;c. 将新节点的指针指向前一个节点的下一个节点;d. 将前一个节点的指针指向新节点。

3. 删除节点删除节点是另一个常见的操作。

我们可以选择删除链表的头节点、尾节点或者指定位置的节点。

删除节点的过程可以分为以下几个步骤:a. 找到要删除节点的前一个节点;b. 将前一个节点的指针指向要删除节点的下一个节点;c. 释放要删除节点的内存空间。

4. 遍历链表遍历链表是为了查看链表中的元素。

我们可以从头节点开始,依次访问每个节点,并输出节点的值。

三、实验结果在本次实验中,我们成功完成了单链表的基本操作。

通过创建链表、插入节点、删除节点和遍历链表等操作,我们可以方便地对链表进行增删改查操作。

四、实验总结通过本次实验,我们对单链表的基本操作有了更深入的了解。

单链表是一种非常重要的数据结构,广泛应用于各个领域。

掌握了单链表的基本操作,我们可以更好地解决实际问题,并且为以后学习更复杂的数据结构打下坚实的基础。

在实验过程中,我们还发现了一些问题和不足之处。

数据结构实验报告--单链表

数据结构实验报告--单链表

数据结构实验报告--单链表数据结构实验报告--单链表1.引言1.1 研究目的本实验旨在通过实践的方式,深入了解单链表的数据结构以及相关操作,提升对数据结构的理解和应用能力。

1.2 实验内容本实验主要包括以下几个方面的内容:●单链表的基本定义和实现●单链表的插入、删除、遍历操作●单链表的逆置操作●单链表的查找和修改操作2.理论基础2.1 单链表的定义单链表是一种常见的线性数据结构,它由一系列的节点组成,每个节点包含数据和指向下一个节点的指针。

2.2 单链表的基本操作①单链表的插入操作在单链表中,可以通过插入操作在指定位置插入一个新节点,该操作主要包括以下步骤:●创建一个新的节点,并为其赋值●将新节点的next指针指向插入位置的后一个节点●将插入位置的前一个节点的next指针指向新节点②单链表的删除操作在单链表中,可以通过删除操作删除指定位置的节点,该操作主要包括以下步骤:●将删除位置的前一个节点的next指针指向删除位置的后一个节点●释放删除节点的内存③单链表的遍历操作单链表的遍历操作主要是依次访问链表中的每一个节点,并执行相应的操作。

④单链表的逆置操作单链表的逆置操作可以将一个单链表中的节点顺序进行颠倒。

⑤单链表的查找操作在单链表中,可以通过查找操作找到指定值的节点。

⑥单链表的修改操作在单链表中,可以通过修改操作修改指定位置的节点的值。

3.实验过程3.1 实验环境本次实验使用C语言进行编程,需要先安装相应的编程环境,如gcc编译器。

3.2 实验步骤①单链表的创建和初始化首先创建一个空链表,并初始化链表的头指针。

②单链表的插入操作按照需求,在链表的指定位置插入一个新节点。

③单链表的删除操作按照需求,删除链表中的指定位置的节点。

④单链表的遍历操作依次访问链表中的每一个节点,并输出其值。

⑤单链表的逆置操作将单链表中的节点顺序进行逆置。

⑥单链表的查找操作按照需求,在链表中查找指定值的节点。

3.2.7 单链表的修改操作按照需求,修改链表中指定位置的节点的值。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告实验目的:掌握单链表的基本操作,学会使用单链表实现各种算法。

实验内容:实现单链表的基本操作,包括创建、插入、删除、访问等。

利用单链表完成以下算法:- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第K个节点- 合并两个有序单链表为一个有序单链表实验步骤:1. 创建单链表在创建单链表时,先定义一个结构体Node来表示链表中的节点,节点包括数据域和指针域,指针域指向下一个节点。

然后,用指针p指向链表的头节点,将头节点的指针域初始化为NULL。

2. 插入节点在单链表中插入节点的操作分为两种情况:- 在链表头插入节点- 在链表中间或尾部插入节点无论是哪种情况,先将新节点的指针域指向要插入的位置的下一个节点,再将要插入的位置的指针域指向新节点即可。

3. 删除节点删除链表节点的操作同样分为两种情况:- 删除头节点- 删除中间或尾部节点要删除头节点,先用一个指针将头节点指向的下一个节点保存起来,再将头节点释放掉。

要删除中间或尾部节点,先用一个指针指向要删除节点的前一个节点,然后将指向要删除节点的前一个节点的指针域指向要删除节点的下一个节点,最后将要删除的节点释放掉。

4. 单链表逆序单链表逆序可以使用三个指针来完成,分别为pre指针、cur指针和next指针。

首先将pre指针和cur指针指向NULL,然后循环遍历链表,将cur指针指向当前节点,将next指针指向当前节点的下一个节点,然后将当前节点的指针域指向pre指针,最后将pre指针和cur指针向前移动一个节点,继续进行循环。

5. 查找单链表中的中间节点查找单链表中的中间节点可以使用双指针法,将两个指针p1和p2都指向链表头,然后p1每次向前移动一个节点,而p2每次向前移动两个节点,当p2指向了链表尾部时,p1指向的节点即为中间节点。

6. 删除单链表中的倒数第K个节点删除单链表中的倒数第K个节点可以使用双指针法,在链表中定义两个指针p1和p2,p1指向链表头,p2指向第K个节点,然后p1和p2同时向前移动,直到p2指向链表尾部,此时p1指向的节点即为要删除的节点。

数据结构-单链表实验报告

数据结构-单链表实验报告

单链表实验报告一、实验目的1、帮助读者复习C++语言程序设计中的知识。

2、熟悉线性表的逻辑结构。

3、熟悉线性表的基本运算在两种存储结构上的实现,其中以熟悉链表的操作为侧重点。

二、实验内容[问题描述]实现带头结点的单链表的建立、求长度,取元素、修改元素、插入、删除等单链表的基本操作。

[基本要求](1)依次从键盘读入数据,建立带头结点的单链表;(2)输出单链表中的数据元素(3)求单链表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。

三、算法设计(1)建立带表头结点的单链表;首先输入结束标志,然后建立循环逐个输入数据,直到输入结束标志。

(2)输出单链表中所有结点的数据域值;首先获得表头结点地址,然后建立循环逐个输出数据,直到地址为空。

(3)输入x,y在第一个数据域值为x的结点之后插入结点y,若无结点x,则在表尾插入结点y;建立两个结构体指针,一个指向当前结点,另一个指向当前结点的上一结点,建立循环扫描链表。

当当前结点指针域不为空且数据域等于x的时候,申请结点并给此结点数据域赋值为y,然后插入当前结点后面,退出函数;当当前结点指针域为空的时候,申请结点并给此结点数据域赋值为y,插入当前结点后面,退出函数。

(4)输入k,删除单链表中所有的结点k,并输出被删除结点的个数。

建立三个结构体指针,一个指向当前结点,另一个指向当前结点的上一结点,最后一个备用;建立整形变量l=0;建立循环扫描链表。

当当前结点指针域为空的时候,如果当前结点数据域等于k,删除此结点,l++,跳出循环,结束操作;如果当前结点数据域不等于k,跳出循环,结束操作。

当当前结点指针域不为空的时候,如果当前结点数据域等于k,删除此结点,l++,继续循环操作;如果当前结点数据域不等于k,指针向后继续扫描。

循环结束后函数返回变量l的值,l便是删除的结点的个数。

四、实验结果1、新建一个链表:2、输出链表的数据:(4)插入数据:在数据为3后面插入一个数据100:(5)删除数据:删除刚刚插入的数据100:五、总结实验之前由于准备不够充分,所以堂上实验时只完成了建立单链表和数据的输出,而后面两个实验要求也是用来很多时间长完成的。

单链表的基本操作

单链表的基本操作

实验二:单链表的基本操作编写一个完整的程序,实现单链表的建立、插入、删除、输出等基本操作。

(1)建立一个带头结点的单链表。

(2)计算单链表的长度,然后输出单链表。

(3)查找值为x的直接前驱结点q。

(4)删除值为x的结点。

(5)把单向链表中元素逆置(不允许申请新的结点空间)。

(6)已知单链表中元素递增有序,请写出一个高效的算法,删除表中所有值大于mink且小于maxk的元素(若表中存在这样的元素),同时释放被删结点空间,并分析你的算法的时间复杂度(注意:mink和maxk是给定的两个参变量,他们的值可以和表中的元素相同,也可以不同)。

(7)同(6)的条件,试写一高效的算法,删除表中所有值相同的多余元素(使得操作后的线性表中所有元素的值均不相同),同时释放被删结点空间,并分析你的算法时间复杂度。

(8)利用(1)建立的链表,实现将其分解成两个链表,其中一个全部为奇数,另一个全部为偶数(尽量利用已知的存储空间)。

(9)在主函数中设计一个简单的菜单,分别测试上述算法。

# include <stdio.h># include <stdlib.h>typedef struct node{int data;struct node * next;}Lnode, * LinkList;int m=sizeof(Lnode);//建立新的链表void Bulid_List(LinkList root){int num;LinkList s,p;s=root->next;int n;printf("请输入新建链表的长度n数据:\n"); scanf("%d",&n);printf("请依次建立链表:");for(int i=0;i<n;i++){scanf("%d",&num);s->data=num;p=(LinkList)malloc(m);s->next=p;s=p;s->next=NULL;}printf("链表已建立!\n");}//对链表的输出,包括长度和元素void OutPut_list(LinkList root) {int len=0;LinkList s;s=root->next;if(s->next==NULL)printf("单链表无数据,请先新建单链表。

数据结构实验指导书——单链表的基本操作

数据结构实验指导书——单链表的基本操作
void MergeAscend_Linklist(LinkList La, LinkList Lb, LinkList &Lc);/*两个非递减有序单链表La和Lb合并成一个非递减有序链表Lc*/
void Split_Linklist(LinkList La, LinkList &Lb);/*链表La按值分解成两个链表,La全部为奇数,Lb全部为偶数*/
printf("\t\t\t4.链表逆置\n");
printf("\t\t\t5.删除偶数节点\n");
printf("\t\t\t6.生成值有序单链表\n");
printf("\t\t\t7.合并生成降序链表\n");
printf("\t\t\t8.合并生成升序链表\n");
printf("\t\t\t9.分解链表\n");
实验说明:
1.类型定义
typedefintElemType; //元素类型
typedef structnode
{
ElemType data;
structnode *next;
}LinkNode, *LinkList;
2.为了算法实现简单,建议采用带头结点的单链表。
注意问题:
1.重点理解链式存储的特点及指针的含义。
Status Insert_Linklist(LinkList L, int x);/*在有序单链表L中插入元素x,链表仍然有序*/
Status CreatOrder_Linklist(LinkList &L);/*创建非递减有序单链表*/
void MergeDescend_Linklist(LinkList La, LinkList Lb, LinkList &Lc);/*两个非递减有序单链表La和Lb合并成一个非递增有序链表Lc*/

带头结点的单链表操作说明

带头结点的单链表操作说明⼀、单链表简介相对于以数组为代表的“顺序表”⽽⾔,单链表虽然存储密度⽐较低(因为数据域才是我们真正需要的,指针域只是⽤来索引,我们并不真正需要它),但是却具有灵活分配存储空间、⽅便数据元素的删除、⽅便元素插⼊等优点单链表是线性表链式存储的⼀种,其储存不连续。

单链表的数据结构中包含两个变量:数据和指向下⼀结点的指针。

⼀个结点只知道下⼀个结点的地址。

⼀个单链表必须有⼀个头指针,指向单链表中的第⼀个结点。

否则链表会在内存中丢失。

⼀般的链表可以不带头结点,头指针直接指向第⼀个节点,如下图:但是这样的链表有⼀个很⼤的问题,就是元素插⼊与删除操作时,需要考虑是否要改动头指针,⽽改动指针如果反应在函数中,那么形参必须使⽤⼆重指针,既加⼤了编写程序的难度,⽽且还降低了可读性,容易出错,因此“带头结点的单链表”使⽤更⽅便,也就是头指针指向的节点不存放数据,只作为链表的开始,这样⼀来,针对第⼀个节点的操作和针对其他节点的操作就完全⼀样的,⼗分⽅便,如图所⽰:⼆、带头结点的单链表各种操作下⾯我们讨论⼀下带头结点的单链表的各种操作1、链表数据结构的声明1using namespace std;2const int MAXSIZE = 1000;3 template <class T>4struct Node5 {6 T data; //数据域7 Node *next; //指针域8 };2、链表模板类的声明1 template <class T>2class LinkList3 {4public:5 LinkList(){front = new Node<T>;} //the constructor function without arguments6 LinkList( T a[], int n); //the constructor function initialized by array of n elements7 ~LinkList();8int GetLength(); //get the length of the LIST9void PrintList(); //print the element of the list10void Insert(int i,T x);// insert element x in the i-th location11 T Delete(int i); //delete the i-th element and return its value12 Node<T> *Get(int i); //get the address of i-th element13int Locate(T x); //find the element whose value is x and return its index14private:15 Node<T> *front; //head pointer16 };3、⽤头插法建⽴新链表,也就是每次插⼊的新节点都在链表的头部,注释部分给出的是尾插法的实现⽅式1 template <class T>2 LinkList<T>::LinkList(T a[], int n)3 {4// insert element at the first location of the existing link list5 front = new Node<T>;6 front->next = NULL;7for(int i=n-1; i>=0; i--)8 {9 Node<T> *s = new Node<T>;10 s->data = a[i];11 s->next = front->next;12 front->next = s;13 }14// insert element at the tail of the existing link list1516/*17 front = new Node<T>;18 Node<T> *r = front;19 for(int i=0; i<n; i++)20 {21 Node<T> *s = new Node<T>;22 s->data = a[i];23 r->next = s;24 r=s;25 }26 r->next = NULL;27*/28 }4、打印链表1 template <class T>2void LinkList<T>::PrintList()3 {4 Node<T> *p = front;5if(p->next==NULL)6 cout<<"link is enpty"<<endl;7else8 {9 p = p->next;10while(p)11 {12 cout<<p->data<<"";13 p = p->next;14 }15 }16 }5、插⼊节点1 template <class T>2void LinkList<T>::Insert(int i,T x)3 {4 Node<T> *p = front;5if(i!= 1) p=Get(i-1); // if not insert the elelment in the first location 6if(p)7 {8 Node<T> *s = new Node<T>;9 s->data = x;10 s->next = p->next;11 p->next = s;12 }13else14 cout<<"error!"<<endl;15 }6、删除节点1 template <class T>2 T LinkList<T>::Delete(int i)3 {4 Node<T> *p = front;5if(i!=1) p = Get(i-1);6 Node<T> *q = p->next;7 p->next = q->next;8 T x = q->data;9delete q;10return x;11 }7、按位查找节点,返回第i个节点的地址1 template <class T>2 Node<T> *LinkList<T>::Get(int i)3 {4 Node<T> *p = front->next;5int j=1;6while(p&&j!=i)7 {8 p = p->next;9 j++;10 }11return p;12 }8、按值查找,返回给定值对应的节点的序号1 template <class T>2int LinkList<T>::Locate(T x)3 {45 Node<T> *p = front->next;6int j=1;7while(p)8 {9if(p->data==x) return j;10 p = p->next;11 j++;12 }13return -1; //search fail14 }9、获取链表长度1 template <class T>2int LinkList<T>::GetLength()3 {4 Node<T> *p = front->next;5int count=0;6while(p)7 {8 p = p->next;9 count++;10 }11return count; //get the length of linklist12 }10、析构函数1 template <class T>2 LinkList<T>::~LinkList()3 {4 Node<T> *p = front;5while(p)6 {7 front = p;8 p = p->next;9 }10 }11、主函数(由于使⽤模板类实现,以上所有代码建议放⼊ .h头⽂件,主函数则放⼊.cpp⽂件所有代码在dev c++环境中测试通过) 1/*2线性表相关成员函数的实现3*/4 #include <iostream>5 #include <cmath>6 #include <stdlib.h>7 #include "linked_list.h"8using namespace std;9int main()10 {11int a[7] = {1,2,3,4,5,6,7};12 LinkList <int> list(a,7);13 list.PrintList();14 cout<<endl;15 cout<<list.Get(3)<<endl;16 Node<int> temp = *list.Get(3);17 cout<<temp.data<<endl;18//cout<<*(list.Get(3))<<endl;19 cout<<list.GetLength()<<endl;20 list.Insert(3,11);21 cout<<list.GetLength()<<endl;22 list.PrintList();23 cout<<list.Locate(5)<<endl;24int x = list.Delete(4);25 cout<<"删除元素:"<<x<<endl;26 list.PrintList();27//int p = list.Locate(1000);28//cout<<"元素4的位置:"<<p<<endl;29 system("pause");30return0;31 }。

单链表的操作实验报告

单链表的操作实验报告《单链表的操作实验报告》在计算机科学领域,数据结构是非常重要的基础知识之一。

而单链表作为一种常见的数据结构,经常被用来存储和操作数据。

在本次实验中,我们将对单链表的操作进行实验,并撰写实验报告以总结和分享我们的实验结果。

实验目的:1. 了解单链表的基本概念和操作方法。

2. 掌握单链表的插入、删除、查找等操作。

3. 通过实际操作加深对单链表的理解和掌握。

实验环境:1. 编程语言:C/C++2. 开发环境:Visual Studio Code3. 实验工具:GCC编译器实验步骤:1. 定义单链表的结构体,并实现初始化、插入、删除、查找等操作的函数。

2. 编写测试用例,对单链表的各种操作进行测试。

3. 分析实验结果,总结操作的时间复杂度和空间复杂度。

4. 撰写实验报告,分享实验过程和结果。

实验结果:经过实验,我们成功实现了单链表的初始化、插入、删除、查找等操作,并对这些操作进行了充分的测试。

我们发现单链表的插入和删除操作的时间复杂度为O(1),而查找操作的时间复杂度为O(n),其中n为链表的长度。

这些结果与我们的预期相符合,说明我们对单链表的操作有了较好的掌握。

实验总结:通过本次实验,我们不仅加深了对单链表的理解,还提高了编程能力和数据结构的应用能力。

我们对单链表的操作有了更深入的了解,为以后在实际项目中应用单链表打下了良好的基础。

结语:单链表作为一种常见的数据结构,在实际应用中具有重要的作用。

通过本次实验,我们对单链表的操作有了更深入的了解,相信在以后的学习和工作中能够更好地应用和运用单链表。

希望本次实验报告能够对读者有所帮助,也欢迎大家对实验结果进行讨论和交流。

数据结构实验报告单链表

数据结构实验报告_单链表数据结构实验报告——单链表一、实验目的1.掌握单链表的基本概念和原理。

2.了解单链表在计算机科学中的应用。

3.掌握单链表的基本操作,如插入、删除、遍历等。

4.通过实验,加深对理论知识的理解,提高编程能力。

二、实验内容1.实验原理:单链表是一种线性数据结构,由一系列节点组成,每个节点包含数据域和指针域。

其中,指针域指向下一个节点,最后一个节点的指针域指向空。

单链表的主要操作包括插入、删除、遍历等。

2.实验步骤:(1)创建一个单链表。

(2)实现插入操作,即在链表的末尾插入一个新节点。

(3)实现删除操作,即删除链表中的一个指定节点。

(4)实现遍历操作,即输出链表中所有节点的数据。

3.实验代码:下面是使用Python语言实现的单链表及其基本操作的示例代码。

class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = Nonedef insert(self, data):new_node = Node(data)if self.head is None:self.head = new_nodeelse:current = self.headwhile current.next is not None:current = current.nextcurrent.next = new_nodedef delete(self, data):if self.head is None:returnif self.head.data == data:self.head = self.head.nextreturncurrent = self.headwhile current.next is not None and current.next.data != data:current = current.nextif current.next is None:returncurrent.next = current.next.nextdef traverse(self):current = self.headwhile current is not None:print(current.data)current = current.next4.实验结果:通过运行上述代码,我们可以看到单链表的基本操作得到了实现。

数据结构中链表的基本操作

数据结构中链表的基本操作链表是计算机科学中常用的一种数据结构,它由若干个结点通过指针链接而成。

在链表中,每个结点存储着一个数据元素和指向下一个结点的指针。

相比于数组,链表具有动态性和易于扩展的优势,因为链表的大小可以根据需要自行增长或缩小。

链表的基本操作包括创建、插入、删除和遍历。

下面将详细介绍这些操作。

一、创建链表创建一个链表需要创建一个空结点,通常称为“头结点”。

头结点可以作为链表的起点,方便对整个链表进行操作。

头结点本身不存储数据,而是保存链表的开始位置。

创建链表时,需要先创建头结点,并将头结点的指针指向 NULL。

二、插入结点插入结点是链表中最常见的操作之一,在链表中插入结点可以分为三种情况:1.在链表的开头插入结点:这种情况下,需要将新结点创建后,将它插入到链表的头部。

此时需要将新结点插入到头结点之后。

2.在链表的中间插入结点:这种情况下,需要先找到插入结点的前一个结点,然后将新结点插入到该结点之后。

如果链表中不存在前一个结点,则无法插入该结点。

3.在链表的末尾插入结点:这种情况下,需要遍历链表,找到最后一个结点,然后将新结点插入到该结点之后。

如果链表为空,则需要创建头结点。

三、删除结点删除结点也是链表中常见的操作之一。

在链表中删除结点可以分为两种情况:1.删除头结点:这种情况下,需要将头结点删除,并将头结点的指针指向下一个结点。

2.删除链表中的其他结点:这种情况下,需要先找到要删除结点的前一个结点,然后将前一个结点指向需要删除结点的下一个结点,最后将需要删除的结点释放掉。

四、遍历链表遍历链表是通过指针将结点链接起来,实现从头结点开始遍历,直到遍历到链表末尾。

链表的遍历可以采用递归或循环方式实现。

遍历链表时需要注意,由于链表没有类似于数组的下标,因此需要通过遍历的方式获取每个结点的数据。

以上是关于链表的基本操作的介绍。

使用链表作为数据结构,可以非常方便地实现各类场景的程序需求。

当然链表也有些缺点,比如在访问链表中间的元素时,需要遍历整个链表才能到达目标元素,速度相对数组会慢一些。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

题目:参照程序2.8~2.14,编写程序,完成带表头结点单链表的初始化、查找、插入、删除、输出、撤销等操作。

部分代码:
带表头结点单链表的结构体定义:
typedef struct Node {
ElemType element; //结点的数据域
struct Node * link; //结点的指针域
}Node;
typedef struct {
struct Node* head; //表头结点
int n;
}HeaderList;
带表头结点单链表的插入函数:
//带表头结点单链表的插入
Status Insert(HeaderList *h, int i, ElemType x) {
Node *p, *q;
int j;
if (i<-1 || i>h->n - 1)
return ERROR;
p = h->head; //从头结点开始找ai元素所在的结点p for (j = 0; j <= i; j++) {
p = p->link;
}
q = (Node*)malloc(sizeof(Node)); //生成新结点q
q->element = x;
q->link = p->link; //新结点q插在p之后
p->link = q;
h->n++;
return OK;
}
带表头结点单链表的删除函数:
//带表头结点单链表的删除
Status Delete(HeaderList *h,int i){
int j;
Node *p,*q;
if(!h->n){
return ERROR;
if(i<0||i>h->n-1){
return ERROR;
}
}
q=h->head;
for(j=0;j<i;j++){
q=q->link;
}
p=q->link;
q->link=p->link; //从单链表中删除p所指结点free(p); //释放p所指结点的存储空间h->n--;
return OK;
}
完整程序:
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef int Status;
#define ERROR 0
#define OK 1
typedef struct Node {
ElemType element; //结点的数据域
struct Node * link; //结点的指针域
}Node;
typedef struct {
struct Node* head; //表头结点
int n;
}HeaderList;
//带表头结点单链表的初始化
Status Init(HeaderList *h) {
h->head=(Node*)malloc(sizeof(Node)); //生成表头结点
if(!h->head){
return ERROR;
}
h->head->link = NULL; //设置单链表为空表h->n = 0;
return OK;
}
//带表头结点单链表的查找
Status Find(HeaderList *h,int i,ElemType *x){
Node *p;
int j;
if(i<0||i>h->n-1){
return ERROR;
}
p=h->head->link;
for(j=0;j<i;j++){
p=p->link;
}
*x=p->element;
return OK;
}
//带表头结点单链表的插入
Status Insert(HeaderList *h, int i, ElemType x) {
Node *p, *q;
int j;
if (i<-1 || i>h->n - 1)
return ERROR;
p = h->head; //从头结点开始找ai元素所在的结点p for (j = 0; j <= i; j++) {
p = p->link;
}
q = (Node*)malloc(sizeof(Node)); //生成新结点q
q->element = x;
q->link = p->link; //新结点q插在p之后
p->link = q;
h->n++;
return OK;
}
//带表头结点单链表的删除
Status Delete(HeaderList *h,int i){
int j;
Node *p,*q;
if(!h->n){
return ERROR;
if(i<0||i>h->n-1){
return ERROR;
}
}
q=h->head;
for(j=0;j<i;j++){
q=q->link;
}
p=q->link;
q->link=p->link; //从单链表中删除p所指结点free(p); //释放p所指结点的存储空间h->n--;
return OK;
}
//带表头结点单链表的输出
Status Output(HeaderList *h) {
Node *p;
if (!h->n)
return ERROR;
p = h->head->link;
while (p) {
printf("%d ",p->element);
p = p->link;
}
return OK;
}
//带表头结点单链表的撤销
void Destroy(HeaderList *h){
Node *p,*q;
while(h->head->link){
q=h->head->link;
p=h->head->link->link;
free(h->head->link);
h->head=q;
}
}
void main()
{
int i, x;
HeaderList list;
Init(&list);
for (i = 0; i < 9; i++) {
Insert(&list, i - 1, i); //插入0~8
}
printf("the linklist is:");
Output(&list);
Delete(&list,0); //删除0
printf("\nthe linklist is:");
Output(&list);
Find(&list,0,&x); //查找下标为0的元素printf("\nthe value is:");
printf("%d ",x);
Destroy(&list);
}
实验结果:。

相关文档
最新文档