8月24日笔记数据结构（补9）带头节点单向链表

最新推荐文章于 2022-03-23 11:45:48 发布
最新推荐文章于 2022-03-23 11:45:48 发布
阅读量136 收藏
点赞数
分类专栏： 笔记 # 数据结构 文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CW_qian/article/details/119904089
版权

                                                                        链表的介绍都在前面无头节点单向链表的基础上展开

基本构造（特点）

// 定义头节点
struct headNode
{
    struct node *first; // 指向第一个数据节点
    struct node *last; // 指向最后一个数据节点
    int nodeNumber; // 记录链表节点数
};

定义头节点：struct headNode

        只存放头和尾相关指针next，和链表长度

定义数据节点：struct node

创建新链表：struct headNode *create_list()

插入新节点：

        头插：void headAdd(struct node *pnew,struct headNode *head)

        尾插：void tailAdd(struct node *pnew,struct headNode *head)

主函数

        int main()

{          创建链表:
          struct headNode *head = create_list();
    功能：

1.打印链表：void show_list(struct headNode *head)
            show_list(head);

2.在对应的data前面增加newdata节点：struct headNode *add_node(struct headNode *head,dataType newdata,dataType data)
            head = add_node(head,8,3);

3.删除所有对应data数据的节点：struct headNode *del_node(struct headNode *head,dataType data)
            head = del_node(head,3);

4.实现排序功能：struct headNode *sort_list()
            struct headNode *head  = sort_list();
   
    return 0;

}

具体代码：LinkedListWithHead.c

#include <stdio.h>
#include <stdlib.h>

//-----------------------------------
typedef int dataType;
//-----------------------------------

// 定义数据节点
struct node
{
	dataType data; // 数据域
	struct node *next; // 指针域，存放(指向)下一个节点的地址
};
//-----------------------------------

// 定义头节点
struct headNode
{
	struct node *first; // 指向第一个数据节点
	struct node *last; // 指向最后一个数据节点
	int nodeNumber; // 记录链表节点数
};
//---------------------------------
// 尾插
void tailAdd(struct node *pnew,struct headNode *head)
{
	head->last->next=pnew;
	head->last=pnew;
}
//---------------------------------
// 头插
void headAdd(struct node *pnew,struct headNode *head)
{
	pnew->next=head->first;
	head->first=pnew;
}
//---------------------------------
struct headNode *create_list()
{
	// 创建头节点
	struct headNode *head = malloc(sizeof(struct headNode));
	if(head == NULL)
	{
		perror("create headNode failed");
		return NULL;
	}
	head->first = NULL;
	head->last = NULL;
	head->nodeNumber = 0;
	
	dataType data;
	
	while(1)
	{
		scanf("%d",&data);
		if(data == 0)// 链表生成
			break;
		
		// 创建新节点
		struct node *pnew = malloc(sizeof(struct node));
		if(pnew == NULL)
		{
			perror("create newnode failed");
			return NULL;
		}	
		pnew->data = data;
		pnew->next = NULL;
		
		//将新节点插入到链表
		if(head->first == NULL)//从无到有
		{
			head->first = pnew;
			head->last = pnew;
		}
		else // 从少到多
		{
			// 尾插法
			tailAdd(pnew,head);
			
			// 头插法
			//headAdd(pnew,head);
			
		}
		
		// 更新节点数
		head->nodeNumber++;
	}
	
	return head;
}
//------------------------------
// 打印链表节
void show_list(struct headNode *head)
{
	for(struct node *p = head->first;p != NULL;p = p->next)
	{
		printf("%d  ",p->data);
	}
	printf("\n");
	printf("此链表的节点数据数为%d个\n",head->nodeNumber);
}
//------------------------------
struct headNode *add_node(struct headNode *head,dataType newdata,dataType data)
{
	// 创建新节点
	struct node *pnew = malloc(sizeof(struct node));
	if(pnew == NULL)
	{
		perror("create new node failed:");
		return NULL;
	}
	// 初始化新节点
	pnew->data = newdata;
	pnew->next = NULL;
	
