带头结点单链表、不带头结点单链表（头指针单链表）

最新推荐文章于 2023-07-18 00:24:24 发布
最新推荐文章于 2023-07-18 00:24:24 发布
阅读量9.7k 收藏 85
点赞数 4
文章标签： c语言 c# javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50539337/article/details/121650024
版权
本文详细探讨了头结点与头指针在单链表实现中的差异，包括它们的概念、作用以及在各种操作如插入、删除、查找等中的实现方式。通过实例展示了头结点如何存储链表长度，以及头指针如何简化操作。同时，对比了头结点单链表和头指针单链表在空间效率和操作复杂度上的特点。
摘要由CSDN通过智能技术生成

1、头结点和头指针的区别

1.1区别：
头指针表明了链表的结点，可以唯一确定一个单链表。
头指针指向链表的第一个结点，其记录第一个存储数据的结点的地址。
头结点是点链表的第一个结点，若单链表有头结点，则头指针指向头结点；若单链表没有头结点，则指针指向第一个结点。
一个单链表可有没有头结点，但不能没有头指针。
头结点的数据域可以不存储任何数据。

1.2记录链表的类型不同：
头指针是一个4字节的指针，记录第一个存储数据的结点的地址。
头结点是一个结构体变量，使用这个变量的next域来记录第一个存储数据的结点的地址，头结点的data域可以使用联合体的方式记录链表的长度。

1.3各个操作方法的定义不同
如果是头指针实现，则方法中国接受这个链表的类型必须是二级指针。
头指针实现使用一级指针就OK。
在这里插入图片描述

2、头结点单链表

链表和顺序表的区别：
（1）链表在逻辑存储上是连续的，在物理存储上是不连续的。
（2）单链表属于链表中的一种，每一个存储数据的节点除了存储数据本身之外，还要存储其直接后继结点的地址。
在这里插入图片描述
例：32位系统存储10个整形（int 4个字节）数据：
顺序表存储 ：总共需要堆区空间：40个字节
单链表存储： 总共需要堆区空间：80个字节

单链表的实现

头结点：
在这里插入图片描述
头指针——在实现代码中会使用二级指针
在这里插入图片描述
方法的声明：

#include<stdio.h>
typedef int DataType;

typedef struct Node
{
	//数据类型
	union//结合体、联合体
	{
		DataType data;//存储元素
		int length;//存储元素个数
	};
	//结点指针类型
	struct Node *next; 
}LinkList;

//初始化
void InitLinkList(LinkList *head);

//销毁
void DestroyLinkList(LinkList *head);

//按位置插入插入
bool InsertPos(LinkList *head,DataType value,int pos);

//头插
bool InsertFront(LinkList *head,DataType value);

//尾插
bool InsertRear(LinkList *head,DataType value);

//按位置删除
bool DeletePos(LinkList *head,int pos);

//头删
bool DeleteFront(LinkList *head);

//尾删
bool DeleteRear(LinkList *head);

//按值删除
bool DeleteValue(LinkList *head,DataType value);

//判空
bool IsEmpty(LinkList *head);

//求长度
int GetLength(LinkList *head);

//输出
bool PrintLinkList(LinkList *head);

方法的实现：

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<string.h>
#include"head.h"

static LinkList *ApplyNode(DataType value,LinkList *point )
{
       LinkList *new_node=(LinkList *)malloc(sizeof(LinkList));
       if(new_node==NULL) return NULL;
       new_node->data=value;
       new_node->next=point;
    
    return new_node;
}

void InitLinkList(LinkList *head)
{
	 
     if(head==NULL) exit(0);
     
	
    head->length=0;
     head->next=NULL;
}




int GetLength(LinkList *head)
{
    if(head==NULL) exit(0);
    return head->length;
}

