链表基础操作(创建、查找、删除、插入、排序)

最新推荐文章于 2023-07-03 13:33:53 发布
最新推荐文章于 2023-07-03 13:33:53 发布
阅读量2.1k 收藏 25
点赞数 10
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55880219/article/details/125862061
版权

文章目录

代码编译器 : VS2019

链表基础操作

1、什么是链表

链表是一种在物理上非连续、非顺序的数据结构，由若干个节点组成。（本文以单向链表为例）

2、链表的基本操作

2.1、创建单链表

2.1.1、头插法
步骤：

1、把新的节点的next指向原先的头节点的下一个节点（这里默认头节点head不存数据，只作为一个链表的开头，所存的第一个数据为头节点的下一个）

//主要代码
nextListNode->next = head->next;

2、把新节点变为头节点的下一个节点

//主要代码
head->next = nextListNode;

由于需要连续插入，故需要时刻改变节点所指向的内容，故：

//循环内的主要代码
p->next = L->next;              //p为临时插入节点，L为头节点
L->next = p;
2.1.2、尾插法
步骤：

把最后的一个节点的next指针指向新插入的节点。（这里默认头节点head不存数据，只作为一个链表的开头，所存的第一个数据为头节点的下一个）

//主要代码
L->next = nextListNode;

由于需要连续插入，故需要时刻改变节点所指向的内容，故：

//循环内主要代码
L->next = p;               //L为当前链表的末尾节点，p为临时插入节点
L = p;

2.2、查找链表

思想：遍历链表，看是否元素，返回一个bool型

//主要代码
bool find_list(ListNode *head, int data) {
	struct List* p = head->next;     //头节点不存数据，只作标记
	while (p != NULL){
		if (p->data == data) {
			return true;
		}
		p = p->next;
	}
	return false;
}

2.3、删除链表

2.3.1、全部删除

思路：从头节点依次往后删除（头节点head不删除,head不存数据，只作为节点的入口或者标识）

//主要代码
void delete_whole_list(ListNode* head) {
	struct List* p = head->next, * q = NULL;
	while (p != NULL) {
		q = p;
		p = p->next;
		free(q);
	}
	head->next = NULL;
	cout << "delete_Whole" << endl;
}
2.3.2、删除一个

思路：遍历链表查找所要删除的元素，然后将该节点的前驱节点的next指向该节点的后继，在释放该节点。

//主要代码
L->next = L->next->next;               //L为删除节点的前驱节点

//函数实现：
bool delete_specific_list_node(ListNode* head, int data) {
	struct List* L = head->next, * p = head;			//p记录data的前驱，L记录当前的data
	while (L != NULL) {	
		p = p->next;
		L = L->next;
		if (L->data == data) {
			p->next = L->next;
			free(L);                                 //释放当前的L无用节点
			return true;                             //返回true，删除成功
		}
	}
	return false;                                   //返回false，删除失败
}

2.4、插入元素

思路：在任意元素的后面插入一个新元素，其中前驱节点的next指针指向新的节点，新节点的next指向后一个节点，若无节点，则指向NULL;

//主要代码
q->next = L->next;
L->next = q;

//函数实现：  data为将要插入链表的数据，number表示在第几个节点后插入，不包括头节点head 
bool insert_specific_list_node(ListNode* head, int data, int number) { 
	struct List* L = head->next, * p = head;     //p记录data的前驱，L记录当前的data
	ListNode* q;                                 //创建节点
	for (int i = 0; i < number; i++) {
		if (L == NULL) {
			return false;                       //判空，返回false
		}
		L = L->next;                           //遍历到相应的节点
		p = p->next;
	}
	q = (ListNode*)malloc(sizeof(ListNode));
	q->data = data;
	p->next = q;
	q->next = L;
	return true;
}

2.5、遍历输出

//主要代码：
void ListOperation::show_out(ListNode* head) {
	struct List *L = head->next;
	while (L != NULL) {
		cout << L->data << " ";
		L = L->next;
	}
	cout << endl;
}

3、链表排序

3.1、冒泡排序

思想：把相邻的元素两两比较，当一个元素大于等于右侧相邻元素时，交换它们的位置；当一个元素小于右侧的元素时，位置不变。

具体操作：先将L指向head的next,作为外循环的主链，用q作为每一次外循环开始的节点（head->next）,tailNode标记尾节点的前移节点。让q节点一直遍历到tailNode，并一直进行比较判断。（头节点head不删除,head不存数据，只作为节点的入口或者标识）

