数据结构——链表（头指针、头结点）

最新推荐文章于 2024-04-19 15:40:31 发布
最新推荐文章于 2024-04-19 15:40:31 发布
阅读量3.3k 收藏 5
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clusterally/article/details/76673875
版权

头指针链表：

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

#define TRUE   1
#define FALSE  0


typedef int LinkData;    // 链表的数据类型
typedef struct _node
{
    LinkData data;       // 链表的数据
    struct _node *next;  // 指向链表下一个结点的指针
}Node;

// 链表的头插
int Insert_Head(Node **h, LinkData data)
{
    if (h == NULL)
        return FALSE;

    // 创建新节点
    Node* node = (Node*)malloc(sizeof(Node)/sizeof(char));
    if (node == NULL)
    {
        return FALSE;
    }

    // 给结点成员变量赋值
    node->data = data;
    node->next = *h;

    // 让新节点变为链表的第一个结点
    *h = node;

    return TRUE;
}


// 尾插
int Insert_Last(Node **h, LinkData data)
{
    if (h == NULL)
    {
        return FALSE;
    }

    // 创建新节点
    Node* node = (Node*)malloc(sizeof(Node)/sizeof(char));
    if (node == NULL)
    {
        return FALSE;
    }

    // 给结点成员变量赋值
    node->data = data;
    node->next = NULL;

    // 找最后一个结点
    Node * tmp = *h;  // 指向第一个结点
    if (tmp == NULL)  // 空表
    {
        *h = node;
    }
    else
    {
        while (tmp->next)
        {
            tmp = tmp->next;
        }

        tmp->next = node;
    }

    return TRUE;
}


// 在第 pos 个节点处插入数据，链表结点从1开始，没有第0个结点
int Insert_Pos (Node** h, int pos, LinkData data)
{
    if (h == NULL || pos < 1)
        return FALSE;

    // 创建新节点
    Node* node = (Node*)malloc(sizeof(Node)/sizeof(char));
    if (node == NULL)
    {
        return FALSE;
    }

    // 给结点成员变量赋值
    node->data = data;


    // 空表的状态下，只能插入在第一个结点处
    if (*h == NULL)  
    {
        if (pos != 1)
        {
            printf ("当前为空表，无法在第 %d 结点处插入数据\n", pos);
            free(node);
            return FALSE;
        }
        node->next = NULL;
        *h = node;
    }
    else  // 非空表，需要找到插入位置的前一个结点
    {
        if (pos == 1)
        {
            node->next = *h;
            *h = node;
        }
        else
        {
            int i;
            Node *tmp = *h;     // tmp 开始的时候指向第一个结点
            for (i = 0; i < pos-2; i++)
            {
                if (tmp == NULL)  // 如果 pos 太大，会造成越界
                    break;
                tmp = tmp->next;
            }

            if (tmp == NULL)
            {
                printf ("插入位置越界\n");
                free(node);
                return FALSE;
            }

            node->next = tmp->next;
            tmp->next = node;
        }
    }

    return TRUE;
}

int Delete_Pos(Node** h, int pos)
{
    if (h == NULL || *h == NULL || pos < 1)
        return FALSE;

    Node *tmp = *h;
    if (pos == 1)
    {
        *h = tmp->next;
        free(tmp);
    }
    else
    {
        int i;
        for (i = 0; i < pos-2; i++)
        {
            if (tmp->next == NULL)  // 如果 pos 太大，会造成越界
                break;
            tmp = tmp->next;
        }

        if (tmp->next == NULL)
        {
            printf ("删除位置越界\n");
            return FALSE;
        }
        Node* p = tmp->next;
        tmp->next = p->next;
        free(p);
    }


    return TRUE;
}

int Reverse_List(Node **h)
{
    // *h == NULL 空表 (*h)->next == NULL 只有一个元素
    if (h == NULL || *h == NULL || (*h)->next == NULL)
        return FALSE;

    Node *pre = *h;
    Node *cur = (*h)->next;
    Node *tmp;

    while (cur)
    {
        tmp = cur->next;
        cur->next = pre;
        pre = cur;
        cur = tmp;
    }

    (*h)->next = NULL;
    *h = pre;

    return TRUE;
}


void Display(Node *h)
{
    if (h == NULL)
        return;
    int count = 0;
    while (h)
    {
        if (count++ % 4 == 0)
            printf ("\n");
        printf ("%8d", h->data);

        h = h->next;
    }
    printf ("\n");
}

int main()
{
    Node * head = NULL;   // 指向链表第一个结点的指针（头指针）

    // 插入元素
    int i;

    for (i = 0; i < 10; i++)
    {
        //Insert_Head(&head, i);
        Insert_Last(&head, i);
    }
#if 0
    Insert_Pos(&head, 1, 1000);
    Insert_Pos(&head, 10, 2000);
    Insert_Pos(&head, 13, 3000);
    Insert_Pos(&head, 15, 3000);
    Insert_Pos(&head, 0, 1000); 
#endif
    //Delete_Pos(&head, 11);
    Display(head);

    Reverse_List(&head);
    Display(head);

    return 0;
}