	// 定义指针p遍历链表
	struct node *p = head->first;
	// 定义指针pre指向p的前一个节点
	struct node *pre = NULL;
	
	// 开始遍历链表查找对应的节
	while(p)
	{
		// 找到了,停止遍历
		if(p->data == data)
		{
			break;
		}
		else // 继续找
		{
			pre = p;
			p = p->next;
		}
	
	}
	// 找不到节点
	if(p == NULL) //尾插
	{
		tailAdd(pnew,head);
	}
	else
	{
		// 找打的是首节点
		if(p == head->first)
		{
			// 头插法
			headAdd(pnew,head);
		}
		else // 中间插
		{
			pre->next = pnew;
			pnew->next = p;
		}
	}
	// 链表节点加一
	head->nodeNumber++;
	return head;
}

/*
	del_node : 将head指向的链表中删除所有对应的data数据所对应的节点
*/
struct headNode *del_node(struct headNode *head,dataType data)
{
	// 遍历指针
	struct node *p = head->first;
	// 指向p的前一个节点
	struct node *pre = NULL;

	while(p)
	{
		if(p->data == data)// 找到需要删除的节点
		{
			// 链表节点减一
			head->nodeNumber--;
			
			if(p == head->first)// 需要删除的数据为首节点数据
			{
				head->first = head->first->next;
				p->next = NULL; // 断开链表
				free(p); // 释放空间
				p = head->first;//p重新指向新的首节点
			}
			else //删除的数据不是首节点
			{
				pre->next = p->next;
				p->next = NULL; // 断开链表
				free(p); // 释放堆空间
				p = pre->next; 
			}
		}
		else // 没有找到对应的节点，继续往下找
		{
			pre = p;
			p = p->next;
		}
	}
	
	return head;
}

struct headNode *sort_list()
{
	// 创建头节点
	struct headNode *head = malloc(sizeof(struct headNode));
	if(head == NULL)
	{
		perror("create headNode failed");
		return NULL;
	}
	head->first = NULL;
	head->last = NULL;
	head->nodeNumber = 0;
	
	// 用于存放数据的数据
	dataType data;
	// 循环创建节点,将节点插入到链表
	while(1)
	{
		// 输入数据
		scanf("%d",&data);
		// 链表创建完成
		if(data == 0)
			break;
		
		// 创建新节点
		struct node *pnew = malloc(sizeof(struct node));
		if(pnew == NULL)
		{
			perror("create new node failed:");
			return NULL;
		}
		// 初始化新节点里面的数据
		pnew->data = data;
		pnew->next = NULL;
		
		//如果链表为NULL
		if(head->first == NULL)
		{
			head->first = pnew;
			head->last  = pnew;
		}
		else // 链表不为空
		{
			// 定义遍历指针p指向链表的首节点，用于遍历链表
			struct node *p = head->first;
			// 定义一个指针pre指向p的前一个节点
			struct node *pre = NULL;
			while(p)
			{
				// 如果找到对应的节点
				if(p->data > pnew->data)
				{
					break;
				}
				else // 找不到，继续找
				{
					pre = p;
					p = p->next;
				}
			}
			
			// 如果找不到对应的数据
			// 将数据插入到链表的末尾
			if(p == NULL)
			{
				head->last->next = pnew;
				head->last = pnew;
			}
			else // 找到了对应的数据
			{
				// 如果找到的是首节点
				if(p == head->first) // 头插法
				{
					pnew->next = head->first;
					head->first = pnew;
				}
				else// 中间插
				{
					pre->next = pnew;
					pnew->next = p;
				}
			}	
		}
	}
	
	return head;
}



int main()
{
	// 创建新链表
	//struct headNode *head = create_list();
	
	//head = add_node(head,8,3);
	
	//  删除节点
	//head = del_node(head,3);
	
	// 排序
	struct headNode *head  = sort_list();
	
	//打印链表
	show_list(head);
	return 0;
}

扩展功能：