//主要代码
ListNode* hubble_sort(ListNode* head) {
	struct List* q, * L = head->next, * tailNode = NULL;
	for (; L != NULL; L = L->next) {
		q = head->next;
		for (; q->next != tailNode; q = q->next) {
			if (q->data >= q->next->data) {
				swap(q->data, q->next->data);		//交换两个值，系统自带的函数
			}
		}
		tailNode = q;
	}
	return head;
}

3.2、插入排序

思想：从第二开始比较（默认第一个是有序的），从前往后依次比较，在插入元素，直到所有元素插入完成。

具体操作：1、判断链表是否为空（主要是要保证第二个节点有值）

​ 2、NodeLast为已排序的最后一个节点(开始时，指向第一个存放数据的节点)，L为主循环的遍历节点（开始时，指向第一个存放数据的节点），进入循环进行比较：

​ a、 若L->data大于等于NodeLast->data，则直接将NodeLast->next指向L;再将L的地址赋给NodeLast。

​ b、否则，说明已排序的最后一个元素大于将要插入的元素。此时，在从第一个节点往后遍历。找到相应的节点位置，然后，将NodeLase->next指向L->next,并插入相应的元素。然后接着遍历，直到为NULL退出。

//主要代码

ListNode* insert_sort(ListNode* head) {
	if ((head ==NULL) || (head->next ==NULL)) {
		return head;
	}
	struct List* NodeLast = head->next, * L = head->next->next;
	ListNode* newHead = head;
	while (L != NULL) {
		if (L->data >= NodeLast->data) {
			NodeLast->next = L;
			NodeLast = L;
		}
		else {
			ListNode* q = newHead;
			while (q->next->data < L->data) {
				q = q->next;
			}
			NodeLast->next = L->next;
			L->next = q->next;
			q->next = L;
		}
		L = NodeLast->next;
	}
	return newHead;
}

4、完整运行代码：

代码编译器 : VS2019

//建立ListOperation类进行封装     ListOperation.h
#pragma once
#include <cstdlib>
#include <iostream>
using namespace std;
typedef struct List{
	int data;
	struct List* next;
}ListNode;

class ListOperation
{
public:
	ListNode* build_head_insert_List(int array[], int len);
	ListNode* build_tail_insert_List(int array[], int len);
	bool find_list(ListNode* head, int number);
	void delete_whole_list(ListNode* head);
	bool delete_specific_list_node(ListNode* head, int data);
	bool insert_specific_list_node(ListNode* head, int data, int number);
	void show_out(ListNode* head);
	ListNode* hubble_sort(ListNode* head);
	ListNode* insert_sort(ListNode* head);
//private:
//	struct List list;
};


#include "ListOperation.h"
ListNode*  ListOperation::build_head_insert_List(int array[], int len) {
	struct List* head, * p, * L;                     //p临时节点，L标记头节点
	head = (ListNode*)malloc(sizeof(ListNode));     //创建头节点，此节点不用于存储内容
	L = head;
	L->next = NULL;
	for (int i = 0; i < len; i++) {
		p = (ListNode*)malloc(sizeof(ListNode));
		p->data = array[i];
		p->next = L->next;              //头插法
		L->next = p;
	}
	return head;
}

ListNode* ListOperation::build_tail_insert_List(int array[], int len) {
	struct List* head, * p, * L;					p临时节点，L标记头节点
	head = (ListNode*)malloc(sizeof(ListNode));		创建头节点，此节点不用于存储内容
	L = head;
	L->next = NULL;
	for (int i = 0; i < len; i++) {
		p = (ListNode*)malloc(sizeof(ListNode));
		p->data = array[i];
		L->next = p;
		L = p;
	}
	L->next = NULL;
	return head;
}

bool ListOperation::find_list(ListNode *head, int data) {
	struct List* p = head->next;     //头节点不存数据，只作标记
	while (p != NULL){
		if (p->data == data) {
			return true;
		}
		p = p->next;
	}
	return false;
}

void ListOperation::delete_whole_list(ListNode* head) {
	struct List* p = head->next, * q = NULL;
	while (p != NULL) {
		q = p;
		p = p->next;
		free(q);
	}
	head->next = NULL;
	cout << "delete_Whole" << endl;
}

