有头结点的链表的功能及实现

已于 2022-06-13 08:29:18 修改
阅读量344 收藏
点赞数
分类专栏： 数据结构学习 文章标签： c语言
于 2022-03-30 09:47:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lzy15192536135/article/details/123837297
版权

有头单向链表：(浪费一个节点保存下一个节点地址)
头节点的数据域无效，指针域有效


无头单向链表：
所有节点的数据域和指针域都是有效的


定义节点结构体：（一个节点保存一个数据元素）

typedef int datatype;
typedef struct node_t   //node是节点的意思
{
	datatype data;		//数据域
	struct node_t *next;  //保存下一个节点的地址
}linklist_t;

遍历有头单向链表

void showHead(linklist_t *p)
{
	while(p->next!=NULL)
	{
		p=p->next;
		//因为头结点数据无效
		//所以先获取到第一个有效节点
		printf("%d ",p->data);
	}
	putchar(10);//换行
}

遍历无单头向链表

void shownoHead(linklist_t *p)
{
	while(p!=NULL)
	{
		printf("%d ",p->data);
		p=p->next;
		//头结点数据有效
		//所以先打印出当前节点的数值再获取到下一个节点
	}
	putchar(10);
}




链表的功能
1.创建一个空的有头单向链表
2.向链表的指定位置插入数据
3.计算链表长度
4.遍历有头单向链表
5.删除制定位置的数据
6.判断链表是否为空
7.查询链表制定位置的数据
8.查询指定数据在链表中的位置
9.修改指定的数据
10.修改指定位置的数据
11.删除指定的数据
12.转置
13.清空
14.销毁




1.创建一个空的有头单向链表

linklist_t *createLinkList(void)
{
	linklist_t *p=(linklist_t *)malloc(sizeof(linklist_t));
	if(NULL == p)//若开辟空间失败
	{
		printf("malloc node err.\n");
		return NULL;
	}
	p->next=NULL;//数据域无效，指针域有效
    return p;
}

2.向链表的指定位置插入数据

int insertPostLinkList(linklist_t *p,int post,datatype data)
{
	linklist_t *pnew=NULL;
	int i;
   //1.容错处理(位置)
   if(post < 0 || post>lengthLinkList(p))
   {
	   printf("insert post err.\n");
	   return -1;
   }
   //2.创建一个新节点保存插入的数据
   pnew=(linklist_t *)malloc(sizeof(linklist_t));
   if(NULL == pnew)
   {
	   printf("malloc new node err.\n ");
	   return -1;
   }
   //初始化节点内容
   pnew->data=data;
   pnew->next=NULL;

   //3.将头指针移动插入位置的前一个位置
    for(i=0;i<post;i++)
	{
		p=p->next;
	}
	//4.插入 ，先连后，再连前
	pnew->next=p->next;
	p->next=pnew;
	return 0;
}

3.计算链表长度

int lengthLinkList(linklist_t *p)
{
	int len=0;
	while(p->next != NULL)
	{
		p=p->next;
		len++;
	}
	return len;
}

4.遍历有头单向链表

void showLinkList(linklist_t *p)
{
	while(p->next != NULL)
	{
		p=p->next;
		printf("%d ",p->data);
	}
	putchar(10);
}

5.删除制定位置的数据

int delectPostLinkList(linklist_t *p,int post)
{
	int i;
	linklist_t *pdel=NULL;
	//1.容错处理
	if(post < 0 || post >= lengthLinkList(p) || isEmptyLinkList(p))
	{
		printf("isEmptyLinkList or post err.\n");
		return -1;
	}
	//2.移动头指针到删除位置的前一个
	for(i=0;i<post;i++)
		p=p->next;
	//3.定义指针保存删除节点地址
	pdel=p->next;
	//4.跨过删除节点
	p->next=pdel->next;
	//5.释放节点
	free(pdel);
	pdel=NULL;
	return 0;
}

6.判断链表是否为空

int isEmptyLinkList(linklist_t *p)
{
	return p->next == NULL; 
	//==作为一个判断条件
	//1空  0非空
}

7.查询链表指定位置的数据

//因为是查询数据，返回值与函数数据类型一致
//所以采用datatype类型
datatype searchPostLinkList(linklist_t *p,int post)
{
	int i;
	//容错处理
	if(post < 0 || post >= lengthLinkList(p))
	{
		printf("post err.\n");
		return -1;
	}
    //将指针移动到指定位置
	for(i=0;i<=post;i++)
		p=p->next;
	return p->data;//返回数据域的数值
}

8.查询指定数据在链表中的位置

