链式单链表

最新推荐文章于 2022-10-23 16:11:34 发布
最新推荐文章于 2022-10-23 16:11:34 发布
阅读量442 收藏 2
点赞数
分类专栏： 数据结构 算法秘籍 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41943578/article/details/82946466
版权

题目：

    构造一个单链表，实现创建、删除、插入、查找等功能。

解析：

初始化单链表，即单链表的表头指针为空

void initlist(node **pnode)
{
	*pnode = NULL;
	printf("初始化成功!\n");
}

 打印链表元素,遍历链表 

//打印链表元素,遍历链表 
void printinfo(linklist list)
{
	lnode *head;
	if(head == NULL)//链表为空 
		cout<<"链表为空!"<<endl;
	//链表不为空则输出打印出元素 
	else 
	{
		cout<<"链表元素为:";
		for(head=list;head!=NULL;head=head->next)//第一个指向list
			cout<<head->data<<" ";
		cout<<endl<<endl;
	}
}

知晓链表长度创建一个线性链表

从线性表的第一个元素开始依次获取表中的数据元素，每取得一个数据元素，就为该数据元素生成一个新的链结点，将取得的数据元素的数据信息送新的结点的数据域的同时，将新结点的指针域置为NULL，然后将新的链结点插入到链表的尾部。当取第1个数据元素时，链表为空，此时只需要将新的链结点的地址传送即可 。

linklist creat(int n)
{
	linklist p,r,next = NULL;
	elemtype a;
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a);//获取一个数据元素 
		p = (linklist)malloc(sizeof(node));//申请一个新的结点 
		p->data = a;
		p->next = NULL;//链表末尾指针域置空 
		if(next == NULL)
			next = p;
		else
			r->next = p;//将新的结点链接在链表的尾部 
		r=p;//指针变量总是指向链表的末尾 
	} 
	return next;
}

求链表的长度（1）

首先将指针指向链表的第一个链结点，然后遍历链表，指针变量每指向一个链结点，计数器就加1，遍历结束后，计数器的数据就是链表的长度。

int length1(linklist list)
{
	linklist p = list;
	int n = 0;
	while(p!=NULL)
	{	
		n++;//计数器累加 
		p = p->next; //指针p指向下一个链结点 
	}
	return n;//返回链表的长度 
}

求链表的长度（2）

递归结构，即每个链结点的指针域均指向一个线性链表，它所指向的链结点为该链表的第1个链结点。

int length2(linklist list)
{
	if(list!=NULL)
		return 1+length2(list->next);
	else
		return 0; 
}

测试链表是否为空

如果指针指向的第1个链结点为NULL，则链表为空，否则链表非空。

void isempty(linklist list)
{
	if(list == NULL)
        printf("链表为空\n");
    else
    	printf("链表非空\n");
}

确定元素item在线性链表中的位置

从链表的第1个链结点开始，依次遍历链表，查找其是否与给定值item相匹配。如果相匹配则输出item的位置，否则则输出链表中该值不存在。

linklist find(linklist list,elemtype item)
{
	linklist p = list;
	int place = 1;//计数器记录位置
	while(p !=NULL && p->data != item)//查询是否匹配
	{
		place++;
		p = p->next;
	}
	if(p !=NULL && p->data == item)
		cout<<"item的位置为:"<<place<<endl;
	else
		cout<<"item不存在!"<<endl;
}

在非空线性链表的第1个链结点前插入一个数据信息为item的链结点

首先申请一个新的链结点，将其数据信息item置于新链结点的数据域内，然后将第1个结点的指针list送入新结点的指针域内，同时将新结点的地址赋予给list，从而新结点插入链表的最前面，由此完成插入。

void insert1(linklist &list,elemtype item)
{
	//list中存放链表的首地址
	linklist p;
	p = (linklist)malloc(sizeof(node));//申请一个新的链接点
	p ->data = item;//将item送新结点的数据域
	p ->next = list;//将list送新结点的指针域
	list = p;//list指向新结点 
}

非空线性链表的末尾插入一个数据信息为item的链接点