bool ListOperation::delete_specific_list_node(ListNode* head, int data) {
	struct List* L = head->next, * p = head;			//p记录data的前驱，L记录当前的data
	while (L != NULL) {	
		p = p->next;
		L = L->next;
		if (L->data == data) {
			p->next = L->next;
			free(L);                                 //释放当前的L无用节点
			return true;                             //返回true，删除成功
		}
	}
	return false;                                   //返回false，删除失败
}

bool ListOperation::insert_specific_list_node(ListNode* head, int data, int number) { //number表示在第几个节点后插入，不包括头节点 
	struct List* L = head->next, * p = head;     //p记录data的前驱，L记录当前的data
	ListNode* q;                                 //创建节点
	for (int i = 0; i < number; i++) {
		if (L == NULL) {
			return false;                       //判空，返回false
		}
		L = L->next;                           //遍历到相应的节点
		p = p->next;
	}
	q = (ListNode*)malloc(sizeof(ListNode));
	q->data = data;
	p->next = q;
	q->next = L;
	return true;
}

void ListOperation::show_out(ListNode* head) {
	struct List *L = head->next;
	while (L != NULL) {
		cout << L->data << " ";
		L = L->next;
	}
	cout << endl;
}

ListNode* ListOperation::hubble_sort(ListNode* head) {
	struct List* q, * L = head->next, * tailNode = NULL;
	for (; L != NULL; L = L->next) {
		q = head->next;
		for (; q->next != tailNode; q = q->next) {
			if (q->data >= q->next->data) {
				swap(q->data, q->next->data);
			}
		}
		tailNode = q;
	}
	return head;
}

ListNode* ListOperation::insert_sort(ListNode* head) {
	if ((head ==NULL) || (head->next ==NULL)) {
		return head;
	}
	struct List* NodeLast = head->next, * L = head->next->next;
	ListNode* newHead = head;
	while (L != NULL) {
		if (L->data >= NodeLast->data) {
			NodeLast->next = L;
			NodeLast = L;
		}
		else {
			ListNode* q = newHead;
			while (q->next->data < L->data) {
				q = q->next;
			}
			NodeLast->next = L->next;
			L->next = q->next;
			q->next = L;
		}
		L = NodeLast->next;
	}
	return newHead;
}

//main函数示例实现    main.cpp
#include<iostream>
#include"ListOperation.h"

using namespace std;