bool InsertPos(LinkList *head,DataType value,int pos)
{
     if(head==NULL) exit(0);
     if(pos<0||pos>GetLength(head)) return false;
     
     LinkList *p=head;
     while(pos)
    {
          p=p->next;
          pos--;
         
    }
    LinkList *new_node=ApplyNode(value,p->next);//生成新的结点
    if(new_node==NULL) return false;
           
    p->next=new_node;
    head->length++;
    return true;
     
}

bool InsertFront(LinkList *head,DataType value)
{
     if(head==NULL) exit(0);
     LinkList *new_node=ApplyNode(value,head->next);
     if(new_node==NULL) return false;
      
     head->next=new_node;
     head->length++;
     return true;
}

bool InsertRear(LinkList *head,DataType value)
{
     if(head==NULL) exit(0);
    return InsertPos(head,value,GetLength(head));
}

bool DeletePos(LinkList *head,int pos)
{
     if(head==NULL) exit(0);
     if(pos<0||pos>=head->length) return false;
     LinkList *p=head;
     while(pos)
     {
        p=p->next;
        pos--;
     }
     LinkList *q=p->next;
     p->next=q->next;
     free(q);
     head->length--;
     return true;
}

bool DeleteFront(LinkList *head)
{
     if(head==NULL) exit(0);
     return DeletePos(head,0);
}

bool DeleteRear(LinkList *head)
{
     if(head==NULL) exit(0);
     return DeletePos(head,GetLength(head)-1);
}

bool DeleteValue(LinkList *head,DataType value)
{
     if(head==NULL) exit(0);
     LinkList *p=head;
     LinkList *q=p->next;
     while(q!=NULL)
    {
       if(q->data==value)
        {
            p->next=q->next;
            free(q);
            q=p->next;
            head->length--;
        }
        else
        {
            p=q;
            q=q->next;
        }
    }
    return true;
}

bool IsEmpty(LinkList *head)
{ 
     if(head==NULL) exit(0);
     return head->length==0;
}

bool PointLinkList(LinkList *head)
{
     if (head == NULL) exit(0);

	LinkList *p = head->next;

	while (p != NULL)
	{
		printf("%d  ", p->data);
		p = p->next;
	}

	printf("\n");
}
void DestroyLinkList(LinkList *head)
{
     if(head=NULL) exit(0);
     while(IsEmpty(head)!=NULL)
	 {
      DeleteFront(head);

	 }
}

//找到第K个结点
LinkList *FindK(LinkList *head, int k)  //  0< k <= length
{
	if (head == NULL)  return NULL;

	if (k <= 0 || k > head->length)  return NULL;

	int pos = head->length - k + 1;

	LinkList *p = head;

	while (pos)
	{
		p = p->next;
		pos--;
	}
	
	return p;
}

//  不能直接获得length的情况
LinkList *FindOfK2(LinkList *head, int k)
{
	if (head == NULL)  return NULL;

	if (k <= 0)  return NULL;

	LinkList *p = head;

	while (k && p != NULL)
	{
		p = p->next;
		k--;
	}

	if (p == NULL)  return NULL;

	LinkList *q = head;
	while (p != NULL)
	{
		p = p->next;
		q = q->next;
	}

	return q;
}

//O(1)删除非尾结点p
bool DeletePos1(LinkList *head,int pos)
{
    if(head==NULL) return false;
    if(pos<0||pos>=head->length) return false;
    LinkList *p=head;
    while(pos)
    {
        p=p->next;
        pos--;
    }
    LinkList *q=p->next;
    p->next=q->next;
    free(q);
    head->length--;
    return true;
    
}