1.冒泡排序：struct headNode *sort_list(struct headNode *head)
            head  = sort_list(head);

/*
    冒泡法实现排序
    交换节点的数值
*/
struct headNode *sort_list(struct headNode *head)
{
    for(int i = 0;i < head->nodeNumber-1;i++)
    {
        struct node *p = head->first;
        
        for(int j = 0;j < head->nodeNumber-i-1;j++)
        {
            if(p->data > p->next->data)
            {
                int tmp;
                tmp = p->data;
                p->data = p->next->data;
                p->next->data = tmp;
            }
            p = p->next;
        }
    }

    return head;
}

2.链表逆序：struct headNode *reverse_list(struct headNode *head)
            reverse_list(head);

/*
    链表实现逆序功能
*/
struct headNode *reverse_list(struct headNode *head)
{
    // 定义指针p指向链表的第一个节点
    struct node *p = head->first;
    // 定义指针pnew用于指向链表的首节点
    struct node *pnew = NULL;
    // 拆头节点
    head->first = NULL;
    head->last = NULL;
    
    // 遍历链表
    while(p)
    {
        // 拆节点
        // 定义pnew指向链表的首节点
        pnew = p;
        // p指向下一个节点
        p = p->next;
        // 将pnew节点从链表中断开
        pnew->next = NULL;
        
        // 将拆下来的节点进行头插法
        // 链表为空
        if(head->first == NULL)
        {
            head->first = pnew;
            head->last = pnew;
        }
        else // 链表不为空,头插法
        {
            headAdd(pnew,head);
        }
        
    }
    
    return head;
}

3.就地排序：struct headNode *sort1_list(struct headNode *head)
            head = sort1_list(head);

/*
    就地排序 ： 编写思想就是 先要拆链表，保证链表不丢失
                再拆节点，然后将拆下来的节点重新布局插入到原来的链表
*/

struct headNode *sort1_list(struct headNode *head)
{
    // 定义指针p用于指向head所指向的首节点，防止等下拆链表头的时候导致链表丢失
    struct node *p = head->first;
    
    // 定义一个指针pnew指向拆下来的节点
    struct node *pnew = NULL;
    
    // 拆链表的头节点
    head->first = NULL; // 断链表头
    head->last = NULL; // 断链表尾 
    
    // 循环拆节点
    while(p)
    {
        // 拆节点
        // 定义一个指针pnew指向拆下来的节点
        pnew = p;
        // p指向下一个节点
        p = p->next;
        // 将pnew所指向的节点与原链表断开
        pnew->next = NULL;
        
        // 重新将节点插入到链表
        // 判断链表是否为空
        if(head->first == NULL) // 没有节点
        {
            head->first = pnew;
            head->last= pnew;
        }
        else // 链表不为空
        {
            // 定义指针p1指向链表的首节点
            struct node *p1 = head->first;
            // 定义pre指针指向p的前驱节点
            struct node *pre = NULL;
            // 循环链表节点与pnew比较
            while(p1)
            {
                // 链表里面的节点大于pnew，那么表示找到了
                if(p1->data > pnew->data)
                {
                    break;
                }
                else // 没找到，继续往下找
                {
                    pre = p1;
                    p1 = p1->next;
                }
            }
            //printf("__%d___\n",__LINE__);
            // 如果p1不为空表示找到了对应的节点
            if(p1 != NULL)
            {
                // 表示新节点要插入到链表的首节点前面
                if(p1 == head->first) // 头插法
                {
                    headAdd(pnew,head);
                }
                else // 中间插入
                {
                    pnew->next = p1;
                    pre->next = pnew;
                }
            }
            else // 找不到对应的节点进行尾插
            {
                tailAdd(pnew,head);
            }
        }
     }
    return head;
}

4.归并两条有序列表排序：struct headNode *merge_two_list(struct headNode *headA,struct headNode *headB)
         创建新链表
            struct headNode *headA = create_list();
            struct headNode *headB = create_list();  

            struct headNode *head  = merge_two_list(headA,headB);

