[手撕数据结构] 链表及其基本操作

已于 2022-05-05 17:16:27 修改
阅读量555 收藏
点赞数 7
分类专栏： 手撕数据结构 文章标签： 链表 数据结构
于 2022-02-20 17:38:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60055052/article/details/123032622
版权

链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。相比于数组这种连续性的储存结构，链表对于插入及删除等操作将更为方便。

单链表

#include<stdlib.h>
#include<stdbool.h>
#include<iostream>
using namespace std;
struct student
{
	int score;
	struct student* next;
};
typedef struct student stu;
stu* Creat_Node(int x)//申请结点
{
	stu* new_node = new stu;
	new_node->score = x;
	new_node->next = NULL;
	return new_node;
}
void Initlist(stu*& L)//初始化 stu* &L表示对一个指针的引用
{
	L = new stu;
	L->next = NULL;
}

void Insert(int i, int k, stu* L)//在第i个位置插入k；Insert(Get_length(L)+1, 2, L)实现尾插；Insert(1, 2, L);实现头插
{
	stu* o = L;
	for (int j = 1; j < i; j++)
	{
		o = o->next;
	}
	stu* p = new stu;
	p->score = k;
	p->next = o->next;
	o->next = p;
}
void Print_list(stu* head)//遍历打印链表
{
	if (head->next == NULL)
	{
		cout << "空表" << endl;
		return;
	}
	head = head->next;
	while (head)
	{
		cout << head->score << "->";
		head = head->next;
	}
	cout << "NULL" << endl;
	return;
}
void Delete_Kth(stu* list, int k)//删除第k个结点
{
	for (int i = 1; i < k; i++)
	{
		list = list->next;
	}
	stu* p = new stu;
	p = list->next;
	list->next = list->next->next;
	delete p;
	return;
}
int Get_length(stu* list)//获得链表长度
{
	stu* p = list;
	if (p->next == NULL)
	{
		return 0;
	}
	int j = 0;
	p = p->next;
	while (p != NULL)
	{
		p = p->next;
		j++;
	}
	return j;
}
void Find_first(int k, stu* list)//寻找出现值的第一个结点
{
	stu* p = list;
	p = p->next;
	for (int i = 1; i <= Get_length(list); i++)
	{
		if (p->score == k)
		{
			cout << k << "第一次出现的位置为" << i << endl;
			return;
		}
		else
			p = p->next;
	}
	cout << "表中无此值" << endl;
	return;
}
void Find_Kth(int k, stu* list)//寻找第K个结点的值
{
	stu* p = list;
	p = p->next;
	int i = 1;
	while (p->next != NULL && i < k)//p->next==NULL的时候说明此时p已经是最后一个结点
	{
		i++;
		p = p->next;
	}
	if (i == k)
	{
		cout << "第" << k << "个结点的值为" << p->score << endl;
		return;
	}
	else
	{
		cout << "没有第" << k << "个结点" << endl;
		return;
	}

}
void Delete_k(int k, stu* list)//删除所有元素为K的结点
{
	stu* p = list;
	while (p->next)
	{
		if (p->next->score == k)
		{
			stu* q = new stu;
			q = p->next;
			p->next = p->next->next;
			delete q;
		}
		else
			p = p->next;
	}
	return;
}
void sort_list(stu* head)//排序
{
	for (int i = 1; i <= Get_length(head); i++)
	{
		stu* p = head->next;
		for (int j = 1; j < Get_length(head); j++)
		{
			if (p->score > p->next->score)
			{
				int a = p->score;
				p->score = p->next->score;
				p->next->score = a;
			}
			p = p->next;
		}
	}
}
void Merge_list(stu* L, stu* M)//合并链表于L
{
	stu* p = L;
	for (int i = 0; i < Get_length(L); i++)
	{
		p = p->next;
	}
	p->next = M->next;//表尾下接表头
}
void Remove_DupliCation(stu* head)//除去重复元素
{
	stu* p = head->next;
	for (int i = 1; i <Get_length(head); i++)
	{
		if (p->score == p->next->score)
		{
			stu* q = p->next;
			p->next = p->next->next;
			delete q;
		}
		else
			p = p->next;
	}
}
int main()
{
	stu* L;
	Initlist(L);
	stu* M;
	Initlist(M);
	Insert(1, 12, L);
	Insert(1, 7, L);
	Insert(1, 6, L);
	Insert(1, 5, L);
	cout << "L链表: ";
	Print_list(L);
	Insert(1, 11, M);
	Insert(1, 7, M);
	Insert(1, 6, M);
	Insert(1, 3, M);
	Insert(1, 1, M);
	cout << "M链表: ";
	Print_list(M);
	Merge_list(L, M);
	cout << "合并后的链表为:";
	Print_list(L);
	sort_list(L);
	cout << "排序后的链表为：";
	Print_list(L);
	Remove_DupliCation(L);
	cout << "去重后的链表为: ";
	Print_list(L);
	return 0;
}
//嗨害嗨