首先设置一个指针变量，使其指向链表的第1个链结点，然后反复执行直到其等于NULL，此时指针指向链表的末尾链结点，然后将item送入申请的新结点的数据域的同时，将新的结点的指针域置为NULL，最后将新的结点的地址送入指针变量指向的链结点的指针域中，由此完成插入。

void insert2(linklist list,elemtype item)
{
	//list存放链表的首地址
	linklist p,r;
	r = list;
	while(r->next!=NULL)
		r = r->next;//找到链表末尾结点的地址 
	p = (linklist)malloc(sizeof(node));//申请一个新的链接点
	p ->data = item;//将item送新结点的数据域
	p ->next = NULL;//新结点的指针域置为NULL 
	r ->next =p;//插入链表的末尾 
}

在线性链表中的第i个链结点后面插入一个数据信息为item的链接点

从第1个结点开始查询直到第i个结点，然后将新的结点插到它们的后面。如果不存在第i个链结点则输出不存在。如果存在第i个链结点则申请一个新的结点，然后将item送入新的结点的数据域，并且将新的结点插到第i个链结点之后，如此插入成功。

void insert4(linklist list,int i,elemtype item)
{
	linklist p,q = list;
	int j=1;
	while(j<i&&q!=NULL)
	{
		q = q ->next;
		j++; 
	}//寻找第i个链结点
	if(j!=i||q==NULL)
		printf("链表中不存在第i个链结点");
	p = (linklist)malloc(sizeof(node));//申请一个新的链结点
	p ->data = item;//将item送新结点的数据域
	p ->next = q ->next;
	q ->next = p;//将新结点插入第i个链结点之后
}

在按值有序链接的线性链表中插入一个数据信息为item的链结点

先为被插入的链结点申请一个新的链结点，然后从链表的第一个链结点开始顺序查找插入位置，在查找的过程中保留当前链结点的直接前驱结点的位置，由此进行插入。

void insert5(linklist &list,elemtype item)
{
	linklist p,q,r;
	p = (linklist)malloc(sizeof(node));
	p ->data = item;
	if(list==NULL||item<list->data)//若链表为空或者item小于第1个链结点 
	{
		p ->next = list;//将新的链结点插在链表最前面 
		list = p;//list指向被插入的新结点 
	}	
	else
	{
		q = list;
		while(q!=NULL&&item>=q->data)//寻找插入位置 
		{
			r = q;
			q = q->next;
		}
		p->next = q;
		r->next = p;//将新的链结点插在q指示的链结点后面 
	} 
}

销毁一个线性链表

设置一个指针变量，先将其指向链表的第1个链结点，然后遍历整个链表，过程中删除并释放链结点。

void deletelist(linklist &list)
{
	linklist p = list;
	while(p!=NULL)
	{
		list = p->next;//保存下一个链结点的位置
		free(p);//删除并释放当前的链结点
		p = list;//下一个链结点成为当前链结点
	}
}

删除第k个结点

从链表第一个链结点开始，找到第k个链结点，然后删除该结点并释放空间。

lnode* getelem(linklist list,int k)
{
    lnode* s=list;
    while(k)
    {
        s=s->next;
        k--;
    }
    return s;
}

void deletelist3(linklist list,int k)
{
    lnode* p=list;
    lnode* q=NULL;
    p=getelem(list,k-1);
    q=p->next;
    p->next=q->next;
    free(q);

}

逆转一个线性链表

通过改变链结点指针域中的地址来依次改变数据元素的关系。

//逆转一个线性链表
void invert(linklist &list)
{
	linklist p,q,r;
	p = list;
	q = NULL;
	while(p!=NULL)
	{
		r = q;
		q = p;
		p = p->next;
		q->next = r;
	}
	list = q;
}

复制一个线性链表

如果一个链表为空，则输出链表为空。如果链表非空则复制链表所指的链结点，并将该链结点的指针赋给另外一个链结点，然后复制链结点后面一个链结点，最后返回另一个链表的第1个链结点