//将单链表逆置  -- 结点逆置
void Reverse(LinkList *head)
{
    if(head==NULL) return;
    LinkList *p=NULL;
    LinkList *q=head->next;
    LinkList *s=q->next;
	
    while(q!=NULL)
    {
        q->next=p;
        p=q;
        q=s;
        if(s!=NULL) s=s->next;
    }
    head->next=p;
}
//判断两个结点是否相交，返回相交的第一个结点
LinkList *IsIntersect(LinkList *head1,LinkList *head2)
{
    if(head1==NULL||head2==NULL) return false;
    LinkList *p=head1;
    LinkList *q=head2;
    if(head1->length>head2->length)
    {
        for(int i=0;i<head1->length-head2->length;i++)
        {
            p=p->next;
        }
    }
    else
    {
        for(int i=0;i<head2->length-head1->length;i++)
        {
            q=q->next;
        }
    }
    while(p!=q)
    {
        p=p->next;
        q=q->next;
    }
	
    return p;
}

LinkList *IsIntersect2(LinkList *head1, LinkList *head2)
{
	if (head1 == NULL || head2 == NULL)  return NULL;

	LinkList *p = head1;
	LinkList *q = head2;

	while (p != q)
	{
		if (p != NULL) p = p->next;
		else  p = head2;
		if (q != NULL) q = q->next;
		else q = head1;
// 		p = p != NULL ? p->next : head2;
// 		q = q != NULL ? q->next : head1;
	}

	return p;
}
//判断单链表是否有环，如果有，返回入环的第一个结点
LinkList *IsLoop(LinkList *head)
{
    if(head==NULL) return NULL;
    LinkList *fast=head;
    LinkList *slow=head;
    while(fast!=NULL&&fast->next!=NULL)
    {
        fast=fast->next->next;
        slow=slow->next;
        if(fast==slow) break;
    }
    LinkList *p=fast;
    LinkList *q=slow;
    while(q!=p)
    {
        p=p->next;
        q=q->next;
    }
    return p;
}

int main()
{
	LinkList list;
	InitLinkList(&list);
	InsertFront(&list,1);
	InsertPos(&list,2,1);
	InsertRear (&list,3);
	InsertRear (&list,4);
	InsertRear (&list,5);
	DeletePos(&list,1);
	printf("单链表长度为:%d\n",GetLength(&list));
	printf("第一次输出：");
	PointLinkList(&list);
	DeleteValue(&list,4);
	InsertPos(&list,2,1);
	printf("第二次输出：");
	PointLinkList(&list);
	return 0;
}

3、头指针单链表

在这里插入图片描述
方法的声明：

#include<stdio.h>
typedef  int  DataType;

typedef struct Node
{
  	DataType    data;    //   记录本结点存储的数据
    struct Node  *next;  //   记录下一个结点的地址
}LinkList;

// 初始化
void  InitLinkList(LinkList **phead);
//  插入
bool InsertLinkList(LinkList **phead, DataType value, int pos);

bool InsertLinkListHead(LinkList **phead, DataType value);

bool InsertLinkListRear(LinkList **phead, DataType value);

//  删除
bool DeleteLinkList(LinkList **phead, int pos);

bool DeleteLinkListHead(LinkList **phead);

bool DeleteLinkListRear(LinkList **phead);

//  长度
int GetLength(LinkList **phead);
//  判空
bool  Empty(LinkList **phead);
//  销毁
void  DestroyLinkList(LinkList **phead);

//  显示
void  ShowLinkList(LinkList **phead);

方法的实现：

#include "head.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>


static LinkList *ApplyNewNode(DataType value, LinkList *next)
{
	LinkList *new_node = (LinkList *)malloc(sizeof(LinkList));
	if (new_node == NULL)  exit(0);

	new_node->data = value;
	new_node->next = next;

	return new_node;
}


void  InitLinkList(LinkList **phead)  //  phead中存储的值就是main方法中的phead变量的地址
{
	if (phead == NULL)  exit(0);

	*phead = NULL;
}

int GetLength(LinkList **phead)
{
	if (phead == NULL)  exit(0);

	int length = 0;

	LinkList *p = *phead;

	while (p != NULL)
	{
		length++;
		p = p->next;
	}

	return length;
}