int main() {
	//int array[] = { 1,2,3,4,5,6,7,8,9,10 };
	int array[] = { 2,1,5,3,4,5,7,9,8,10,0 };
	int data = 11;
	bool find;
	ListOperation listOperation;
	ListNode* head;
	//head = listOperation.build_head_insert_List(array, 10);
	head = listOperation.build_tail_insert_List(array, 11);
	//find = listOperation.find_list(head, 11);
	/*if (find) {
		cout << "true" << endl;
	}
	else {
		cout << "false" << endl;
	}*/
	//listOperation.delete_whole_list(head);
	//listOperation.delete_specific_list_node(head, 4);
	//listOperation.insert_specific_list_node(head, 11, 6);
	//head = listOperation.hubble_sort(head);
	head = listOperation.insert_sort(head);
	listOperation.show_out(head);
	return 0;
}
走过的绿柳荫
关注
  • 10
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
1.3单链表的设计与实现
bao_libra的专栏
05-20 1235
实现单链表的基本操作,包括链表的建立与释放,查找,求长度,查找后继,插入,删除,输出等函数. //调试环境:DevC++ //库文件和预设定义 #include #include #define NULL 0 typedef int ElemType;//指定单链表中的数据类型 //单链表存储结构定义 typedef struct LNode { ElemType data;//数
【数据结构】第二章线性表：单链表的定义、插入和删除、查找、建立
weixin_37706349的博客
10-13 3259
2.3.1 单链表的定义 用链式存储的线性表统称为链表，本小节将会依次学习单链表、双链表、循环链表、静态链表。 一、什么是单链表 二、用代码定义一个单链表 （1）结构体变量和结构体类型的定义 菜鸟教程链接： 结构体变量和结构体类型的定义 | 菜鸟教程 typedef 关键字，将 struct LNode 这个结构体类型名字重新定义为 LNode 和 *LinkList（用来表示指向struct LNmde的指针）； 下次想定义一个 struct LNode 结构体变量时，直接 L..
[数据结构 链表] 链表的定义与表示,删除,插入,初始化,循环链表,双向链表,链表的应用,多项式创建
beiqianqian的博客
07-03 975
n。
线性表之循环链表的建立、查找、插入和删除（附C++程序）
ch18328071580的博客
07-07 3413
本文介绍了线性表中的循环链表，包括循环单链表、循环双链表的头插法和尾插法的建立，按元素查找，插入和删除操作。
数据结构：线性表（链表的实现）
qq_59325159的博客
03-03 697
顺序存储与链式存储的优缺点 链表操作 单链表(带头结点)的代码实现
c语言链表基本操作(带有创建链表 删除 打印 插入)
09-04
本教程主要涉及了链表的基本操作，包括创建链表、删除节点、打印链表以及插入节点。接下来，我们将深入探讨这些操作。 1. **创建链表**： 创建链表通常涉及动态内存分配和节点的初始化。在提供的代码中，`create()...
链表创建排序查找删除
12-01
c++实现链表创建排序查找删除所有单链表功能
数据结构 链表创建、插入、删除排序等
05-14
下面我们将深入探讨链表的创建、插入、删除和排序等操作。 **链表的创建** 创建链表首先需要定义一个节点结构。例如，可以创建一个名为`Node`的结构体，包含一个数据成员`data`和一个指向下一个节点的指针`next`： ...
C语言课设_小区物业管理_查找,统计,排序,链表创建及各种插入删除等操作（代码+程序）
09-02
在本项目中，"C语言课设_小区物业管理_查找,统计,排序,链表创建及各种插入删除等操作（代码+程序）"是针对C语言编程的一次课程设计任务，旨在让学生掌握基本的编程技能以及数据结构中的链表操作。这个项目涵盖了几个...
基于Java实现的单链表基本操作之链表排.zip
最新发布
04-26
1. **插入排序**：遍历链表，每次取出一个元素，将其插入到已排序的子链表的合适位置。对于小规模数据，插入排序效率较高，但对于大规模数据，其性能可能不佳。 2. **归并排序**：将链表分成两半，分别对每一半进行...
顺序表的基本操作，如查找，删除，插入，排序
12-30
学习数据结构的基本操作要求，查找，删除，插入，排序，显示等，VC++开发环境
链表的创建与基本操作（C++ 实现）
vegetable__chicken的博客
07-23 4020
链表即采用链式存储方式的线性表。为了表示每个数据元素  及其后继元素  间的逻辑关系，我们在存储数据元素  的同时，必须存储一个指示其后继 的存储位置的信息  。我们称这样的二元组 为一个结点 ( Node ) 。不多说，直接贴代码吧。   #include &lt;iostream&gt; #include &lt;string&gt; #include &lt;vector&gt; us...
数据结构之线性单链表的基本使用(创建插入查找删除)
theskylife的博客
10-11 1513
链表头插法在C语言中如何实现？如何利用C语言实现尾插法？如何对链表中的元素进行删除？如何在链表查找元素？
单链表的创建，查找，插入，删除、长度
qq_46093754的博客
07-19 1890
单链表线性表的链式存储，通过任意的存储单元来存储线性表中的数据元素。优点不需要大片的连续的空间，改变容量方便。缺点不可随机读取，要耗费一定空间存放指针。
数据结构顺序表与链表（查找，插入，删除）
qq_68433774的博客
09-05 768
顺序表与链式表的操作
链表的基本操作（创建链表、插入结点、删除结点）
qq_41027398的博客
12-29 1590
文章目录链表创建（尾插法） 链表创建（尾插法） 带头结点单链表尾插法创建的基本思想： 创建一个头结点，让一个指针指向链表最尾端，新建结点插入指针指向的结点之后，然后调整指针位置 #include<stdio.h> #include<stdlib.h> typedef struct node{ int number; struct node* next; }LNode,*LinkList; int main(){//尾插法创建链表 LinkList head = (LinkLis
线性表链式存储-初始化、插入、删除、查找、读取操作（C语言）
热门推荐
苍之羽
01-11 1万+
一、单链表抽象数据类型定义： #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; #define OK 1 #define ERROR 0 typedef int Elemtype;//数据类型重定义 typedef int Status;//状态类型重定义 typedef struct LNode{ Elemtyp...
线性表的链式结构
sunlanchang的博客
04-17 824
实验一 线性表的基本操作 一、实验目的 1）掌握顺序表、链表的概念，学会对顺序表、链表进行操作。 2）实现顺序表、链表的存储结构，逐步培养解决实际问题的能力 二、实验内容 顺序表、链表结构的生成,插入,删除,定位,查找 三、实验步骤 1、定义节点 2、生成一个单链表（正序建立单链表或逆序建立单链表） 3、单链表中插入一个元素 4、在单链表中删除一个元素 5、按序号查找一个元素
链表的初始化、取值、查找、插入、删除
m0_68002095的博客
03-13 3914
以上代码中，定义了一个`ListNode`结构体，其中`val`表示节点的值，`next`表示指向下一个节点的指针。在`getVal`函数中，使用循环遍历链表中的节点，如果找到了第`i`个节点，则返回其值。以上代码中，定义了一个`ListNode`结构体，其中`val`表示节点的值，`next`表示指向下一个节点的指针。以上代码中，定义了一个`ListNode`结构体，其中`val`表示节点的值，`next`表示指向下一个节点的指针。缺点是访问节点的时间复杂度为 O(n)，其中 n 表示链表的长度。
用C语言完成定义结点类型，创建链表，遍历链表，链表排序，借点查找，插入结点，删除结点等操作的程序
05-30
好的，我会根据您的要求回答问题，以下是用C语言完成定义结点类型，创建链表，遍历链表，链表排序，借点查找，插入结点，删除结点等操作的程序： ```c #include <stdio.h> #include <stdlib.h> //定义链表结点类型 typedef struct node { int data; //数据域 struct node *next; //指向下一个结点的指针 } Node; //创建链表 Node *createList(int n) { Node *head = NULL; //链表头指针 Node *tail = NULL; //链表尾指针 int i = 0; for (i = 0; i < n; i++) { Node *p = (Node *)malloc(sizeof(Node)); //创建新结点 printf("请输入第 %d 个结点的数据：", i + 1); scanf("%d", &(p->data)); p->next = NULL; if (head == NULL) { //如果链表为空，新结点就是头结点 head = p; tail = p; } else { //否则将新结点插入到链表末尾 tail->next = p; tail = p; } } return head; } //遍历链表 void traverseList(Node *head) { Node *p = head; printf("链表的数据为："); while (p != NULL) { printf("%d ", p->data); p = p->next; } printf("\n"); } //链表排序 void sortList(Node *head) { Node *p = head; Node *q = NULL; int tmp = 0; while (p != NULL) { q = p->next; while (q != NULL) { if (p->data > q->data) { tmp = p->data; p->data = q->data; q->data = tmp; } q = q->next; } p = p->next; } } //结点查找 Node *findNode(Node *head, int data) { Node *p = head; while (p != NULL && p->data != data) { p = p->next; } return p; } //插入结点 void insertNode(Node *head, int pos, int data) { Node *p = head; int i = 0; while (p != NULL && i < pos - 1) { p = p->next; i++; } if (p == NULL || i > pos - 1) { printf("插入位置非法\n"); return; } Node *q = (Node *)malloc(sizeof(Node)); q->data = data; q->next = p->next; p->next = q; } //删除结点 void deleteNode(Node *head, int data) { Node *p = head; Node *q = NULL; while (p != NULL && p->data != data) { q = p; p = p->next; } if (p == NULL) { printf("要删除的结点不存在\n"); return; } if (q == NULL) { //要删除的结点是头结点 head = p->next; } else { q->next = p->next; } free(p); } int main() { int n = 0; //链表长度 printf("请输入链表长度："); scanf("%d", &n); Node *head = createList(n); //创建链表 traverseList(head); //遍历链表 sortList(head); //链表排序 traverseList(head); //遍历链表 int data = 0; //要查找的结点的数据 printf("请输入要查找的结点的数据："); scanf("%d", &data); Node *p = findNode(head, data); //查找结点 if (p == NULL) { printf("未找到要查找的结点\n"); } else { printf("要查找的结点的数据为：%d\n", p->data); } int pos = 0; //要插入的位置 printf("请输入要插入的位置："); scanf("%d", &pos); printf("请输入要插入的数据："); scanf("%d", &data); insertNode(head, pos, data); //插入结点 traverseList(head); //遍历链表 printf("请输入要删除的结点的数据："); scanf("%d", &data); deleteNode(head, data); //删除结点 traverseList(head); //遍历链表 return 0; } ``` 以上是一个简单的链表操作的程序，可以实现定义结点类型，创建链表，遍历链表，链表排序，借点查找，插入结点，删除结点等操作。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值