//复制一个线性链表
linklist copy(linklist lista)
{
	linklist listb;
	if(lista==NULL)
		cout<<"链表为空"<<endl;
	else
	{
		listb = (linklist)malloc(sizeof(node));
		listb->data = lista->data;
		listb->next = copy(lista->next); 
	}
	return listb;
}

附：源代码

#include<iostream>
#include<cstdio>
#include<malloc.h>
using namespace std;
typedef int elemtype;

typedef struct node
{
	elemtype data;//数据域 
	struct node *next;//指针域 
}lnode,*linklist;//定义一个线性链表的类型 

void initlist(linklist *pnode)
{
	*pnode = (linklist)malloc(sizeof(lnode));
	if(*pnode == NULL)
		printf("初始化失败\n\n");
	else
	{
		(*pnode)->next =NULL;
		printf("初始化成功!\n\n"); 
	}
}

linklist creat(int n)
{
	linklist p,r,next = NULL;
	elemtype a;
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a);//获取一个数据元素 
		p = (linklist)malloc(sizeof(node));//申请一个新的结点 
		p->data = a;
		p->next = NULL;//链表末尾指针域置空 
		if(next == NULL)
			next = p;
		else
			r->next = p;//将新的结点链接在链表的尾部 
		r=p;//指针变量总是指向链表的末尾 
	} 
	return next;
}

//求线性链表的长度
int length1(linklist list)
{
	linklist p = list;
	int n = 0;
	while(p!=NULL)
	{	
		n++;//计数器累加 
		p = p->next; //指针p指向下一个链结点 
	}
	return n;//返回链表的长度 
} 

//求线性链表的长度(递归)
int length2(linklist list)
{
	if(list!=NULL)
		return 1+length2(list->next);
	else
		return 0; 
} 

//测试线性链表是否为空
void isempty(linklist list)
{
	if(list == NULL)
        printf("链表为空\n");
    else
    	printf("链表非空\n");
} 

//确定元素item在线性链表中的位置
linklist find(linklist list,elemtype item)
{
	linklist p = list;
	int place = 1;
	while(p !=NULL && p->data != item)
	{
		place++;
		p = p->next;
	}
	if(p !=NULL && p->data == item)
		cout<<"item的位置为:"<<place<<endl;
	else
		cout<<"item不存在!"<<endl;
}

//在非空线性链表的第1个链结点前插入一个数据信息为item的链结点
void insert1(linklist &list,elemtype item)
{
	//list中存放链表的首地址
	linklist p;
	p = (linklist)malloc(sizeof(node));//申请一个新的链接点
	p ->data = item;//将item送新结点的数据域
	p ->next = list;//将list送新结点的指针域
	list = p;//list指向新结点 
} 

//非空线性链表的末尾插入一个数据信息为item的链接点
void insert2(linklist list,elemtype item)
{
	//list存放链表的首地址
	linklist p,r;
	r = list;
	while(r->next!=NULL)
		r = r->next;//找到链表末尾结点的地址 
	p = (linklist)malloc(sizeof(node));//申请一个新的链接点
	p ->data = item;//将item送新结点的数据域
	p ->next = NULL;//新结点的指针域置为NULL 
	r ->next =p;//插入链表的末尾 
}


//在线性链表中的第i个链结点后面插入一个数据信息为item的链接点
void insert4(linklist list,int i,elemtype item)
{
	linklist p,q = list;
	int j=1;
	while(j<i&&q!=NULL)
	{
		q = q ->next;
		j++; 
	}//寻找第i个链结点
	if(j!=i||q==NULL)
		printf("链表中不存在第i个链结点");
	p = (linklist)malloc(sizeof(node));//申请一个新的链结点
	p ->data = item;//将item送新结点的数据域
	p ->next = q ->next;
	q ->next = p;//将新结点插入第i个链结点之后
}

