判断链表是否为空、求链表长度、插入新节点、删除节点、链表排序

最新推荐文章于 2023-01-09 15:16:56 发布
最新推荐文章于 2023-01-09 15:16:56 发布
阅读量1.4k 收藏 4
点赞数
分类专栏： 数据结构 文章标签： 链表 源代码 malloc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fly_lhw/article/details/21764597
版权



学英语就选新概念英语：https://item.taobao.com/item.htm?spm=686.1000925.0.0.znXWxu&id=534934477732


一、判断链表是否为空

就是判断头结点的pNext是否指向空节点。

<span style="font-size:24px;">//start
bool is_empty(PNODE pHead)
{
	if (pHead->pNext == NULL)
	{
		return true;
	}
	else
	{
		return false;
	}	

}
//end</span>


二、求链表长度



<span style="font-size:24px;">//start
int length_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	int len = 0;

	while (p != NULL)
	{
		++len;
		p = p->pNext;
	}

	return len;
}
//end</span>


三、链表排序

第一层循环用来定位当前比较的位置；

第二层循环表示当前第一层循环的位置之后的剩余位置每次与当前第一层循环的位置进行比较；

结果：是把链表当中的定位位置之后的最小值放到当前位置。


<span style="font-size:24px;">//start
void sort_list(PNODE pHead)
{
	int i, j, t;
	PNODE p, q;
	int len = length_list(pHead);

	for (i = 0, p = pHead->pNext; i < len -1; ++i, p = p->pNext)
	{
		for (j = i + 1, q = p->pNext; j < len; ++j, q = q->pNext)
		{
			if (p->data > q->data)
			{
				t = p->data;
				p->data = q->data;
				q->data = t;
			}
		}
	}

	return;
}
//end</span>


四、插入一个新节点

1.     在while循环里面把p节点的位置定位在要插入新节点位置的前一个位置（p = p->pNext）;

2.     创建新节点pNew用来存储val的值；

3.     q = p->pNext:记录要插入新节点位置之前的节点；

4.     p->pNext = pNew:插入新的节点；

5.     pNew->pNext = q:把旧节点链接到新节点之后；

<span style="font-size:24px;">//start
bool insert_list(PNODE pHead, int pos, int val)
{
	int i = 0;
	PNODE p = pHead;
	PNODE pNew = NULL;
	PNODE q = NULL;

	while (p != NULL && i < pos -1)
	{
		p = p->pNext;
		++i;
	}

	if (i > pos -1 || NULL == p)
	{
		return false;
	}

	pNew = (PNODE)malloc(sizeof(NODE));
	if (pNew == NULL)
	{
		printf("Dynamic memory allocation failure");
		exit(-1);
	}
	pNew->data = val;

	q = p->pNext;
	p->pNext = pNew;
	pNew->pNext = q;

	return true;
}
//end</span>



五、删除一个节点


1.     在while循环里面把p节点的位置定位在要删除节点位置的前一个位置（p = p->pNext）;

2.     q = p->pNext:找到要删除的节点；

3.     p->pNext = p->pNext->pNext:删除q节点；

4.     free(q)释放应该删除的节点；

5.     q = NULL；



<span style="font-size:24px;">//start
bool delete_list(PNODE pHead, int pos, int *pVal)
{
	int i = 0;
	PNODE p = pHead;
	PNODE pNew = NULL;
	PNODE q = NULL;

	while (p->pNext != NULL && i < pos -1)
	{
		p = p->pNext;
		++i;
	}

	if (i > pos -1 || p->pNext == NULL)
	{
		return false;
	}

	q = p->pNext;
	*pVal = q->data;

	p->pNext = p->pNext->pNext;
	free(q);
	q = NULL;

	return true;
}
//end</span>


源代码如下： 

<span style="font-size:24px;">#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <stdbool.h>


typedef struct Node
{
	int data;
	struct Node *pNext;
}NODE, *PNODE;


static PNODE create_list(void);
static void traverse_list(PNODE pHead);

bool is_empty(PNODE pHead);
int length_list(PNODE pHead);
bool insert_list(PNODE, int, int);
bool delete_list(PNODE, int, int * );
void sort_list(PNODE);



