带头节点的单向不循环链表

最新推荐文章于 2023-05-16 09:51:56 发布
最新推荐文章于 2023-05-16 09:51:56 发布
阅读量236 收藏
点赞数
分类专栏： 算法与数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41572450/article/details/101639424
版权 
//filename:single_list.h
#ifndef _SINGLE_LIST__H
#define _SINGLE_LIST__H
#include "stdio.h"
#include "stdlib.h"
//带头节点单向不循环链表

typedef int datatype;

typedef struct slist{
	datatype dat;
	struct slist* next;
}s_node;
//不论是向第i个节点插入还是删除，都要在第(i-1)个节点上进行操作

//思路：malloc一个节点作为头节点,头节点的next指向null
s_node* slist_create(void);//创建一个单向带头节点不循环链表

//思路：定义一个指针p，从头节点开始遍历，遍历条件是p非空且跳过节点数小于i，则遍历结束时p为空或者p是第(i-1)个节点，此时插入新节点
int slist_insert_at(s_node* list,int i,datatype* dat);//向第i个节点插入dat

//思路：定义一个指针p，从头节点开始遍历，遍历条件是p非空且跳过节点数小于i，则遍历结束时p为空或者p是第(i-1)个节点，先保存(i+1)节点，再删除i节点
int slist_delete_at(s_node* list,int i,datatype* dat);//删除第i个节点,i从0开始

//思路：定义一个指针p，从头节点开始遍历，遍历条件是p->next非空且p->dat小于dat，则遍历结束时p为空或p->dat大于dat的节点，此时插入新节点
int slist_insert_order(s_node* list,datatype* dat);//按照dat大小顺序插入

//思路：定义一个指针p，从头节点开始遍历，直到p->next为空则结束遍历，插入新节点
int slist_insert_tail(s_node* list,datatype* dat);//向尾部插入

//思路：直接向头节点后面插入
int slist_insert_first(s_node* list,datatype* dat);//向首部插入

//思路：定义一个指针p_prev，从头节点开始遍历，直到p->next为空则结束遍历,p_prev是记录p->next为空的上一个节点，释放p，p_prev->next=null
int slist_delete_tail(s_node* list,datatype* out_dat);//删除尾部节点,注意头节点不会被删除

//思路：删除头节点后面的节点
int slist_delete_first(s_node* list,datatype*out_dat);//删除第0个节点

//思路：定义一个指针p，从头节点开始遍历，遍历条件是p->next非空且p->dat等于dat，则遍历结束时p为空或p->dat等于dat的节点，此时删除节点
int slist_delete(s_node* list,datatype* dat);//删除dat节点

//思路：定义一个指针p，从头节点开始遍历，num累计，遍历条件是p->next非空且p->dat等于dat，则遍历结束时p为空或p->dat等于dat的节点，此时返回num
int slist_find(s_node* list,datatype* dat);//find dat节点号

//思路：头节点的next为null则链表为空
int slist_isempty(s_node* list);//判断链表是否为空

//思路：根据节点的next遍历
void slist_show(s_node* list);//遍历显示node

//思路：根据节点的next遍历释放节点，注意释放前要保存下一个节点
void slist_destroy(s_node* list);//销毁链表

#endif

//filename:single_list.c
#include "single_list.h"


s_node* slist_create(void)
{
	s_node* plist = NULL;
	plist = malloc(sizeof(s_node));
	if(plist == NULL)
		return NULL;
	plist->next = NULL;
	return plist;
}//创建一个单向带头节点不循环链表

int slist_insert_at(s_node* list,int i,datatype* dat)
{
	if(i<0) return -1;
	
	s_node* p = list;//这里不能为list->next,否则开始时第0个插不进
	int j=0;
	while(p!= NULL && j<i)
	{
		//printf("debug %p\n",p->next);
		p=p->next;
		j++;
	}
	
	if(p==NULL) return -2;//例如只有5个节点，但是i大于5
	else   //p is (i-1) node
	{
		s_node* insert_node = slist_create();
		if(insert_node == NULL) return -3;
		
		insert_node->dat = *dat;//data
		insert_node->next = p->next;
		p->next = insert_node;
	}
	return 0;
	
}//向第i个节点插入dat