头结点链表：

头文件：

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

#define FALSE 0
#define TRUE  1

typedef int LinkData;
typedef struct _node
{
    LinkData data;
    struct _node * next;
}Node;

// 创建链表
Node * Create_List();

// 尾插
int Insert_Last(Node *h, LinkData data);

// 头插
int Insert_Head(Node *h, LinkData data);

// 在第 pos 个结点处插入数据
int Insert_Pos(Node *h, int pos, LinkData data);

//删除 第 pos 个结点
int Delete_Pos(Node* h, int pos);

// 逆序
int Reverse_List(Node *head);

// 删除指定数据
int Delete_Data(Node* h, LinkData data);

// 查找元素:如果有, 返回元素的位置
int Find_Element(Node* h, LinkData data, int *x);

// 获取顺序表中的元素：通过位置获取
int Get_Element(Node* s, int pos, int *x);

int Get_Len(Node * head);

// 清空所有结点
int Clean_List(Node * head);

// 销毁链表
int Destroy(Node *);

void Display(Node *h);
#endif

功能函数：

#include "LinkList.h"
#include <stdlib.h>
#include <stdio.h>
Node * Create_List()
{
    Node *list = (Node*)malloc(sizeof(Node)/sizeof(char));
    if (list == NULL)
        return NULL;

    list->next = NULL;   // 空表

    return list;
}

int Insert_Head(Node *h, LinkData data)
{
    if (h == NULL)
        return FALSE;
    Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
    if (node == NULL)
    {
        return FALSE;
    }

    node->data = data;
    node->next = h->next;

    h->next = node;

    return TRUE;
}

int Insert_Last(Node *h, LinkData data)
{
    if (h == NULL)
        return FALSE;

    Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
    if (node == NULL)
    {
        return FALSE;
    }
    node->data = data;
    node->next = NULL;

    Node* tmp = h;
    while (tmp->next)
    {
        tmp = tmp->next;
    }

    tmp->next = node;

    return TRUE;
}

int Insert_Pos(Node *h, int pos, LinkData data)
{
    if (h == NULL || pos < 1)
        return FALSE;

    // 找要插入位置的前一个结点
    Node *tmp = h;
    int i;
    for (i = 0; i < pos-1; i++)
    {
        if (tmp == NULL)
            break;
        tmp = tmp->next;
    }

    if (tmp == NULL)   // 越界
    {
        printf("插入位置越界\n");
        return FALSE;
    }

    Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
    if (node == NULL)
    {
        return FALSE;
    }
    node->data = data;
    node->next = tmp->next;
    tmp->next  = node;

    return TRUE;
}

int Delete_Pos(Node* h, int pos)
{
    if (h == NULL || pos < 1)
        return FALSE;

    // 找要插入位置的前一个结点
    Node *tmp = h;
    int i;
    for (i = 0; i < pos-1; i++)
    {
        if (tmp->next == NULL)
            break;
        tmp = tmp->next;
    }

    if (tmp->next == NULL)   // 越界
    {
        printf("删除位置越界\n");
        return FALSE;
    }

    Node *p = tmp->next;
    tmp->next = p->next;
    free(p);

    return TRUE;
}

int Reverse_List(Node *h)
{
    // h->next 空表
    // h->next->next 只有一个结点
    if (h == NULL || h->next == NULL || h->next->next == NULL)
        return FALSE;

    Node *pre = h->next;
    Node *cur = h->next->next;
    Node *tmp;

    while (cur)
    {
        tmp = cur->next;
        cur->next = pre;
        pre = cur;
        cur = tmp;
    }

    h->next->next = NULL;
    h->next = pre;

    return TRUE;
}

int Delete_Data(Node* h, LinkData data)
{
    if (h == NULL)
        return FALSE;

    Node *tmp = h;
    while (tmp->next)
    {
        if (tmp->next->data == data)
            break;
        tmp = tmp->next;
    }

    if (tmp->next == NULL)
        return FALSE;

    Node *p = tmp->next;
    tmp->next = p->next;
    free(p);

    return TRUE;
}

int Find_Element(Node* h, LinkData data, int *x)
{
    if (h == NULL)
        return FALSE;

    Node *tmp = h->next;
    int k = 1;
    while (tmp)
    {
        if (tmp->data == data)
        {
            *x = k;
            return TRUE;
        }
        k++;
        tmp = tmp->next;
    }

    return FALSE;
}