int main(void)
{
	int len = 0;
	int val;
	PNODE pHead = NULL; //<=>struct Node *pHead = NULL
	pHead = create_list();
	traverse_list(pHead);

	printf("/**********Find the length of the list*********/\n");
	len = length_list(pHead);
	printf("The length of the list is the %d\n", len);
	printf("\n");
	printf("\n");
	printf("\n");




	printf("/**********Insert a node***********************/\n");
	insert_list(pHead, 3, 102);
	traverse_list(pHead);
	printf("\n");
	printf("\n");
	printf("\n");

	printf("/**********To sort the list********************/\n");
	sort_list(pHead);
	traverse_list(pHead);
	printf("\n");
	printf("\n");
	printf("\n");

	printf("/**********To delete a node********************/\n");
	if (delete_list(pHead, 3, &val))
	{
		printf("Successfully deleted, you delete the elements is: %d\n", val);
	}
	else
	{
		printf("Delete failed, you remove the element does not exist!\n");
	}
	traverse_list(pHead);
	printf("\n");
	printf("\n");
	printf("\n");

	printf("/****Determine whether the list is empty*******/\n");
	if (is_empty(pHead))
	{
		printf("The List is empty\n");
	}
	else
	{
		printf("The list is not empty\n");
	}
	printf("\n");
	printf("\n");
	printf("\n");
	return 0;
}

PNODE create_list(void)
{
	int i;
	int len;
	int val;

	PNODE pHead = NULL;
	PNODE pTail = NULL;
	PNODE pNew = NULL;

	pHead = malloc(sizeof(NODE));
	if (pHead == NULL)
	{
		printf("Allocation failure, Program termination");
		exit(-1);
	}

	pTail = pHead;
	pTail->pNext = NULL;

	printf("Please enter a number of linked list nodes that you want to build: len = ");
	scanf("%d", &len);
	
	for (i = 0; i < len; i++)
	{
		printf("Please enter the %d node value = ", i+1);
		scanf("%d", &val);
        
		pNew = malloc(sizeof(NODE));
		if (pNew == NULL)
		{
			printf("Allocation failure, Program termination!");
			exit(-1);
		}
		pNew->data = val;
		pTail->pNext = pNew;
		pNew->pNext = NULL;
		pTail = pNew;
	}

	return pHead;
}

void traverse_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->pNext;
	}

	printf("\n");
	return;
}


bool is_empty(PNODE pHead)
{
	if (pHead->pNext == NULL)
	{
		return true;
	}
	else
	{
		return false;
	}	

}


int length_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	int len = 0;

	while (p != NULL)
	{
		++len;
		p = p->pNext;
	}

	return len;
}


void sort_list(PNODE pHead)
{
	int i, j, t;
	PNODE p, q;
	int len = length_list(pHead);

	for (i = 0, p = pHead->pNext; i < len -1; ++i, p = p->pNext)
	{
		for (j = i + 1, q = p->pNext; j < len; ++j, q = q->pNext)
		{
			if (p->data > q->data)
			{
				t = p->data;
				p->data = q->data;
				q->data = t;
			}
		}
	}

	return;
}


bool insert_list(PNODE pHead, int pos, int val)
{
	int i = 0;
	PNODE p = pHead;
	PNODE pNew = NULL;
	PNODE q = NULL;

	while (p != NULL && i < pos -1)
	{
		p = p->pNext;
		++i;
	}

	if (i > pos -1 || NULL == p)
	{
		return false;
	}

	pNew = (PNODE)malloc(sizeof(NODE));
	if (pNew == NULL)
	{
		printf("Dynamic memory allocation failure");
		exit(-1);
	}
	pNew->data = val;

	q = p->pNext;
	p->pNext = pNew;
	pNew->pNext = q;

	return true;
}


bool delete_list(PNODE pHead, int pos, int *pVal)
{
	int i = 0;
	PNODE p = pHead;
	PNODE pNew = NULL;
	PNODE q = NULL;

	while (p->pNext != NULL && i < pos -1)
	{
		p = p->pNext;
		++i;
	}

	if (i > pos -1 || p->pNext == NULL)
	{
		return false;
	}

	q = p->pNext;
	*pVal = q->data;

	p->pNext = p->pNext->pNext;
	free(q);
	q = NULL;

	return true;
}</span>


运行结果如下：