//归并两条有序链表
struct headNode *merge_two_list(struct headNode *headA,struct headNode *headB)
{
	// 定义指针pA和pB指向第一个节点
	struct node *pA = headA->first;
	struct node *pB = headB->first;
	
	// 创建头节点
	struct headNode *head = malloc(sizeof(struct headNode));
	if(head == NULL)
	{
		perror("create head failed : ");
		return NULL;
	}
	// 初始化头节点
	head->first = NULL;
	head->last = NULL;
	head->nodeNumber = headA->nodeNumber + headB->nodeNumber;
	
	// 定义指针pnew指向拆下来的节点
	struct node *pnew = NULL;
	
	// 同时遍历AB两条链表
	while(pA && pB)
	{
		// 如果pA小于pB节点则拆pA节点
		if(pA->data < pB->data)
		{
			pnew = pA;
			// pA指向下一个节点
			pA = pA->next;
			
			// 断开pnew
			pnew->next = NULL;
		}
		else
		{
			pnew = pB;
			// pA指向下一个节点
			pB = pB->next;
			
			// 断开pnew
			pnew->next = NULL;
		}
		
		// 将拆下来的节点依次插入到head链表
		if(head->first == NULL) // 链表为空
		{
			head->first = pnew;
			head->last = pnew;
		}
		else // 链表不为空,节点尾插
		{
			head->last->next = pnew;
			head->last = pnew;
		}
		
	}
	
	// 将A，B链表多余的节点插到head链表后面
	if(pA != NULL)
	{
		head->last->next = pA;
		//更新尾指针
		head->last = headA->last;
	}
	else
	{
		head->last->next = pB;
		//更新尾指针
		head->last = headB->last;
	}
	
	// 释放A，B两条链表
	headA->first = NULL;
	headA->last = NULL;
	free(headA);
	
	headB->first = NULL;
	headB->last = NULL;
	free(headB);
	
	return head;
}