双向链表

#include<stdlib.h>
#include<stdbool.h>
#include<iostream>
using namespace std;
#define OK 1;
#define ERROR 0;
#define ElemType int;
#define TRUE  1
#define FALSE 0
#define INFEASIBLE  -1
typedef int Status;
struct student
{
	int score;
	struct student* next;
	struct student* last;
};
typedef struct student stu;
Status Initlist(stu* &L)//初始化 stu* &L表示对一个指针的引用
{
	L = new stu;
	L->next = NULL;
	L->last = NULL;
	return OK;
}
Status Insert(int i, int k, stu* L)//在第i个位置插入k；Insert(Get_length(L)+1, 2, L)实现尾插；Insert(1, 2, L);实现头插
{
	stu* o = L;
	for (int j = 1; j < i; j++)
	{
		o = o->next;
	}
	stu* p = new stu;
	p->score = k;
	p->next = o->next;
	p->last = o;
	o->next = p;
	if (p->next != NULL)
	{
      p ->next->last = p;
	}
	
	return OK;
}
Status Print_link(stu* head)//遍历打印链表
{
	if (head->next == NULL)
	{
		cout << "空表" << endl;
		return ERROR;
	}
	head = head->next;
	while (head)
	{
		cout << head->score << endl;
		head = head->next;
	}
	cout << "遍历结束" << endl;
	return OK;
}
Status Delete_Kth(stu* list, int k)//删除第k个结点
{
	for (int i = 1; i < k; i++)
	{
		list = list->next;
	}
	stu* p = new stu;
	p = list->next;
	list->next = list->next->next;
	list->next->last = list;
    delete p;
	return OK;
}
Status Get_length(stu* list)//获得链表长度
{
	stu* p = list;
	if (p->next == NULL)
	{
		return ERROR;
	}
	int j = 0;
	p = p->next;
	while (p!=NULL)
	{
		p = p->next;
		j++;
	}
	return j;
}
Status Find_first(int k, stu* list)//寻找出现值的第一个结点
{
	stu* p = list;
	p = p->next;
	for (int i = 1; i <= Get_length(list); i++)
	{
		if (p->score == k)
		{
			cout << k << "第一次出现的位置为" << i << endl;
           return OK;
		}
			
		else
			p = p->next;
	}
	return ERROR;
}
Status  Find_Kth(int k, stu* list)//寻找第K个结点的值
{
	stu* p = list;
	p = p->next;
	int i = 1;
	while (p->next!=NULL && i < k)//p->next==NULL的时候说明此时p已经是最后一个结点
	{
        i++;
        p = p->next;
	}
	if (i == k)
	{ 
		cout << "第" << k << "个结点的值为" << p->score << endl;
		return OK;
	}
	else
	{
		cout << "没有第" << k << "个结点" << endl;
       return ERROR;
	}
		
}
Status Delete_k(int k, stu* list)//删除所有元素为K的结点
{
	stu* p = list;
	while (p->next)
	{
		if (p->next->score == k)
		{
			stu* q = new stu;
			q = p->next; 
			p->next = p->next->next;
			p->next->last = p;
			delete q;
		}
		else
		p = p->next;
	}
return OK;
}
Status Clear_link(stu* head)
{
	if (head == NULL)
	{
		return ERROR;
	}
	stu* p = head;
	p = p->next;
	while (p != NULL)
	{
		stu* tmp = p;
		p = p->next;
		free(tmp);
	}
	head->next = NULL;
	cout << "链表已清空" << endl;
	return OK;
} 
int main()
{
	stu* L;
	Initlist(L);
	Insert(1, 3, L);
	Insert(1, 3, L);
	Insert(1, 3, L);
	Insert(2, 8, L);
	Insert(1, 3, L);
	Insert(1, 2, L);
	Insert(Get_length(L)+1, 2, L);
	Print_link(L);
	Delete_k(3, L);
	Print_link(L);
	return 0;
}
//嗨害嗨

双向循环链表

#include<stdlib.h>
#include<stdbool.h>
#include<iostream>
using namespace std;
struct student
{
	int score;
	struct student* next;
	struct student* last;
};
typedef struct student stu;
void Initlist(stu*& L)//初始化 stu* &L表示对一个指针的引用
{
	L = new stu;
	L->next = L;
	L->last = L;
}

stu* Creat_Node(int x)//申请结点
{
	stu* new_node = new stu;
	new_node->score = x;
	new_node->next = NULL;
	new_node->last = NULL;
	return new_node;
}