int searchDataLinkList(linklist_t *p,datatype data)
{
	int post=0;
	if(isEmptyLinkList(p))
	{
		printf("isEmptyLinkList err.\n");
		return -1;
	}
	while(p->next != NULL)
	{
		p=p->next;
		if(p->data == data)
			return post;
		post++;
		//因为计算机中位置是从0开始的
		//开始又需要将头结点跳过
		//所以位置和数据差一位
		//先打印再自加
	}
	return -1;
}

9.修改指定的数据

void changeDataLinkList(linklist_t *p,datatype old,datatype new)
{
	while(p->next != NULL)
	{
		p=p->next;
		if(p->data == old)
			p->data=new;
	}
}

10.修改指定位置的数据

int changePostLinkList(linklist_t *p,int post,datatype data)
{
	int i;
	if(post < 0 || post >= lengthLinkList(p))
	{
		printf("post err.\n");
		return -1;
	}
	//将头指针移动指定位置
	for(i=0;i<=post;i++)
		p=p->next;
	p->data=data;
	return 0;
}

11.删除指定的数据

void delectDataLinkList(linklist_t *p,datatype data)
{
	linklist_t *pdel=NULL;
	while(p->next != NULL)
	{
		if(p->next->data == data)
		//指针要指到要删除位置的上一个节点才能进行删除
		{
			pdel=p->next;
			//让pdel指向被删除节点
			p->next=pdel->next;
			//跨过被删除节点
			free(pdel);
			pdel=NULL;
		}else
			p=p->next;
	}
}

12.转置

int reverseLinkList(linklist_t *p)
{

	//容错处理
	if(isEmptyLinkList(p))
	{
		printf("isEmptyLinkList err.\n");
		return -1;
	}
	linklist_t *ptemp=NULL;
	//用于暂时保存无头单向链表砍下的头节点地址
	linklist_t *pa=p->next;//无头单项链表的头节点地址
	p->next=NULL;//有头单向空链表
	while(pa != NULL)
	{
		//砍头
        ptemp=pa;
		pa=pa->next;
		ptemp->next=NULL;
		//插入到p的头节点之后
		ptemp->next=p->next;
		p->next=ptemp;
	}
	return 0;
}

13.清空

void clearLinkList(linklist_t *p)
{
	while(p->next != NULL)
	{
		delectPostLinkList(p,0);
		//循环删除第一个位置的数据
	}
}

14.销毁

void destory(linklist_t **pt)
//之前*p传入的都是复制过来的头节点地址
//这里要释放建立的头节点
//所以将头节点中存储的地址传入，进行赋空
{
     clearLinkList(*pt);
	 free(*pt);
	 //释放头节点
	 *pt=NULL;
	 //将头节点存储的地址置空
}







使用的代码

linklist.h

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

typedef int datatype;
typedef struct node_t
{
	datatype data;
	struct node_t *next;
}linklist_t;

//1.创建一个空的有头单向链表
linklist_t *createLinkList(void);
//2.向链表的指定位置插入数据
int insertPostLinkList(linklist_t *p,int post,datatype data);
//3.计算链表长度
int lengthLinkList(linklist_t *p);
//4.遍历有头单向链表
void showLinkList(linklist_t *p);
//5.删除制定位置的数据
int delectPostLinkList(linklist_t *p,int post);
//6.判断链表是否为空
int isEmptyLinkList(linklist_t *p);
//7.查询链表制定位置的数据 
datatype searchPostLinkList(linklist_t *p,int post);
//8.查询指定数据在链表中的位置
int searchDataLinkList(linklist_t *p,datatype data);
//9.修改指定的数据
void changeDataLinkList(linklist_t *p,datatype old,datatype new);
//10.修改指定位置的数据
int changePostLinkList(linklist_t *p,int post,datatype data);
//11.删除指定的数据
void delectDataLinkList(linklist_t *p,datatype data);
//12.转置
int reverseLinkList(linklist_t *p);
//13.清空
void clearLinkList(linklist_t *p);
//14.销毁
void destory(linklist_t **pt);
#endif

linklist.c

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

//1.创建一个空的有头单向链表
linklist_t *createLinkList(void)
{
	linklist_t *p=(linklist_t *)malloc(sizeof(linklist_t));
	if(NULL == p)
	{
		printf("malloc node err.\n");
		return NULL;
	}
	p->next=NULL;//数据域无效，指针域有效
    return p;
}