int slist_delete_at(s_node* list,int i,datatype* out_dat)
{
		if(i<0) return -1;
		s_node*p = list;
		int j=0;
		while(p!=NULL && j<i)
		{
			p=p->next;
			j++;
		}
		if(p==NULL) return -2;
		else //p is (i-1) node
		{
			s_node* del_node;
			del_node = p->next;
			if(out_dat!= NULL) *out_dat = del_node->dat;
			p->next = del_node->next;
			free(del_node);del_node=NULL;
		}
	return 0;
}//删除第i个节点,i从0开始


int slist_insert_order(s_node* list,datatype* dat)
{
		s_node * p=list;
		s_node* insert_node;
			
		while(p->next!=NULL)
		{
			if(p->next->dat > *dat)break;
			p=p->next;
		}
		
		insert_node = slist_create();
		if(insert_node == NULL) return -1;
		insert_node->dat = *dat;
		insert_node->next = p->next;
		p->next = insert_node;
		
		return 0;
}//按照dat大小顺序插入,从小到大顺序

int slist_insert_tail(s_node* list,datatype* dat)
{
	s_node *p=list;
	s_node *insert_node;
	while(p->next != NULL)
	{
			p=p->next;
	}
	
	insert_node = slist_create();
	if(insert_node == NULL) return -1;
	insert_node->dat = *dat;
	insert_node->next=p->next;
	p->next=insert_node;
	return 0;
}//向尾部插入

int slist_insert_first(s_node* list,datatype* dat)
{
	s_node *p=list;
	s_node *insert_node;
	
	insert_node = slist_create();
	if(insert_node == NULL) return -1;
	insert_node->dat = *dat;
	insert_node->next=p->next;
	p->next=insert_node;	
}//向首部插入

int slist_delete_tail(s_node* list,datatype* out_dat)
{
	s_node *p=list;
	s_node *p_prev;
	
	if(slist_isempty(p)==1) return -1;
	
	p_prev=p;
	while(p->next != NULL)
	{
		p_prev=p;
		p=p->next;
	}
	//p->next==NULL
	if(out_dat!=NULL) *out_dat = p->dat;
	free(p);
	p_prev->next=NULL;
	return 0;
}//删除尾部节点,注意头节点不会被删除

int slist_delete_first(s_node* list,datatype*out_dat)
{
	s_node*p=list;
	s_node *p_next;
	if(slist_isempty(p)==1) return -1;
	p_next = p->next->next;
	if(out_dat!=NULL) *out_dat = p->next->dat;
	free(p->next);
	p->next = p_next;
	return 0;
}//删除第0个节点

int slist_delete(s_node* list,datatype* dat)
{
	if(dat == NULL) return -1;
	
	s_node*p=list;
	s_node*p_next;
	while(p->next !=NULL)
	{
		if(p->next->dat == *dat) break;
		p=p->next;
	}		
	if(p->next == NULL) return -2;
	//p is *dat prev node
	p_next=p->next;
	p->next=p_next->next;
	free(p_next);
	return 0;
}//删除dat节点

int slist_find(s_node* list,datatype* dat)
{
	if(dat == NULL) return -1;
	int num=0;
	s_node*p=list;
	s_node*p_next;
	while(p->next !=NULL)
	{
		if(p->next->dat == *dat) break;
		num++;
		p=p->next;
	}		
	if(p->next == NULL) return -2;
	return num;
	
}//find dat节点号

int slist_isempty(s_node* list)
{
	if(list->next==NULL)return 1;
	return 0;
}//判断链表是否为空

void slist_show(s_node* list)
{
	if(slist_isempty(list)==1) return;
	s_node* p = list->next;
	for(;p!=NULL;p=p->next)
	{
		printf("%d ",p->dat);
	}
	printf("\n");
}//遍历显示node