void Print(stu* head)//打印
{
	if (head->next == head)
	{
		cout << "空表" << endl;
		return;
	}
	stu* current = head->next;
	while (current != head)
	{
		cout << current->score << endl;
		current = current->next;
	}
}

void Tail_Plug(stu* head, int x)//尾插
{
	stu* new_node = Creat_Node(x);
	new_node->next = head;
	new_node->last = head->last;
	head->last->next = new_node;
	head->last = new_node;
}

void Delete_tail(stu* head)//尾删
{
	stu* p = head->last;
	p->last->next = head;
	head->last = p->last;
	delete p;
}

void Head_Plug(stu* head, int x)//头插
{
	stu* p = Creat_Node(x);
	p->next = head->next;
	head->next->last = p;
	p->last = head;
	head->next = p;
}

void Delete_head(stu* head)//头删
{
	stu* p = head->next;
	head->next = p->next;
	p->next->last = head;
	delete p;
}

int Get_length(stu* head)//获得链表长度
{
	stu* p = head;
	if (p->next == NULL)
	{
		return 0;
	}
	int j = 0;
	while (p->next != head)
	{
		p = p->next;
		j++;
	}
	return j;
}

void Insert(int i, int k, stu* L)//在第i个位置插入k;
{
	if (i <= Get_length(L))
	{
		stu* o = L;
		for (int j = 1; j < i; j++)
		{
			o = o->next;
		}
		stu* p = Creat_Node(k);
		p->next = o->next;
		p->last = o;
		o->next = p;
	}
	else
		cout << "第" << i << "个位置不合法" << endl;
}

void Delete_Kth(stu* list, int k)//删除第k个结点
{
	if (k > Get_length(list) || k < 1)
	{
		cout << "没有第" << k << "个结点" << endl;
		return;
	}
	for (int i = 1; i < k; i++)
	{
		list = list->next;
	}
	stu* p = list->next;
	list->next = list->next->next;
	list->next->last = list;
	delete p;
}

void Find_first(int k, stu* list)//寻找出现值的第一个结点
{
	stu* p = list;
	p = p->next;
	for (int i = 1; i <= Get_length(list); i++)
	{
		if (p->score == k)
		{
			cout << k << "第一次出现的位置为" << i << endl;
			return;
		}
		else
			p = p->next;
	}
	cout << "表中没有值为" << k << "的结点" << endl;
}

void Find_Kth(int k, stu* head)//寻找第K个结点的值
{
	int i = k;
	if (k <= Get_length(head))
	{
		stu* p = head;
		while (i--)
		{
			p = p->next;
		}
		cout << "第" << k << "个结点的值为" << p->score << endl;
		return;
	}
	else
	{
		cout << "没有第" << k << "个结点" << endl;
		return;
	}
}

void Delete_k(int k, stu* list)//删除所有元素为K的结点
{
	stu* p = list;
	while (p->next != list)
	{
		if (p->next->score == k)
		{
			stu* q = new stu;
			q = p->next;
			p->next = p->next->next;
			p->next->last = p;
			delete q;
		}
		else
			p = p->next;
	}
}

void Clear_link(stu* head)//清空链表
{
	int k = Get_length(head);
	for (int i = 1; i <= k; i++)
	{
		Delete_Kth(head, 1);
	}
	cout << "链表已清空" << endl;
}

int main()
{
	stu* L;
	Initlist(L);
	Tail_Plug(L, 1);
	Tail_Plug(L, 2);
	Tail_Plug(L, 3);
	Tail_Plug(L, 4);
	Head_Plug(L, 8);
	Insert(2, 8, L);
	Insert(2, 8, L);
	Insert(2, 8, L);
	Insert(2, 8, L);
	Insert(108, 5, L);
	Print(L);
	Clear_link(L);
	Print(L);
	return 0;
}
//嗨害嗨

有何不足欢迎批评指正