卫橙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-带头节点单向链表
junLe_come_on的博客
09-01 583
链表 链表是以节点的方式来存储，是链式存储 基本结构：data域， nextNode域（指向下一个节点） 链表不是连续存储的 链表分带头节点和没有带头节点 单链表 链表中每个链节点中仅包含一个nextNode域（指针域），这样的链表称为单链表 带头节点的单链表 在链表的第一个节点之前设一个节点，也叫头节点 头节点的引入使得单链表的头指针永远不为空，从而方便了插入、删除等操作 链式存储结构的特点 优点 不需要占用连续存储空间，使用链表前不用事先估计存储空间大小 插入和删除操作时，不需要移动
数据结构笔记：单向链表
12-22
分类目录——数据结构笔记 离散存储，手拉手，每一块有指向下一块的指针（形象描述，python中没有指针），就好像形成了一条链 一个元素包括两部分：value 和 next 链表与顺序表都是线性表 知识点补充 b = 20 a = 'a...
数据结构示例之链表头部插入新节点
WorldMvp的专栏
10-30 6220
以下为“链表头部插入新节点”的简单示例： 1. 用c语言实现的版本为： #include #include typedef char datatype; typedef struct node{ datatype data; struct node *next; } listnode; typedef listnode *linklist; listnode *p; //
[C++]试一试结构体struct node的构造函数
热门推荐
11-09 2万+
完全不懂计算机原理的人举爪
8月25日笔记数据结构（补10）双向链表
CW_qian的博客
08-25 149
链表的介绍都在前面带头节点单向链表的基础上展开 基本构造（特点）： // 定义数据节点 struct node { dataType data; // 数据域 struct node *prev; // 指向上一个节点的地址 struct node *next; // 指针域，存放(指向)下一个节点的地址 }; //----------...
struct node和struct node *类型以及为什么要使用struct node *类型
qq_36950117的博客
09-28 1万+
在链表的学习过程，有的时候搞不清楚为什么只是一个指针而已，为什么要设置成struct node *类型。 昨天又有了一点想法：指针地址的关系，以及指针和指针的不同。 一般我们学的都是类似于int *p或者char *p这种单纯结构的指针。而在进行链表的学习时，我们用的是复合结构的指针。 可以进行这样的类比：一般单结构的指针，就把它看成是一个单层抽屉，这个抽屉里面装的是需要保存的地址，它指向的是和自己一样的结构的抽屉；而复合结构的指针，把它看成是一个双层的抽屉，它其中一层装的是需要保存的地址，另一层也许装的是
8月24日笔记数据结构（补8）无头节点单向链表
CW_qian的博客
08-25 139
为
8月25日笔记数据结构单向循环链表
CW_qian的博客
08-25 159
链表的介绍都在前面双向链表的基础上展开 基本构造（特点）： // 更新节点数 head->nodeNumber++; // 将链表设计为单向循环链表 if(head->nodeNumber != 0) { head-...
【单向链表】数据结构——单向链表的介绍与代码实现&笔记
皮皮不调皮的博客
03-23 776
从今天开始将修炼数据结构专栏，将持续更新，分模块学习。 数据结构——单向链表一、数据结构1、什么是数据结构？2、逻辑结构和物理结构二、链表——线性结构1、首先介绍下链表和数组的区别2、链表节点——节点本身是一个结构体3、单向链表的一般性结构4、单向链表节点的添加——插入节点5、单向链表节点的查找——查找结点6、单向链表删除节点7、单向链表节点的销毁8、最后附上示例代码 一、数据结构 1、什么是数据结构？ 数据结构：计算机存储，组织数据的方式，数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。 .
数据结构与算法:单向链表实现与封装
08-26
今天小编就为大家分享一篇关于数据结构与算法:单向链表实现与封装，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
python数据结构链表之单向链表(实例讲解)
01-21
单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 表元素域elem用来存放具体...
基于数据结构的单向链表排序算法探究.pdf
08-07
#资源达人分享计划#
10月14日笔记交叉开发开发板连接，远程登录和tftp服务器配置
CW_qian的博客
10-15 2338
1.开发板的链接 电源： 网线：不用的时候可以不接 串口：用来开发板通信 你们使用SecureCRT的界面是你们开发板的终端界面 右键此电脑 -》管理-》设备管理器-》端口 看看下有没有名字： USB_SERIALCH340(COMx) COMx就是开发板的串口端口号 x=1,2,3,4,5... SecureCRT链接开发板 1.打开软件 选择快速链接 2.协议 Serial 选择后 界面会发生改变 端...
[笔记]ASCLL码表（48 “0”，65 “A”，97 “a”）2022.3.12
CW_qian的博客
03-22 1715
ASCLL表格 ASCLL码 ASCLL值 对应字符 0 NUT 1 SOH 2 STX 3 ETX 4 EOT 5 ENQ 6 ACK 7 BEL ...
11月17日笔记网络编程1_基础知识
CW_qian的博客
11-17 1531
(1)网络协议层次模型 OSI七层模型 TCP/IP四层模型 (2)网络数据包的发送过程 "封装和拆包" (3)了解一下概念 交换机 路由器 网关 (4) IP地址和mac地址 (5) 端口号 IP地址+传输层协议(TCP/UDP)+端口号
11月17日笔记网络编程3_UDP套接字编程及广播，组播
CW_qian的博客
11-17 1277
1.UDP套接字编程 UDP传输层的一个协议 面向无连接 数据报的传输层协议 无连接 不可靠的一种协议 既然不可靠为什么要用UDP 1.实时应用 2.在网络环境比较好的时候 UDP的效率更高。 可以在应用层保证你的数据可靠 sendto recvfrom 你要知道谁给你发了消息你才好回信 练习： 1.DNS Domain Name syatem域名解析系统 ...
11月17日笔记网络编程2_Socket套接字及TCP\UDP
CW_qian的博客
11-17 904
socket套接字，创建，端口，bind,listen，accept，connect , sendto,recvfrom, close/shutdown
数据结构----单向链表
最新发布
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值