void slist_destroy(s_node* list)
{
	s_node * p;
	s_node * p_next;
	for(p=list->next;p!=NULL;p=p_next)
	{
		p_next=p->next;
		//printf("free %d\n",p->dat);
		free(p);p=NULL;
	}
	free(list);list=NULL;//free head
}//销毁链表


//filename:main.c
#include "single_list.h"
datatype arr[10]={12,34,56,23,56,1,34,24,90,76};
datatype arr1[10]={24,34,6,23,6,1,100,51,90,0};
int main(int argc ,char*argv[])
{
	//-----------------------------------
	printf("特定位置插入、删除\r\n");
	s_node* L= slist_create();
	if(L==NULL) goto exit;
	int i,ret;
	for(i=0;i<sizeof(arr)/sizeof(arr[0]);i++)
	{
		if((ret = slist_insert_at(L,i,&arr[i]))!=0)
		{
			printf("err:%d\n",ret);
			goto exit;
		}
	}
	slist_show(L);
	datatype dat;
	slist_delete_at(L,0,&dat);
	printf("del: %d\n",dat);
	slist_delete_at(L,3,&dat);
	printf("del: %d\n",dat);
	slist_delete_at(L,7,&dat);
	printf("del: %d\n",dat);	
	slist_show(L);
	slist_destroy(L);
	printf("\r\n");
	//-----------------------------------
	printf("按顺序插入\r\n");
	s_node* L1= slist_create();
	if(L1==NULL) goto exit;
	for(i=0;i<(sizeof(arr1)/sizeof(arr1[0]));i++)
	{
		if((ret = slist_insert_order(L1,&arr1[i]))!=0)
		{
			printf("err:%d\n",ret);
			goto exit;
		}
	}
	slist_show(L1);
	printf("\r\n");
	
	dat = 15;
	printf("尾部插入 %d \r\n",dat);
	slist_insert_tail(L1,&dat);//尾部插入
	slist_show(L1);
	printf("\r\n");
	
	dat = 33;
	printf("首部插入 %d \r\n",dat);
	slist_insert_first(L1,&dat);//0节点插入
	slist_show(L1);
	printf("\r\n");
	
	slist_delete_tail(L1,&dat);//尾部删除
	printf("尾部删除 %d \r\n",dat);
	slist_show(L1);
	printf("\r\n");
	
	slist_delete_first(L1,&dat);//0节点删除
	printf("首部删除 %d \r\n",dat);
	slist_show(L1);
	printf("\r\n");
	
	dat = 0;
	printf("删除%d \r\n",dat);
	slist_delete(L1,&dat);
	slist_show(L1);
	printf("\r\n");

	
	dat = 6;
	printf("删除%d \r\n",dat);
	slist_delete(L1,&dat);
	slist_show(L1);
	printf("\r\n");	

	dat = 100;
	printf("删除%d \r\n",dat);
	slist_delete(L1,&dat);
	slist_show(L1);
	printf("\r\n");	

	dat = 200;
	printf("删除%d \r\n",dat);
	slist_delete(L1,&dat);
	slist_show(L1);
	printf("\r\n");		
	
	int num;
	dat = 200;num=-1;
	if((num = slist_find(L1,&dat))>=0)
		printf("发现%d节点编号%d\r\n",dat,num);
	else
		printf("%d节点不在链表中\r\n",dat);
	slist_show(L1);
	printf("\r\n");	

	dat = 1;num=-1;
	if((num = slist_find(L1,&dat))>=0)
		printf("发现%d节点编号%d\r\n",dat,num);
	else
		printf("%d节点不在链表中\r\n",dat);
	slist_show(L1);
	printf("\r\n");	
	
	dat = 6;num=-1;
	if((num = slist_find(L1,&dat))>=0)
		printf("发现%d节点编号%d\r\n",dat,num);
	else
		printf("%d节点不在链表中\r\n",dat);
	slist_show(L1);
	printf("\r\n");	
	
	dat = 90;num=-1;
	if((num = slist_find(L1,&dat))>=0)
		printf("发现%d节点编号%d\r\n",dat,num);
	else
		printf("%d节点不在链表中\r\n",dat);
	slist_show(L1);
	printf("\r\n");	
	
	slist_destroy(L1);
	
exit:
	return 0;
}