多想陪你看场雪
关注
  • 7
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构链表的操作
TY113322的博客
03-16 1348
一.链表 1.单链表逆置 解题思路： 使用递归函数，一直递归到链表的最后一个结点，该结点就是反转后的头结点，记作 ret 此后，每次函数在返回的过程中，让当前结点的下一个结点的 next 指针指向当前节点。 同时让当前结点的 next 指针指向 NULL ，从而实现从链表尾部开始的局部反转 当递归函数全部出栈后，链表反转完成。 递归实现版: 非递归实现版本解题思路： 定义两个指针： pre 和 cur ；pre 在前 cur 在后。 每次让 pre 的 next 指向 cur ，实现一次局部反转 局部反转
链表基本结构及操作实现详解
xioacd的博客
10-30 1197
文章目录单向链表节点单向线性链表实现单向链表的操作添加到尾结点添加到中间结点删除链表的尾结点删除链表的中间结点单向环形链表节点基本实现添加到尾结点添加到任意节点删除尾结点删除任意节点双向链表节点双向线性链表添加到尾结点添加到头结点添加到指定节点之前删除链表的尾结点删除链表的头结点删除链表的中间节点双向环形链表反向遍历实现添加到头节点添加到尾结点删除/添加任意节点删除头结点删除尾结点 单向链表 节点 templat <typename T> struct Node { T value;
链表基本操作（详解）
热门推荐
Czc1357618897的博客
11-30 1万+
链表的基本操作 这里写目录标题链表的基本操作一：单链表的基础知识二：单链表的建立头插法尾插法三：单链表的遍历四：单链表结点数目判断五：单链表的插入链表头插入任意结点插入链表尾部插入六：单链表的删除七 ：单链表的查询 一：单链表的基础知识 为什么需要链表？ 我们在使用数组存放数据是非常方便，但是由于数组的长度是固定的，所以当存储不同的元素数量时，就很容易出现问题。如果向数组中添加的数量大于数组大小时候，信息无法完全被保存。所以我们需要另一种存储方式来存储数据，其中存储的元素的个数不受限制。这种存储方式就是链
【数据结构】链表的基本操作
m0_53171456的博客
03-11 8310
规划 /* 链表的基本操作 */ #include<iostream> #include<algorithm> #define ElemType int using namespace std; typedef struct LNode{ ElemType data; //数据域 LNode *next; //指针域 } *LinkList; //链表的初始化 void IniteList(LinkList &L){ L = new LNode; //创建头结点
【数据结构-链表】链表的基本操作
Mount256的博客
10-26 1785
【数据结构-链表】链表的基本操作
数据结构链表基本操作
qq_49983256的博客
06-26 542
链表的基本操作
C语言实现数据结构和双向链表操作
01-21
数据结构 双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef ...
数据结构实验代码链表的基本操作.rar
最新发布
05-01
这个"数据结构实验代码链表的基本操作.rar"文件包含了关于链表操作的实践代码，这将有助于我们深入理解链表的工作原理。 链表分为单链表、双链表和循环链表等类型，其中单链表是最基础的形式。单链表的每个节点包含...
头歌数据结构二叉树的二叉链表存储及基本操作
05-18
在IT领域，数据结构是计算机科学的基础，而二叉树是一种重要的抽象数据类型。本题主要涉及二叉树的链式存储方式以及基于链表的二叉树的基本操作，包括先序遍历、计算二叉树的高度、节点总数、叶子节点数、层次遍历...
【数据结构课程设计】单链表的基本操作（含源代码）
06-14
【数据结构课程设计】单链表的基本操作(含源代码和运行结果）VC++6.0 C/C++ 可运行
数据结构试验 单链表的基本操作及应用
06-03
数据结构试验 单链表的基本操作及应用 源代码 下载
数据结构实现单链表的基本操作
06-24
主要是单链表中元素的插入，删除，还有转置，用C++编写的
单链表的基本操作及实现
11-22
单链表的基本操作及实现单链表的基本操作及实现单链表的基本操作及实现
C语言数据结构 双向链表的建立与基本操作
01-01
C语言数据结构 双向链表的建立与基本操作 双向链表比单链表有更好的灵活性，其大部分操作与线性表相同。下面总结双向链表与单链表之间的不同之处及我在实现过程中所遇到的问题。 1.双向链表的建立 双向链表在初始...
双向链表及其基本操作
10-29
C语言，实现双向链表以及其基本操作，基本操作：链表初始化、创建、查询、删除、释放，查询和删除均有两种方式，一种是按照值，另一种是按照结点的序号。
单链表的基本操作和应用
m0_63569461的博客
05-24 2082
一、单链表的特点 有一个head 指针变量，它存放头结点的地址，称之为头指针。 头结点的指针域 head->next，存放首元结点(第一个实际有效结点)的地址。 每个结点都包含一个数据域和一个指针域，数据域存放用户需要的实际数据，指针域存放下一个结点的地址。从头指针 head开始，head 指向头结点，头结点指向首元结点，首元结点指向第二个结点，…，直到最后一个结点。所有结点都是单线联系环环相扣。 最后一个结点不再指向其他结点,称为“表尾结点”,它的指针域为空指针“NULL”,表示链表到此结束
链表的基本操作
eminemi的博客
07-13 7264
链表的基本操作包括建立（批量存入数据）、打印（输出所有数据）、删除（在批量数据中删除指定数据）、插入（在批量数据中添加一个数据）等。
数据结构链表操作大全，面向对象封装
数据结构链表操作大全是一种在面向对象编程中对链表进行操作的封装方法。链表是一种重要的数据结构，它可以动态地存储和处理数据。本文将介绍链表的创建、插入、删除、查找等操作，并在面向对象的方法上进行封装。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值