bool InsertLinkList(LinkList **phead, DataType value, int pos)
{
	if (phead == NULL)  exit(0);

	if (pos < 0 || pos > GetLength(phead))  return false;

	//  在头指针的后面插入新结点，头插法必须特殊处理： 因为只有在这需要修改头指针的值
	if (pos == 0)  return InsertLinkListHead(phead, value);//  头插


	LinkList *p = *phead;

	while (pos > 1)
	{
		p = p->next;
		pos--;
	}

	//  while循环结束后，就需要在p所指向的结点的后面插入新结点

	/* 
		LinkList *new_node = ApplyNewNode(value, p->next); 
		p->next = new_node;
	*/
	p->next = ApplyNewNode(value, p->next);
	return true;
}

bool InsertLinkListHead(LinkList **phead, DataType value)
{
	if (phead == NULL)  exit(0);

	*phead = ApplyNewNode(value, *phead);

	return true;
}

bool InsertLinkListRear(LinkList **phead, DataType value)
{
	if (phead == NULL)  exit(0);

	//  链表本身是空的，尾插相当于头插
	if (Empty(phead))  return InsertLinkListHead(phead, value);

	LinkList *p = *phead;

	while (p->next != NULL)  p = p->next;  //  while循环结束后，p就是最后一个结点

	p->next = ApplyNewNode(value, NULL);
	return true;
}

bool  Empty(LinkList **phead)
{
	if (phead == NULL)  exit(0);

	if (*phead == NULL)  return true;

	return false;
}



bool DeleteLinkList(LinkList **phead, int pos)
{
	if (phead == NULL)  exit(0);

	if (pos < 0 || pos >= GetLength(phead))  return false;

	if (pos == 0)  return DeleteLinkListHead(phead);

	LinkList *p = *phead;  //  p指向的是第一个数据结点

	while (pos > 1)
	{
		p = p->next;
		pos--;
	}

	//  while循环结束后，要删除的结点时p->next
	LinkList *q = p->next;
	p->next = q->next;
	free(q);
	return true;
}

bool DeleteLinkListHead(LinkList **phead)
{
	if (phead == NULL)  exit(0);

	if (Empty(phead))  return false;

	LinkList *p = *phead;

	*phead = p->next;
	free(p);
	return true;
}

bool DeleteLinkListRear(LinkList **phead)
{
	if (phead == NULL)  exit(0);

	if (Empty(phead))  return false;

	LinkList *front = NULL;
	LinkList *p = *phead;

	while (p->next != NULL)
	{
		front = p;
		p = p->next;
	}

	if (front == NULL)  return DeleteLinkListHead(phead);

	front->next = NULL;
	free(p);
	return true;
}

void  DestroyLinkList(LinkList **phead)
{
	if (phead == NULL)  exit(0);

	while (!Empty(phead))
	{
		DeleteLinkListHead(phead);
	}
}

void  ShowLinkList(LinkList **phead)
{
	if (phead == NULL)  exit(0);

	LinkList *p = *phead;

	while (p != NULL)
	{
		printf("%d  ", p->data);
		p = p->next;
	}

	printf("\n");
}

int main()
{
	LinkList *list;
	InitLinkList(&list);
	InsertLinkListHead(&list,6);
	InsertLinkListHead(&list,5);
	InsertLinkListHead(&list,4);
	InsertLinkListHead(&list,3);
	InsertLinkListHead(&list,2);
	InsertLinkListHead(&list,1);
	DeleteLinkList (&list,5);
	printf("第一次输出：");
	ShowLinkList(&list);
	InsertLinkList(&list,6,5);
	InsertLinkListRear(&list,7);
	DeleteLinkListHead(&list);
	DeleteLinkListRear(&list);
	printf("第一次输出：");
	ShowLinkList(&list);


	return 0;
}
头指针单链表操作时的转化

因为头结点实现的单链表相比于头指针实现的单链表，操作时特殊情况少一些。在实现一些有指针的单链表的操作时，可以虚拟构建出一个头结点。