[root@localhost struct_list]# ./list1
Please enter a number of linked list nodes that you want to build: len = 5
Please enter the 1 node value = 11
Please enter the 2 node value = 23
Please enter the 3 node value = 31
Please enter the 4 node value = 5
Please enter the 5 node value = 24
11 23 31 5 24 
/**********Find the length of the list*********/
The length of the list is the 5

/**********Insert a node***********************/
11 23 102 31 5 24 

/**********To sort the list********************/
5 11 23 24 31 102 

/**********To delete a node********************/
Successfully deleted, you delete the elements is: 23
5 11 24 31 102 

/****Determine whether the list is empty*******/
The list is not empty





fly_lhw
关注
专栏目录
PHP实现双链表删除与插入节点的方法示例
10-19
在`insertLink`方法中，我们创建一个新的节点`$p`，然后遍历链表找到合适的位置插入新节点。如果新节点的数据小于当前节点的数据，则将新节点插入到当前节点之前。当找到正确位置时，更新前后节点的链接。 ```php ...
各类链表判空条件
abcdeasdfas的博客
01-02 1万+
——> 转自原博客 1.单链表 带头结点： 分析： 带有头节点的链表若为空，只需要整条链表只剩一个头节点 [这是和不带头节点的链表的一个很大的区别（不带头结点的链表若要为空，整个链表不能存在一个结点）]， 怎样使带头节点的链表只剩一个头节点呢？ 只需要第一个存储数据的节点不存在即可，即头节点的后继结点不存在即可 所以只需要头节点的next指针域不存在即可（实质上使指向NULL） 所以 带头点的单链表的判空条件为 head->next=NULL 不带头结点： 分析： 若要不带头结点的链表为空，
Node head = null与Node head = new Node(null, null)的区别
qq_38708372的博客
04-05 1197
head = null： 只定义了head的变量，但是没有变量声明和变量实例化，实际上head = null是这个结点是不存在的 Node head = new Node(null, null)： 完成了变量的定义、声明、实例化，只是head 这个Node的val & next 都是null ...
判断链表为空的三种情况
W8Z8M的博客
07-05 9776
（1）带头结点单链表：head->next==NULL; （2）带头结点循环链表：head->next==head; （3）不带头结点单链表：head==NULL;
链表的特点，单链表的定义、存储结构，单链表的基本操作（判断链表是否为空、销毁链表、清空链表、求链表表长、查找、插入、删除，建立单链表）
weixin_72728720的博客
01-09 2465
单链表是由表头唯一确定，因此单链表可以用头指针的名字来命名，若头指针名是L，则把链表称为表L。
如何判断一个链表是否为空？
Cookie1997的小屋
05-07 2万+
L为指向表头结点的指针，分别写出带有头结点的单链表、单项循环链表和双向循环链表判空的条件单链表 NULL==L-&gt;next单向循环 L==L-&gt;next双向循环 L==L-&gt;next&amp;&amp;L==L-&gt;prior...
yuandaima.zip_插入排序_链表插入排序
09-20
首先，我们创建一个空的已排序链表，然后遍历原链表，取出每个节点，找到它在已排序链表中的合适位置，并插入。这个过程需要保持链表的连接性，确保每个新插入的节点正确地指向其前后节点。链表插入排序的时间复杂度...
JavaScript实现链表插入排序和链表归并排序
10-21
链表插入排序在链表长度较小或链表基本有序的情况下效率较高，但其平均时间复杂度为O(n^2)，因此不适用于大数据量的链表排序。 ### 链表归并排序 链表归并排序采用分而治之的思想，它将链表递归地分割成更小的部分...
C++删除链表中间节点的方法
08-30
这个函数首先检查链表是否为空或只有一个节点，如果是，则直接返回。接着，如果链表只有两个节点，那么删除第二个节点。然后，通过快慢指针遍历链表，当快指针到达链表末尾时，慢指针位于中间节点。最后，通过更新`...
创建双链表的节点、插入节点到双链表头部、打印双链表和删除所有节点的功能
最新发布
07-09
createNode 函数，用于创建一个新的双链表节点。 insertAtBeginning 函数现在将新节点插入到链表的开头，并正确地更新前驱和后继指针。 printList 函数用于遍历并打印双链表中的数据。 deleteList 函数，用于遍历双...
链表关于链表合并和反转的两类题型
dongdong7_77的博客
11-28 166
第一类 将链表的头部指向尾部，再指向头部的第二个，再由头部的第二个指向尾部的第二个 例子 输入：1，3，5，7，8，9，0 输出：1，0，3，8，5，8，7 这里我的思路是先将将一条表分为两段从中间截断，这时候我们将第二条链表反转，最后将他们有序的合并就可以达成目的 link1* fanzhuan (link1 *p) { link1 *p1,*p2,*tem; p1 =p; p2 =p->next; p1 ->next =NULL; tem =p2 ->next; whi
某带头结点的单链表的头指针为head，则判定该链表为非空的条件是？
qq_44165157的博客
10-22 5243
判定该链表为非空的条件是：head->next！=null。 带头节点的情况下，链表空时还会存在一个节点，所以head不为空，head->next为空 不带头节点的情况下，链表空时，没有任何节点，head指向null。 无论是否有头结点，头指针始终指向链表的第一个结点。如果有头结点，头指针就指向头结点。 头结点的作用是使所有链表的头指针非空，并使对单链表的插入、删除操作不需要区分是否为空表或是否在第一个位置进行，从而与其他位置的插入、删除操作一致。 ...
剑指 Offer 18. 删除链表的节点
ls_wifi的博客
10-04 410
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。 返回删除后的链表的头节点。 注意：此题对比原题有改动 示例 1: 输入: head = [4,5,1,9], val = 5 输出: [4,1,9] 解释: 给定你链表中值为5的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9. 示例 2: 输入: head = [4,5,1,9], val = 1 输出: [4,5,9] 解释: 给定你链表中值为1的第三个节点，那么在调用了...
【数据结构】判断链表是否为空 和 求链表长度
l634007854的博客
09-28 1748
#include <stdio.h> #include <malloc.h> #include <stdlib.h> #include <stdbool.h> typedef struct Node { int data; //数据域 struct Node * pNext; //指针域 }NODE, *PNODE; //NODE等价于struct Node, PNODE等价于struct Node * PNODE create_list(
数据结构判断链表是否为空：
m0_58687013的博客
06-15 1794
数据结构判断链表是否为空
C++中如何判断链表为空
一个半路出家的人
06-26 1万+
链表区分带头节点和不带头结点两种。假定链表节点指向下一节点的指针变量名为next。那么区分情况，判断空链表的方法为： 1 带头节点。 对于带头节点的链表，存在有不变的头结点head，这个节点并不保存任何数据，仅提供链表起始的一个标识。对于此类链表，判断为空的条件为head-&gt;next==NULL。当head的next值为NULL,这时链表为空。 2 不带头结点。 不带头结点的情况，链表的...
单链表为空的判定条件
热门推荐
mxing5694270的博客
06-03 2万+
带头结点的单链表head为空的判定条件是（）。 A.head==NULL B.head->next==NULL C.head->next==head D.head!=NULL 正确答案：B 解析：若单链表带头结点，那么判定它为空的条件是head->next==NULL；若单链表不带头结点，那么判定它为空的条件则是head==NULL。 ...
c语言判断顺序链表是否为空,数据结构之线性表(五)——单链表(2 初始化，判断空表，销毁，清空，求表长)...
weixin_42522131的博客
05-21 4168
1.单链表(带头结点)的初始化即，构造一个空表，如下图， 算法步骤：1.生成新结点作头结点，用头指针L指向头结点。2.将头指针的指针域置空。算法描述：Status InitList_L(LinkList& L){L = new LNode; //在C语言里，为 L=(LinkList)malloc(sizeof(LNode));L->next = NULL;return OK;}...
python3怎么创建一个链表_「C语言」链表的操作——增删改查——让你一次全弄懂
weixin_39825722的博客
11-24 240
1.什么是链表1.1什么是链表链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。----百度百科上面关于链表的定义来源于百度百科，光看定义我想大部分人跟我初次看的时候一样，这讲的是个啥玩...
判断链表链表为空和链表插入的实现结果还有删除结果
10-30
链表为空的判断可以通过判断链表头指针是否为空来实现。链表插入的实现可以分为在链表头插入和在链表中间插入两种情况。在链表头插入时，需要将新节点的next指向原链表头，然后将链表头指向新节点。在链表中间插入时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值