//在按值有序链接的线性链表中插入一个数据信息为item的链结点
linklist insert5(linklist &list,elemtype item)
{
	linklist p,q,r;
	p = (linklist)malloc(sizeof(node));
	p ->data = item;
	if(list==NULL||item<list->data)//若链表为空或者item小于第1个链结点 
	{
		p ->next = list;//将新的链结点插在链表最前面 
		list = p;//list指向被插入的新结点 
	}	
	else
	{
		q = list;
		while(q!=NULL&&item>=q->data)//寻找插入位置 
		{
			r = q;
			q = q->next;
		}
		p->next = q;
		r->next = p;//将新的链结点插在q指示的链结点后面 
	} 
	return list;
}

//销毁一个线性链表
void deletelist(linklist &list)
{
	linklist p = list;
	while(p!=NULL)
	{
		list = p->next;//保存下一个链结点的位置
		free(p);//删除并释放当前的链结点
		p = list;//下一个链结点成为当前链结点
	}
} 


lnode* getelem(linklist list,int k)
{
    lnode* s=list;
    while(k)
    {
        s=s->next;
        k--;
    }
    return s;
}

void deletelist3(linklist list,int k)
{
    lnode* p=list;
    lnode* q=NULL;
    p=getelem(list,k-1);
    q=p->next;
    p->next=q->next;
    free(q);

}

//逆转一个线性链表
void invert(linklist &list)
{
	linklist p,q,r;
	p = list;
	q = NULL;
	while(p!=NULL)
	{
		r = q;
		q = p;
		p = p->next;
		q->next = r;
	}
	list = q;
} 

//复制一个线性链表
linklist copy(linklist lista)
{
	linklist listb;
	if(lista==NULL)
		cout<<"链表为空"<<endl;
	else
	{
		listb = (linklist)malloc(sizeof(node));
		listb->data = lista->data;
		listb->next = copy(lista->next); 
	}
	return listb;
} 


//打印链表元素,遍历链表 
void printinfo(linklist list)
{
	lnode *head;
	if(head == NULL)//链表为空   
		cout<<"链表为空!"<<endl;
	//链表不为空则输出打印出元素 
	else 
	{
		cout<<"链表元素为:";
		for(head=list;head!=NULL;head=head->next)//第一个元素指向list  
			cout<<head->data<<" ";
		cout<<endl<<endl;
	}
}

int main()
{

	lnode *list = NULL; 
	elemtype length = 0,item;
	
	//测试链表是否为空
	cout<<"测试链表是否为空!"<<endl;
	isempty(list);
	
	//初始化单链表，即单链表的表头指针为空
	cout<<endl<<"初始化链表!"<<endl;
	initlist(&list);//链表初始化 
	
	//知晓链表长度创建一个线性链表
	cout<<"创建链表!"<<endl; 
	int m;//长度 
	cout<<"输入链表长度:";
	scanf("%d",&m);
	cout<<"输入数据:";
	list = creat(m);//数据元素需要接收回来赋给list 
	printinfo(list); 
	
	//求线性链表的长度
	cout<<"链表的长度:";
	cout<<length1(list)<<endl;
	
	//递归求链表的长度
	cout<<"递归求链表的长度:";
	cout<<length2(list)<<endl<<endl; 
	
	//测试链表是否为空
	cout<<"测试链表是否为空!"<<endl;
	isempty(list);
	
	//确定元素item在线性链表中的位置
	cout<<endl<<"确定item在链表中的位置!"<<endl; 
	cout<<"输入item:";
	scanf("%d",&item); 
	find(list,item);
	
	//在非空线性链表的第1个链结点前插入一个数据信息为item的链结点
	cout<<endl<<"在链表第1个链结点插入item!"<<endl; 
	cout<<"输入item:";
	scanf("%d",&item);
	insert1(list,item);
	printinfo(list); 
	
	//非空线性链表的末尾插入一个数据信息为item的链接点
	cout<<endl<<"在链表末尾插入item!"<<endl; 
	cout<<"输入item:";
	scanf("%d",&item);
	insert2(list,item);
	printinfo(list); 
	
	//在线性链表中的第i个链结点后面插入一个数据信息为item的链接点
	cout<<endl<<"在链表中的第i个链结点后面插入item!"<<endl; 
	cout<<"输入item:";
	scanf("%d",&item);
	elemtype i;
	cout<<"输入i:";
	scanf("%d",&i);
	insert4(list,i,item);
	printinfo(list);

	//在按值有序链接的线性链表中插入一个数据信息为item的链结点
	cout<<endl<<"在按值有序链接的线性链表中插入item!"<<endl; 
	cout<<"输入item:";
	scanf("%d",&item);
	list = insert5(list,item);
	printinfo(list);
	
	
	//删除第 k 个节点
	cout<<endl<<"删除第k个结点!"<<endl;
	elemtype k;
	cout<<"输入k:";
	cin>>k;
	deletelist3(list,k);
	printinfo(list);
	
	//逆转一个线性链表
	cout<<endl<<"逆转链表!"<<endl; 
	invert(list);
	printinfo(list);
	
	//复制一个线性链表
	cout<<"复制链表!"<<endl; 
	copy(list);
	printinfo(list);

    //销毁一个线性链表
	cout<<endl<<"销毁链表!"<<endl;
	deletelist(list);
	isempty(list);
	
	return 0;
}

                                           