//2.向链表的指定位置插入数据
int insertPostLinkList(linklist_t *p,int post,datatype data)
{
	linklist_t *pnew=NULL;
	int i;
   //1.容错处理(位置)
   if(post < 0 || post>lengthLinkList(p))
   {
	   printf("insert post err.\n");
	   return -1;
   }
   //2.创建一个新节点保存插入的数据
   pnew=(linklist_t *)malloc(sizeof(linklist_t));
   if(NULL == pnew)
   {
	   printf("malloc new node err.\n ");
	   return -1;
   }
   //初始化节点内容
   pnew->data=data;
   pnew->next=NULL;

   //3.将头指针移动插入位置的前一个位置
    for(i=0;i<post;i++)
	{
		p=p->next;
	}
	//4.插入 ，先连后，再连前
	pnew->next=p->next;
	p->next=pnew;
	return 0;
}

//3.计算链表长度
int lengthLinkList(linklist_t *p)
{
	int len=0;
	while(p->next != NULL)
	{
		p=p->next;
		len++;
	}
	return len;
}
//4.遍历有头单向链表
void showLinkList(linklist_t *p)
{
	while(p->next != NULL)
	{
		p=p->next;
		printf("%d ",p->data);
	}
	putchar(10);
}
//5.删除制定位置的数据
int delectPostLinkList(linklist_t *p,int post)
{
	int i;
	linklist_t *pdel=NULL;
	//1.容错处理
	if(post < 0 || post >= lengthLinkList(p) || isEmptyLinkList(p))
	{
		printf("isEmptyLinkList or post err.\n");
		return -1;
	}
	//2.移动头指针到删除位置的前一个
	for(i=0;i<post;i++)
		p=p->next;
	//3.定义指针保存删除节点地址
	pdel=p->next;
	//4.跨国删除节点
	p->next=pdel->next;
	//5.释放节点
	free(pdel);
	pdel=NULL;
	return 0;
}

//6.判断链表是否为空
int isEmptyLinkList(linklist_t *p)
{
	return p->next == NULL; //1空  0：非空
}
//7.查询链表制定位置的数据 
datatype searchPostLinkList(linklist_t *p,int post)
{
	int i;
	//容错处理
	if(post < 0 || post >= lengthLinkList(p))
	{
		printf("post err.\n");
		return -1;
	}
    //将指针移动到指定位置
	for(i=0;i<=post;i++)
		p=p->next;
	return p->data;
}

//8.查询指定数据在链表中的位置
int searchDataLinkList(linklist_t *p,datatype data)
{
	int post=0;
	if(isEmptyLinkList(p))
	{
		printf("isEmptyLinkList err.\n");
		return -1;
	}
	while(p->next != NULL)
	{
		p=p->next;
		if(p->data == data)
			return post;
		post++;
	}
	return -1;
}
//9.修改指定的数据
void changeDataLinkList(linklist_t *p,datatype old,datatype new)
{
	while(p->next != NULL)
	{
		p=p->next;
		if(p->data == old)
			p->data=new;
	}
}
//10.修改指定位置的数据
int changePostLinkList(linklist_t *p,int post,datatype data)
{
	int i;
	if(post < 0 || post >= lengthLinkList(p))
	{
		printf("post err.\n");
		return -1;
	}
	//将头指针移动指定位置
	for(i=0;i<=post;i++)
		p=p->next;
	p->data=data;
	return 0;
}
//11.删除指定的数据
void delectDataLinkList(linklist_t *p,datatype data)
{
	linklist_t *pdel=NULL;
	while(p->next != NULL)
	{
		if(p->next->data == data)
		{
			pdel=p->next;
			p->next=pdel->next;
			free(pdel);
			pdel=NULL;
		}else
			p=p->next;
	}
}

//12.转置
int reverseLinkList(linklist_t *p)
{

	//容错处理
	if(isEmptyLinkList(p))
	{
		printf("isEmptyLinkList err.\n");
		return -1;
	}
	linklist_t *ptemp=NULL;
	//用于暂时保存无头单向链表砍下的头节点地址
	linklist_t *pa=p->next;//无头单项链表的头节点地址
	p->next=NULL;//有头单向空链表
	while(pa != NULL)
	{
		//砍头
        ptemp=pa;
		pa=pa->next;
		ptemp->next=NULL;
		//插入到p的头节点之后
		ptemp->next=p->next;
		p->next=ptemp;
	}
	return 0;
}

//13.清空
void clearLinkList(linklist_t *p)
{
	while(p->next != NULL)
	{
		delectPostLinkList(p,0);
	}
}

//14.销毁
void destory(linklist_t **pt)
{
     clearLinkList(*pt);
	 free(*pt);
	 *pt=NULL;
}

main.c

#include <stdio.h>
#include "linklist.h"