在这里插入图片描述
在这里插入图片描述

jiang_2018
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
不带头结点的单循环链表
weixin_43854256的博客
05-19 2285
创建头文件nlist.h #pragma once //不带头节点的链表,主要应用在循环链表中,其缺点,操作复杂(会出现二级指针), //优点:灵活(头指针指向哪个节点哪个节点就是第一个节点) //不带头节点的单链循环链表,尾节点的next指向第一个节点 typedef struct NNode { int data;//数据 struct NNode *next;//下一个节点的地址 }NNode,*PNList; //初始化函数,将头指针置NULL,会出现二级指针 void InitList(P
不带头节点的单链表
qq_41885826的博客
10-03 539
不带头结点的单链表：       1.不带头结点的单链表操作中，除了初始化，头插，尾插，删除，操作与带头结点的单链表有差别外，其它的操作基本上一样。      2.链表指针直接指向了首元节点，因此在首元节点前插入数据元素或者删除首元节点元素都会改变头指针的值。所以这里要引入二级指针。 # include&lt;stdio.h&gt; # include&lt;stdlib.h&gt; #i...
数据结构——单链表(不带头节点)
Jambo!的博客
04-01 2860
单链表
数据结构之不带头结点的单链表
热门推荐
qq_43411563的博客
04-20 1万+
我们都知道不管是单链表、双向链表还是循环链表，都带有头结点，这个头结点相当于一个起始的位置。我们在设计带头结点的单链表的时候，我们会在主函数中设计一个头结点，并把它的指针域置为空，这样我们就可以进行增删查改这些操作了。那我们今天这篇博客就来说一下不带头结点的单链表。 一、不带头结点的单链表的定义 我们先来回忆一下带头结点的单链表是什么样子。如下图所示：红色的区域就是头结点，它有一个头指针指向它。 ...
单循环链表（不带表头）的C语言实现（详细）
qq_983030560的博客
12-19 1694
单循环链表（不带表头）的C语言实现，非常详细
【数据结构】-学习链表所需要的预备知识
m0_74044018的博客
05-16 1779
本文主要讲解链表的必备基础知识和常见问题的解释
C/C++经典约瑟夫环问题——带头结点的单向循环链表
03-24
本程序以C/C++语言实现，利用带头结点的单向循环链表来解决这个问题。这里我们将深入探讨相关知识点。 首先，**带头结点的单向循环链表**是链表的一种特殊形式。与普通的单向链表不同，它在第一个元素（头结点）...
C语言实现带头结点的单向链表的基本操作
04-04
本文详细介绍了使用C语言实现带头结点的单向链表的基本操作，包括链表的创建、输出、插入元素和删除元素，以及单向链表的逆序连接和两个有序线性表的归并。 一、链表的创建 链表的创建是指在内存中分配一个结点，...
单向链表 代码架构
12-29
单向链表是一种基本的数据结构，它在计算机科学和编程中有着广泛的应用。与数组不同，链表中的元素不是在内存中连续存储的，而是通过指针或引用连接在一起，形成一个逻辑上的线性序列。单向链表的每个节点包含两部分...
单向链表逆转单向链表逆转单向链表逆转
07-10
单向链表是一种特殊的链表，每个结点只有一个指针，指向下一个结点。单向链表逆转是指将链表的结点顺序颠倒的过程。 链表的实现 在C++中，链表可以通过结构体（struct）来实现。结构体 Node 代表链表的一个结点，它...
数据结构-基本算法-不带头结点的循环链表
05-21
数据结构-基本算法-不带头结点的循环链表(学生时代源码，调试可运行)
单循环链表（带头结点和不带头结点）
05-21
自己在实验课是做的。主要是单循环链表，有带头结点和不带头结点两种情况。 文件里分别进行了实现。有两个文件
带头结点和不带头结点的循环链表
11-24
这学期学数据结构，写了带头结点和不带头结点的循环链表，供其他在校学生参考学习，体会在链表中带头结点和不带头结点的差别
数据结构顺序表和链表（超详细）
最新发布
08-14
此压缩包为1、无头+单向+非循环链表增删查改实现// 动态申请一个结点// 单链表打印// 单链表尾插// 单链表的头插// 单链表的尾删// 单链表头删// 单链表查找// 单链表在pos位置之后插入x// 单链表删除pos位置之后的...
不带头结点循环单链表
qq_44313416的博客
03-26 294
王道2024考研数据结构；不带头结点循环单链表
【数据结构与算法】 - (不带头结点)单链表详细实现思路及代码(C/C++语言)
wkd_007的博客
03-26 5668
文章先介绍 “头结点” 在链表的作用，以及 “有头结点” 和 “无头结点” 的区别，然后再详细介绍了“无头结点链表” 的实现步骤，最后给出了 “无头结点单链表” 的C语言实现代码，同时也给出了 “有头结点单链表” 的C语言实现代码。读者可以对比这两份代码，将会对单链表的“头结点”有非常深刻的理解。
不带头结点的单向链表实现
a331683772的博客
04-27 1429
一. 什么是链表，链表的分类？ 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针连接次序实现的。 分类： 2. 熟悉链表带头结点和不带头结点的区别？ (后面解释) 3. 完成单链表的以下基本操作： ...
线性表学习归纳总结五：不带头结点的循环链表
蜗牛漫步。。。我要一步一步往上爬。。。
06-10 2127
循环链表与单链表的区别在于，最后一个结点的指针域。 不带头结点循环链表最后一个结点的指针域指向链表的第一个结点，带头结点的话，最后一个结点的指针域指向头结点。 而单链表中，最后一个结点的指针域为null。 基本运算中的区别在于：链表扫描时候的终点条件；以及在插入和删除操作时候， 需要注意是否需要修改最后一个结点的指针域。 获得循环链表的最后一个结点的存储地址 n
创建一个不带头结点的循环单链表并进行相关操作
yuki_1209的博客
09-14 5194
关于循环单链表的创建，以及一些基本操作
不带头结点的单向循环链表怎么建立
06-03
不带头结点的单向循环链表可以通过以下步骤进行建立： 1. 定义链表节点结构体，包含数据域和指向下一个节点的指针； 2. 定义一个指向链表首节点的指针，初始值为NULL； 3. 读入第一个节点的数据，创建一个节点，将其作为链表首节点，指向自身，将其指针赋值给链表首指针； 4. 读入下一个节点的数据，创建一个节点，将其插入到链表的尾部，即将链表尾节点的指针指向新节点，新节点的指针指向首节点，完成插入操作； 5. 重复执行步骤4，直到读取完所有节点的数据。 具体实现可以参考以下代码： ```c typedef struct Node { int data; // 数据域 struct Node *next; // 指向下一个节点的指针 } Node; int main() { Node *head = NULL; // 链表首指针初始化为NULL Node *tail = NULL; // 链表尾指针初始化为NULL int n; // 节点个数 int data; // 数据 scanf("%d", &n); // 读入节点个数 for (int i = 0; i < n; i++) { scanf("%d", &data); // 读入节点数据 Node *node = (Node*)malloc(sizeof(Node)); // 创建新节点 node->data = data; // 赋值数据域 node->next = NULL; // 新节点的next指针初始化为NULL if (head == NULL) { // 如果链表为空，将新节点作为首节点 head = node; node->next = head; // 新节点的next指针指向自身 tail = head; // 将尾指针指向首节点 } else { // 如果链表不为空，将新节点插入到尾部 node->next = head; // 新节点的next指针指向首节点 tail->next = node; // 将尾节点的next指针指向新节点 tail = node; // 将尾指针指向新节点 } } return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值