int Get_Element(Node* h, int pos, int *x)
{
    if (h == NULL || pos < 1)
        return FALSE;

    int i;
    Node *tmp = h;
    for (i = 0; i < pos; i++)
    {
        if (tmp == NULL)
            break;
        tmp = tmp->next;
    }

    if (tmp == NULL)
        return FALSE;
    else
        *x = tmp->data;

    return TRUE;
}

int Get_Len(Node * h)
{
    if (h == NULL)
        return 0;

    Node *tmp = h;
    int count = 0;
    while (tmp->next)
    {
        count++;
        tmp = tmp->next;
    }

    return count;
}

int Clean_List(Node * h)
{
    if (h == NULL)
        return FALSE;

    Node *tmp = h;
    while (tmp->next)
    {
        Delete_Pos(h, 1);
    }

    return 0;
}


void Display(Node *h)
{
    if (h == NULL)
        return;

    int count = 0;
    Node *tmp = h->next;
    while (tmp)
    {
        if (count++ % 4 == 0)
            printf ("\n");
        printf ("%8d", tmp->data);

        tmp = tmp->next;
    }
    printf ("\n");
}



int Destroy(Node *h)
{
    if (h == NULL)
        return FALSE;
    Clean_List(h);
    free(h);

    return TRUE;
}

main函数：

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