梦逸雨涵
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表内容介绍.zip
03-25
而next pointer则用于连接链表中的各个节点，形成一个链式结构。 链表不同于数组，数组中的元素在内存中是连续存储的，而链表的节点可以在内存的任何位置，只要通过next指针能够相互链接即可。这使得链表在插入和...
单链表的创建、插入、删除、查找、遍历等功能（C语言实现）
weixin_46626833的博客
05-25 4650
下面展示一些 内联代码片。 //用到的头文件、结构体 #include <stdio.h> #include <stdlib.h> typedef int elemtype; typedef struct node { elemtype data; struct node *next; }LinkList; int i;//记录链表节点的个数(除头结点) //头插法创建链表 LinkList *creat_LinkListF() { i = 0;
单链表——建立一个空的单链表
qq_45820351的博客
10-02 5159
单链表——建立一个空的单链表 slnklist.h #include <stdio.h> #include <stdlib.h> /**************************************/ /* 链表实现的头文件，文件名slnklist.h */ /**************************************/ typedef int datatype; typedef struct link_node{ datatype info;
java linklist方法_java LinkedList的使用方法介绍
weixin_36332320的博客
02-16 3820
LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用.LinkedList的构造函数如下1. public LinkedList(): ——生成空的链表2. public LinkedList(Collection col): 复制构造函数1、获取链表的第一个和最后一个元素importjava.util.LinkedList;publicclassLinkedL...
数据结构 | 链式线性表
鷾
09-30 815
链式线性表的基本操作，包括线性表的创建、插入元素、链表逆置、销毁链表等
使用C语言实现单链表的功能（带头节点）
Keep_Trying_Go的博客
08-06 883
使用C语言实现单链表的功能（带头节点）
单链表LinkList
12-31
使用数据结构中的方法，实现链式存储结构，达到节省空间的目的
java实现单链表
12-22
1）链表是以节点的方式来存储,是链式存储。 2）每个节点包含 data 域， next 域：指向下一个节点。 3）如上图：发现链表的各个节点不一定是连续存储。 4）链表分带头节点的链表和没有头节点的链表，根据实际的需求来...
数据结构单链表
11-05
单链表是线性表的链式存储表示。 2. 链式存储结构特点：与顺序存储相比，链式存储允许动态调整空间，但访问元素时需要遍历链表。 3. 头结点的作用：头结点用于标记链表的起始位置，即使链表为空，也有一个头结点存在...
单链表上机报告
09-10
单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据元素和一个指针，该指针指向下一个节点。在这个数据结构上机实验中，学生们被要求使用C#语言来实现单链表的模型，并为其添加各种操作功能。 首先...
数据结构（数据表之单链表）（Day4）
楚子航
04-06 1709
一、线性表的链式存储结构（什么是链表及其原理） 将线性表L=(a0,a1,……,an-1)中各元素分布在存储器的不同存储块，称为结点，通过地址或指针建立元素之间的联系 。 结点的data域存放数据元素ai，而next域是一个指针，指向ai的直接后继ai+1所在的结点。 举例： 结点类型描述： typedef struct node { data_t data; //结点的数据域// struct node *next; ...
数据结构中的.和-＞的辨析
MichaelSuns的博客
11-03 6190
在数据结构中我们经常会用到p->data,p.data,p->lchild等，这里的.和->分别是什么意思？各自的用法是什么？详解如下： -> 左边是结构体指针，右边是结构体成员，因此p->next 的含义是p指针指向结构体zhi变量的next数据域（一般该数据域存放后继dao结点的地址） . 左边是结构体变量名，右边是结构体成员，因此p.next的含义是p结构体变量的next数据域，如： SqList &L;//这里的L是一个变量 L.data[1]=1; SqLi
数据结构我好爱：02单链表的基本操作
qq_60678811的博客
04-28 206
#include<stdio.h> #include<malloc.h> typedef struct link { int data; struct link* next; }Link,*LinkPtr; LinkPtr AppendNode_tail(LinkPtr head,int data){//tail LinkPtr p = NULL, pr = head; p = (Link*)malloc(sizeof(Link)); p...
数据结构——4.单链表
qq_51330164的博客
05-05 1251
数据结构 4.单链表 线性表的链式表示和实现——链表 将每个结点放在一个独立的存储单元中，结点间的逻辑关系依靠存储单元中附加的指针来给出。前一个数据的指针指向了后一个数据，以此类推。 结点的存储单元在物理位置上可以相邻，也可以不相邻。 结点由两部分组成： 数据字段+指针字段（后继元素的地址） 链表节点图示 单链表示意图 指针P1指向下一个结点A2这个整体的首地址，结点A2中的指针域中的指针P2，指向下一个结点A3这个整体的首地址。 首元结点是存储第一个数据元素的结点，也称为第一元素结点。 头结点是在首元
（三）线性表 -- 中
FionaDong的博客
08-15 428
5.
链表（一）——创建一个最基本的单向链表
laoniu_c的专栏
07-14 1330
1.结点 链表中用来存储一个数据的存储单元。 一个链表至少需要由两部分组成，就是数据域和指针域，一般形式的结点定义为： struct node {     Elem data; //Elem类型泛指基本数据类型     struct node *next; } typedef struct node Elemsn; 以上两步等价于： typedef struct node {
【C++ 深入浅出】C++指针运算和指针安全总结
捡起一束光的博客
02-16 1399
文章目录指针的运算数组和指针的关系*(p + 4) 和 p[4]指针和结构的关系p->data; 和 (*p).data指针的安全问题 指针的运算 指针p可以加上或减去一个整数n，但指针的这种运算的意义和通常的数值的加减 运算的意义是不一样的，它是以单元为单位，如p指向int型整数，则一个单位是sizeof(int) （1）示例1 char a[20]="You are my friend"...
c语言单链表
sunzixian998的博客
10-23 798
2.2创建单链表头结点。5.1按位置删除元素。2.1先创建指针结构。3.1按位置插入元素。4.1按位置查找元素。4.2按数值查找位置。
关于scanf(“%d“, &p-＞data)的执行问题
little_yuan20的博客
01-30 4184
首先来看scanf的使用方法 scanf(“输入控制符”, 输入参数); 功能：将从键盘输入的字符转化为“输入控制符”所规定格式的数据，然后存入以输入参数的值为地址的变量中。 例如 #include <stdio.h> int main(void) { int i; scanf("%d", &i); //&i 表示变量 i 的地址，&是取地址符 printf("i = %d\n", i); return 0; } 之后则是C语言运算符优
链式线性表单链表的倒数
最新发布
05-29
对于单链表来说，我们可以使用快慢指针的方法来找到倒数第k个节点。具体来说，我们定义两个指针p1和p2，首先让p1指向链表的头节点，然后让p2指向第k个节点。接着，同时移动p1和p2指针，直到p2指向链表的尾节点。此时...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值