int main(int argc, const char *argv[])
{
	linklist_t *p=NULL;
	p=createLinkList();

	insertPostLinkList(p,0,1);
	insertPostLinkList(p,0,5);
	insertPostLinkList(p,0,3);
	insertPostLinkList(p,0,4);
	insertPostLinkList(p,0,5);

	showLinkList(p);

//	delectPostLinkList(p,2);

//	delectPostLinkList(p,4);
//  reverseLinkList(p);
//  delectDataLinkList(p,5);
//  clearLinkList(p);
    destory(&p);//销毁后链表操作函数不能用了
    printf("%p \n",p);//打印p的地址
//	showLinkList(p);

	return 0;
}

Makefile

CC=gcc
OBJS=main.o linklist.o
CFLAGS=-c -g -Wall -o

link:$(OBJS)
	$(CC) $^ -o $@

%.o:%.c
	$(CC) $(CFLAGS) $@ $<

.PHONY:clean

clean:
	rm *.o

结果如下：
在这里插入图片描述

有只小白叫岳飒
关注
专栏目录
带头结点的链表实现
qq_63808434的博客
01-02 204
带头结点的链表实现各项功能（菜单选择功能）
单链表的两种简单实现（有头节点和无头节点）
12-09
重学数据结构第一步：简单实现下链表，功能不是很完善，重在学习思想。
实现带有头结点的链表
横济沧海的博客
03-18 828
首次写博客，请大神不要吐槽 要实现带头结点的链表，重要的是先搞清楚头结点是什么。链表里有几个名词，头指针，头结点，首结点，概念要明白，会区别，弄懂了这一步，链表的开始就没问题了。 头指针即是头结点的地址，头结点数据域为空（当然你也可以用头结点的数据域来保存链表结点的个数），指针域的指针指向首结点，首结点即是你要储存数据的第一个结点。 /* 建立带有头结点的链表 包含函数cre
带有头节点的链表操作
123向前走的博客
03-08 531
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define LEN sizeof(student) typedef struct Student{ int num; float score; struct Student *next; }student; student *find(student *head,int...
链表-数据结构和算法之美学习笔记
greenwoodp的博客
12-18 151
链表的底层存储结构 ​ 数组需要一块连续的内存空间来存储，对内存的要求比较高。如果我们申请一个 100MB 大小的数组，当内存中没有连续的、足够大的存储空间时，即便内存的剩余总可用空间大于 100MB，仍然会申请失败。而链表恰恰相反，它并不需要一块连续的内存空间，它通过“指针”将一组零散的内存块串联起来使用，所以如果我们申请的是 100MB 大小的链表，根本不会有问题 单链表 链表通过指针将一组零散的内存块串联在一起。其中，我们把内存块称为链表的“结点”。为了将所有的结点串起来，每个链表的结点除了存储数
带有头结点的链表实现
yuweilong000的专栏
08-18 689
不带头结点的链表，其插入和删除节点操作需要分两种讨论：第一个数据节点 和 非第一个数据节点。 加入了一个不含数据项的头结点可以统一这两个操作，使得插入和删除可以统一实现，避免了分情况讨论。 #ifndef LIST2_H_INCLUDED #define LIST2_H_INCLUDED typedef int ElemType; struct node
C语言实现带头结点的链表的创建、查找、插入、删除操作
09-04
总结起来，C语言实现带头结点的链表操作包括创建链表（创建头结点并连接数据节点）、查找指定位置的节点、在特定位置插入新节点以及删除某个位置的节点。这些基本操作是理解和掌握链表数据结构的关键，也是进行更...
C语言实现带头结点的单向链表的基本操作
04-04
本文详细介绍了使用C语言实现带头结点的单向链表的基本操作，包括链表的创建、输出、插入元素和删除元素，以及单向链表的逆序连接和两个有序线性表的归并。 一、链表的创建 链表的创建是指在内存中分配一个结点，...
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
最新发布
03-13
链表的删除操作也分为两种情况：删除头结点、删除尾结点以及删除链表中的任意节点。删除头结点或尾结点时，需要特别处理指针的更新，而删除链表中的任意节点则需要找到前一个节点进行操作： ```c void deleteHead...
带头结点的双向循环链表
07-17
为了实现带头结点的链表，我们需要一个额外的头结点，其数据部分通常不存储有效信息，而是用来方便操作链表。 接下来，我们需要实现链表的一些基本操作，如创建、插入、删除节点以及遍历链表。创建链表时，首先创建...
C语言写的带有头结点的链表
04-03
这是一个带有头结点的链表，实现了链表的创建，翻转和销毁。并在main（）函数中举例测试。
有头节点的单链表
NICHUN12345的博客
10-03 248
程序源码 /*带头节点的单链表*/ #include <stdio.h> #include <stdlib.h> typedef int datatype; //类型重定义，方便以后修改变量类型 typedef struct node_st { datatype data; //数据域 struct node_st *next; //指针域 }list; /*函数声明*/ list *list_create(); //创建链表
带有头结点的链表的基本操作
weixin_30808253的博客
09-04 125
#ifndef _LIST_h_ #define _LIST_h_ //链表中的数据结构 typedef struct Link_data { int a; int b; }Node_data; //链表节点结构 typedef struct Link_node { Node_data data; struct ...
16 - 11 - 04 有头节点 单链表---《数据结构（c language）》
Sodaoo's Blog
11-04 570
//设计应用举例 /*编程实现以下任务：建立一个线性表，依次输入数据0123456789、10、11、而后删除数据元素5，最后依次显示当前线性表中的数据元素，假设数据元素个数最大 不会超过100个*/typedef struct{ DateType list[MAXSIZE]; int size; }Seqlist; //初始化 void ListInitiate(Seqlist *
有头结点的单链表的各种操作
hhgfg1980的专栏
09-24 257
//有头结点的单链表 template &lt;class T&gt; struct Node {     T data;     Node&lt;T&gt; *next; }; //----------------------------------------------- //初始化单链表 template &lt;class T&gt; int init_list(Node&lt;T&g...
数据结构-带头节点的单链表（C语言）超详细讲解
热门推荐
m0_56992713的博客
10-17 2万+
前面我们学到线性表的顺序存储结构（顺序表），发现它有着明显的缺点：插入和删除元素时需要频繁的移动元素，运算效率低。必须按事先估计的最大元素个数申请连续的存储空间。存储空间估计大了，造成浪费空间；估计小了，容易产生溢出，空间难以扩大。 采用链式存储结构的线性表（链表）可以克服以上的不足。 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(存放的数据元素)+指针(指示下一个元素存储位置，单、双链表的最后一个节点除外，它们.
链表整表的创建(头插法，带有头节点)
Jaylan的博客
12-19 143
链表整表的创建(头插法，带有头节点) C语言
数据结构之头节点链表实现-c++实现
weixin_51192760的博客
07-22 430
链表；c++;
C语言有头结点链表的经典实现
喂兔子的菜
04-26 1644
        经常用到链表，但每次写都不那么顺利，终于有点时间整理一下，把感觉写的不错的代码拿出来分享，希望大家能指出问题，那我算没白写。 该链表以存放整型数据为例。头文件： #ifndef __LINK_H__#define __LINK_H__#define ERROR ( -1 )#define OK      ( 0  )#define TRUE  ( 1 == 1 )#
go实现带头结点的链表栈
04-04
以下是带头结点的链表栈的Go语言实现： ```go package main import ( "fmt" ) type ListNode struct { Val int Next *ListNode } type MyStack struct { Top *ListNode } /** Initialize your data structure here. */ func Constructor() MyStack { return MyStack{&ListNode{0, nil}} } /** Push element x onto stack. */ func (this *MyStack) Push(x int) { newNode := &ListNode{x, this.Top.Next} this.Top.Next = newNode } /** Removes the element on top of the stack and returns that element. */ func (this *MyStack) Pop() int { if this.Empty() { return -1 } val := this.Top.Next.Val this.Top.Next = this.Top.Next.Next return val } /** Get the top element. */ func (this *MyStack) Top() int { if this.Empty() { return -1 } return this.Top.Next.Val } /** Returns whether the stack is empty. */ func (this *MyStack) Empty() bool { return this.Top.Next == nil } func main() { stack := Constructor() stack.Push(1) stack.Push(2) stack.Push(3) fmt.Println(stack.Top()) // 3 fmt.Println(stack.Pop()) // 3 fmt.Println(stack.Pop()) // 2 fmt.Println(stack.Pop()) // 1 fmt.Println(stack.Empty()) // true } ``` 在上面的代码中，我们使用了一个`ListNode`结构体来表示链表的节点，其中`Val`表示当前节点的值，`Next`表示下一个节点的指针。`MyStack`结构体表示栈，其中`Top`是一个指向头结点的指针。 在`Constructor`函数中，我们初始化栈的头结点。在`Push`函数中，我们将新元素插入到头结点之后。在`Pop`函数中，我们先判断栈是否为空，如果不为空，就返回栈顶元素并将其从栈中删除。在`Top`函数中，我们先判断栈是否为空，如果不为空，就返回栈顶元素。在`Empty`函数中，我们判断栈是否为空。 最后，在`main`函数中，我们测试了上述栈的功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

有只小白叫岳飒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值