bool Funaction(LinkList **phead)
{
	//虚拟出来的头结点
	LinkList *head=(LinkList *)malloc(sizeof(LinkList));
	head->next =*phead;

	LinkList *p=head;//p指向头结点
	LinkList *q=p->next;

	while(q->next!=NULL)
	{
		p=q;
		q=q->next;
	}

	p->next=q->next ;
	free(q);
	*phead=head->next;
	free(head);
}
小永。
关注
  • 4
    点赞
  • 踩
  • 85
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构（2）—单链表（带头结点和不带头结点）
qq_61914039的博客
08-31 3126
单链表是通过一组任意的存储单元来存储线性表中的数据元素。每个结点都有data数据域（用来存放数据元素）和next指针域（用来存放后继节点的地址）。对于顺序表，单链表可以解决顺序表需要一整个大量的连续的存储单元的缺点，单链表的元素可以离散地分布在存储空间中，即非随机存取的存储结构，不能直接找到表中某个特定的结点，当查找某个特定的结点时，需要从表头开始一个一个遍历。因为单链表附加了指针域，缺点就是存储空间增大。单链表有带头结点和不带头结点两种类型。引入头结点。
单链表：带头结点和不带头结点 总结
热门推荐
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
03-25 1万+
写在前面：        一直以来，带头结点和不带头节点的单链表的操作实现困扰着我。在没有理解和实现之前，光凭思考真的是很难理解清楚 1.两者之间代码的差异； 2.带不带头结点的区别； 3.带头结点之后，什么情况下形参必须传二级指针（或者一级指针的引用）；       ...
带头与不带头节点单链表
weixin_44501074的博客
10-12 2164
链表与顺序表、链表的一些常用方法
数据结构-单链表（带头结点与不带头结点表示）
Yyan7777的博客
02-13 3808
单链表是线性表的链式存取结构；是用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的；
带头结点链表&不带头结点链表
weixin_42072280的博客
10-06 919
带头结点链表     空链：   POINT head1 = {0};   //此为不完全赋初值，指针被赋值为NULL。若不赋值，则head1中的三个成员是有值的，其值为垃圾数据 //此链为一个空链（不关心数据域，只要指针域为空即可），空链是链表的起始点。           ...
带头节点的链表
alm23479的博客
01-30 119
链表的基本操作 #include<stdio.h> #include<stdlib.h> #include<malloc.h> typedef int type; typedef struct Node { type info; struct Node *next; }node; //建立一个头节点并将其指针返回 node...
链表-使用C语言实现带头结点的单链表.zip
最新发布
03-13
本资料包"链表-使用C语言实现带头结点的单链表.zip"详细介绍了如何用C语言构建一个带头结点的单链表。 首先，我们来看链表的基本概念。链表由一系列节点组成，每个节点包含两部分：数据元素和指向下一个节点的指针...
小白算法积累——单链表15#2个带头结点单链表+提取公共元素+二表合一
01-20
在解决问题的过程中，我们需要初始化这三个指针，`pa` 指向A链表的第二个节点（因为题目要求带头结点），`pb` 指向B链表的第二个节点，而`pc` 初始指向链表A的头结点。 接下来，我们使用一个`while`循环来遍历两个...
2，带头结点单链表的定义及基本操作源代码
12-18
以上就是带头结点单链表的基本定义和操作。这些操作构成了链表操作的基础，可以在此基础上扩展出更复杂的算法和数据结构。通过理解并实现这些基本操作，可以加深对链表和数据结构的理解，提高编程技能。在实际编程中...
c代码-不带头结点单链表创建——头插法
07-14
在本主题中，我们将深入探讨如何使用头插法创建一个不带头结点的单链表。头插法是一种在链表头部插入新节点的方法，这与尾插法相反，后者是在链表末尾添加新节点。 首先，我们需要定义链表节点的结构体类型。在...
单循环链表（带头结点和不带头结点）
05-21
自己在实验课是做的。主要是单循环链表，有带头结点和不带头结点两种情况。 文件里分别进行了实现。有两个文件
【考研】分清带头结点和不带头结点的单链表
qq_34438969的博客
10-09 4698
为分清带结点与不带头结点的单链表操作，本文以图文和表格形式描述了两者之间的区别。考研中，数据结构的单链表操作是重要考点，其中，比较常考带头结点的链表操作。本文包含了带头结点的插入、删除、查找、用前插法和后插法创建单链表等基本操作。【考研】数据结构考点——直接插入排序_住在阳光的心里的博客-CSDN博客【考研】单链表相关算法（从基础到真题）_住在阳光的心里的博客-CSDN博客。
带头结点单链表 和 不带头结点单链表的区别
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
11-12 1万+
文章目录不带头结点的操作代码①代码②代码③代码④带头结点的操作代码⑤ 下面的代码中，传递链表时，传的是头指针。如果是带头结点的链表，传递链表时，可以传头结点，具体可以看看 C语言实现-线性表的链式存储(单链表) 带头结点单链表 和 不带头结点单链表的区别： 带头结点单链表，在进行插入、删除操作时，不需要改变链表头指针。 不带头结点的单链表，在进行插入、删除操作时，可能会涉及到链表头指针的修改（所以链表作为参数传递时，传递的是头指针的引用，具体可看代码④中head_insert方法中的指针变量带了
数据结构学习笔记——线性表的链式表示（单链表带头结点和不带头结点的基本操作）
小宇y的博客
04-10 8393
目录单链表的相关知识点（一）单链表的定义（二）单链表的初始化和空表判断（三）单链表的建立（四）单链表的输出（五）单链表的逆序输出（六）单链表的插入操作（七）单链表的删除操作（）（） 单链表的相关知识点 单链表是链式存储的，其每个结点除了存放数据元素之外，还存储指向下一个结点的指针；而顺序表是顺序存储的，其每个结点只存放数据元素。【顺序存储结构可以随机存取、顺序存取，而链式存储结构只能顺序存取】 顺序存储结构不仅可用于存储线性结构，还能用于树、图。 若需对表进行频繁的插入、删除操作，此时适合选链式存储。 一
数据结构——单链表（带头指针）
m0_60939437的博客
08-15 599
#include<stdio.h> #include<stdlib.h> //typedef 改名 typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList; //单链表找到头指针 就等于找到了链表 bool InitList(LinkList &L){ L = (LNode *)malloc(sizeof(LNode)); if(L==NULL) .
带头结点和不带头结点的单链表区别
Hhytyq的博客
01-22 3550
链接
C语言——链表（带头节点与不带头节点）
m0_73771309的博客
07-18 1305
链表是一种常见的线性数据结构，它由一系列的节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点可以在内存中不连续地分布，通过指针将它们串联在一起。下面呢，进入正题！！！首先呢，我们先看这张图！这是带头节点，带头节点的链表是在链表头部添加了一个额外的节点，该节点不存储任何数据，只是作为链表的起始位置。带头节点的链表中，头节点的下一个节点才是实际存储数据的第一个节点。
数据结构与算法学习笔记(java版)——第三章 链表
五更钟动的博客
04-12 891
第三章 链表
[日常] 链表-头结点和头指针的区别
程序员老狼专注开发aigc或客服系统应用
06-27 3714
理解下头结点1.头结点是为了操作的统一与方便而设立的，放在第一个元素结点之前，其数据域一般无意义（当然有些情况下也可存放链表的长度）。2.有了头结点后，对在第一个元素结点前插入结点和删除第一个结点，其操作与对其它结点的操作统一了。3.首元结点也就是第一个元素的结点，它是头结点后边的第一个结点。4.头结点不是链表所必需的。 理解下头指针1.在线性表的链式存储结构中，头指针是指链表指向第一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值