int main()
{
    // 创建链表
    Node* head = Create_List();
    if (head == NULL)
    {
        printf("创建链表失败\n");
        return -1;
    }


    int i;
    for (i = 0; i < 10; i++)
    {
        Insert_Head(head, i);
    }
#if 0       
    for (i = 0; i < 10; i++)
    {
        Insert_Head(head, i);
    }

    Insert_Pos(head, 5, 1000);
    Insert_Pos(head, 1, 2000);
    Insert_Pos(head, 22, 2000);
    Insert_Pos(head, 24, 2000);
    Insert_Pos(head, 26, 2000);
    Delete_Pos (head, 21);

    Reverse_List(head);
#endif
    Delete_Data(head, 0);

    int x;
    Find_Element(head, 7, &x);
    Get_Element(head, 8, &x);
    printf ("%d\n", x);

    printf ("%d\n", Get_Len(head));
    Display(head);
    Clean_List(head);
    printf ("清空后：\n");
    Display(head);

    return 0;
}
clusterally
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构实验——链表
12-07
数据结构实验——链表 链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在这个实验中，我们将深入理解单链表的各种操作，包括建立、显示、求长度、查找、插入、删除、就地...
【数据结构与算法】(4)：链表是什么？头结点和头指针的区别？
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-06 3341
初步认识链表的特点和分类，后续深入各种链表的操作原理。
数据结构：头指针，头结点详解（新手.小白）
BigBigMonster的博客
10-27 2万+
如果不想看定义的话，可以看我的第二部分，里面有我自己遇到的一些疑难。 目录(一）定义详解（二）个人理解 (一）定义详解   1.头结点：（1）数据结构中，在单链表的开始结点之前设立一个节点称之为头结点，头结点的数据域可以不存储任何信息，也可以存储链表的长度等附加信息，头结点的指针域存储指向第一个结点的指针（即第一个结点的存储位置）。        （2）作用：方便链表的操作，减...
链表基础知识详解（非常详细简单易懂）
最新发布
酒无忧的博客
04-19 421
链表作为C语言中一种基础的数据结构，在平时写程序的时候用的并不多，但在操作系统里面使用的非常多。不管是RTOS还是Linux等使用非常广泛，所以必须要搞懂链表，链表分为单向链表和双向链表，单向链表很少用，使用最多的还是双向链表。单向链表懂了双向链表自然就会了。
头指针、头节点、首元结点——《王道数据结构》
qq_42615475的博客
12-30 5299
一、关于头指针、头节点、首元节点的问题 昨天考研专业课遇到了一个选择题 带头结点的单链表具有什么优点 ，因为平时都是用的带头节点的链表，只是单纯记住了结论。考后我想仔细研究研究这个问题… 来CSDN找点资料，发现越看越模糊，下面我来总结总结。 二、教材说法 1.让我们先来瞅瞅这个《王道考研》辅导书上给的结论： 下图就是一个带头结点的单链表。（这个头指针我曾犯过一个很傻的错误，一定要把指针学好，再来学习数据结构） 2.这是《大话数据结构》上给的结论： 3.CSDN上的一些结论： ①.使用头节点，指针
关于链表中头指针和头结点的理解
热门推荐
jyh的博客
05-29 5万+
    线性表使用顺序（数组）存储时有个弊端，那就是在插入和删除时需要大量的移动数据，这显示是非常消耗时间的，所以可以采用链式存储，即有一个指针域（单链表），来记录下个结点的存储位置（地址），这样在插入和删除结点时只需要修改指针域即可，从而大量减少移动数据所消耗的时间。来看链表的定义： struct node { int data; struct node *next; }; 其中...
数据结构之链表的创建头结点与头指针
m0_63623345的博客
12-04 9898
很多正在学C语言的小伙伴可能很快就会学到结构体了，当然单链表可是结构体里面的一块硬骨头，在单链表中我们要能够创建，删除，添加，打印单链表，今天我们就来说一说创建单链表。 单链表的创建又分为两种情况，分别为头插法，和尾插法。当然，我们今天的重点不在这里，我们今天的重点在于头节点，头指针创建单链表（我们今天所用的方法都是头插法) 首先，我们先来介绍一下头结点，和头指针。 头结点： 1.点是为了操作方便而设立的，放在第一个元素结点之前，其数据一般无意义（但也...
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
数据结构——堆栈和队列
02-06
总的来说，这个压缩包提供了关于数据结构——堆栈和队列的C语言实现，以及额外的数字转换和字符串处理功能。这些基础知识对于理解和编写高效的计算机程序至关重要。通过学习和理解这些内容，开发者能够更好地解决...
C++——数组模拟链表
12-03
链表是一种动态的数据结构，每个结点都包含两个部分：数据域和指针域。数据域存储当前结点的值，而指针域存储当前结点的下一个结点的地址。然而，在数组模拟链表中，我们不再使用指针来存储下一个结点的地址，而是...
C/C++经典约瑟夫环问题——带头结点的单向循环链表
03-24
在循环链表中，由于最后一个结点指向头结点，所以删除最后一个结点时需要特别处理，将头结点的next指针设置为当前链表的第二个结点，以保持链表的循环性。 **出列过程**是按照一定的规则进行的。在经典的约瑟夫环...
头结点和头指针
qq_30419463的博客
03-19 1293
头结点和头指针简介
头结点和头指针的详解
博可睿的博客
04-03 5187
头结点和头指针的详解
链表、头指针、头结点、第一个结点的区别与联系
我是Cj，一个正义之人
02-24 6995
图1为线性表（ZHAO, QIAN, SUN, LI, ZHOU, WU, ZHENG, WANG）的逻辑状态。头指针 指示链表中第一个结点（即第一个数据元素的存储映像）的存储位置。同时，由于最后一个数据元素没有直接后继，则线性链表中最后一个结点的指针为“空”（NULL）。                                                         
链表之头指针、头结点、首元结点、空链表
weixin_41692282的博客
09-08 1945
链表头指针，头结点
链表头结点与头指针
WGS.
01-02 3822
链表中第一个结点的存储位置叫做头指针，那么整个链表的存取就必须从头指针开始进行了。之后的每一个结点，其实就是上一个的后继指针指向的位置。链表中第一个结点的存储位置叫做头指针。 头指针和头结点不同，头结点即第一个结点，头指针是指向第一个结点的指针。链表中可以没有头结点，但不能没有头指针。 链表中设置头结点的好处： 防止单链表是空的而设的。当链表为空的时候，带头结点的头指针就指向头结点，如果当链...
C语言入门基础之链表和指针：指针链表速成
qq_72290695的博客
06-28 2447
九个重要点包括指针的基本概念与使用、链表的基本概念与创建、链表的遍历和插入、链表的删除操作、指针链表的反转、双指针法解决链表问题、循环链表的创建与判断、头插法与尾插法，以及释放链表内存。七、循环链表的创建与判断（500字） 循环链表是一种特殊的链表，它的最后一个节点指向头节点，形成一个环形结构。链表的插入操作可以在任意位置插入新的节点，需要修改相应节点的指针。五、指针链表的反转（500字） 反转链表是指将链表中的节点顺序颠倒，使原先指向后继节点的指针指向前驱节点。标题：C语言链表和指针：指针链表速成。
关于链表的头结点和头指针
cc
10-19 3832
在初学数据结构单链表的时候，对于链表的的头指针和头结点之间的区别和联系不是很清楚，后来查阅了一些资料，根据自己的理解大概整理了一下这两者之间的关系，主要就是下面这几点： 1.头指针表明了链表的起点，可以唯一确定一个单链表。 2.头指针指向链表的第一个结点，其指针域存储的是第一个结点在内存中的位置。 3.头结点是单链表的第一个结点，若单链表有头结点，则头指针指向头结点；若单链表不含头结点，则头指针指...
结构之美：单链表的头结点与头指针
foreverhuylee的专栏
08-23 1184
当链表的每个结点只包含一个指针域时，我们称此链表为单链表。 关于单链表的存取，有时候我们在单链表的第一个结点（有效元素）之前附设一个结点，称之为头结点；指向头结点的指针，称之为头指针；对单链表的存取必须从头指针开始进行，由于单链表的最后一个数据元素没有直接后继，则指针为NULL。 对于头结点，数据域可以不存储任何信息，也可存储如链表长度等附加信息。 下面是带头结点的单链表与空表的比较图。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值