单链表无头节点

最新推荐文章于 2024-07-13 08:21:27 发布
最新推荐文章于 2024-07-13 08:21:27 发布
阅读量362 收藏 8
点赞数 9
文章标签： 数据结构 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67152404/article/details/134639890
版权 


/*
Create_input_LinkedList:创建一条从键盘上输入数据的整形数据链表
返回值:
返回的 首节点的地址
*/
struct Node *Create_input_LinkList()
{
    // 创建首尾节点
    struct Node *first = NULL; // 首节点指针
    struct Node *last = NULL;  // 尾节点指针
    while (1)
    {
        // 获取数据
        int d;
        scanf("%d", &d);
        if (d == 0)
            break;
        // 创建新的数据节点并赋值
        struct Node *pnew = malloc(sizeof(*pnew));
        pnew->data = d;
        pnew->next = NULL;
        // 把新的数据节点加入到链表
        if (first == NULL && last == NULL)
        {
            first = last = pnew;
        }
        else
        {
            last->next = pnew;
            last = pnew;
        }
    }
}

/*
  Print_LinkedList:输出一条整型数据链表
  @first: 指针,指向链表的首节点
  返回值:
    无
*/
// 打印链表
void Printf_ListLint(struct Node *p)
{
    struct Node *first = p;
    while (first != NULL)
    {
        printf("%d\n", first->data);
        first = first->next;
    }
}

/*
Create_input_LinkedList_front:用头插法的方式创建一条从键盘上输入数据的整形数据链表
返回值:
返回的 首节点的地址
*/
// 头插法
struct Node *Create_input_LinkedList_front_1()
{
    struct Node *first = malloc(sizeof(*first));
    int x;
    printf("键盘输入一些元素:");
    scanf("%d", &x);
    while (x != 0)
    {
        struct Node *p = malloc(sizeof(*p));
        p->data = x;
        p->next = first->next;
        first->next = p;
        scanf("%d", &x);
    }
    return first;
}

/*
Insert_node_y:在first指向的链表中,查找节点值为x的节点,在其前面插入一个值为y的节点
如果没有则增加在最后,如果有多个则找第一个
返回值:
返回插入之后链表的首节点地址
*/
struct Node *Insert_node_y_1(struct Node *first, Elemtype x, Elemtype y)
{
    struct Node *p = first;
    while (p->data && p->next->data != x)
    {
        p = p->next;
    }
    struct Node *pnew = malloc(sizeof(*pnew));
    pnew->data = y;
    pnew->next = NULL;
    if (!p->next)
    {
        p->next = pnew;
    }
    else
    {
        pnew->next = p->next;
        p->next = pnew;
    }
    return first;
}

/*
    Create_input_LinkedList_front:用头插法的方式创建一条从键盘上输入数据的整形数据链表

    返回值:
        返回的 首节点的地址
*/
struct Node *Create_input_LinkedList_front()
{
    struct Node *first = NULL;

    while (1)
    {
        int d;
        scanf("%d", &d);
        if (d == 0)
        {
            break;
        }
         创建新节点,赋值
        struct Node *pnew = malloc(sizeof(*pnew));
        pnew->data = d;
        pnew->next = NULL;

        // 头插法的方式加入到链表中
        if (first == NULL) // 从无到有
        {
            first = pnew;
        }
        else
        {
            pnew->next = first;
            first = pnew; // 更新首节点指针
        }
    }

    return first;
}
/*
    Insert_node_y:在first指向的链表中,查找节点值为x的节点,在其前面插入一个值为y的节点
    如果没有则增加在最后,如果有多个则找第一个
    返回值:
        返回插入之后链表的首节点地址
*/
struct Node *Insert_node_y(struct Node *first, Elemtype x, Elemtype y)
{
    // 创建新节点并赋值
    struct Node *pnew = malloc(sizeof(*pnew));
    pnew->data = y;
    pnew->next = NULL;
    // 查找
    struct Node *p = first;  // 遍历指针
    struct Node *pre = NULL; // 指向p前面一个节点
    while (p)
    {
        if (p->data == x)
            break;
        pre = p;
        p = p->next;
    }
    // 根据分析结果执行不同的操作
    if (p) // 找到
    {
        // 根据不同的位置执行不同的操作
        if (p == first) // 找到的节点在开头
        {
            pnew->next = first;
            first = pnew;
        }
        else
        {
            pnew->next = p;
            pre->next = pnew;
        }
    }
    else // 未找到
    {
        if (first == NULL)
        {
            first = pnew;
        }
        else
            pre->next = pnew;
    }

    return first;
}
/*
    Insert_node_y_behind_x:在first指向的链表中,查找节点值为x的节点,在其后面插入一个值为y的节点
    如果没有则增加在最后,如果有多个则找第一个
    返回值:
        返回插入之后链表的首节点地址
*/
struct Node *Insert_node_y_behind_x(struct Node *first, Elemtype x, Elemtype y)
{
    // 创建新节点并赋值
    struct Node *pnew = malloc(sizeof(*pnew));
    pnew->data = y;
    pnew->next = NULL;
    // 查找
    struct Node *p = first;  // 遍历指针
    struct Node *pre = NULL; // 指向p前面一个节点
    while (p)
    {
        if (p->data == x)
            break;
        pre = p;
        p = p->next;
    }
    // 根据分析结果执行不同的操作
    if (p) // 找到
    {
        pnew->next = p->next;
        p->next = pnew;
    }
    else // 未找到
    {
        if (first == NULL)
        {
            first = pnew;
        }
        else
            pre->next = pnew;
    }

    return first;
}
/*
    Delete_x_node:在first指向的链表中,查找节点值为x的节点,将其删除
    如果有多个则删除第一个
    返回值:
        返回删除之后链表的首节点地址
*/
struct Node *Delete_x_node(struct Node *first, Elemtype x)
{

    // 查找节点值为x的节点
    struct Node *p = first; // 遍历指针
    struct Node *pre = NULL;
    while (p)
    {
        if (p->data == x)
        {
            break;
        }
        pre = p;
        p = p->next;
    }

    // 找到则删除
    if (p)
    {
        // 删除操作
        if (p == first) // 要删除的是首节点
        {
            first = first->next;
            p->next = NULL;
            free(p);
            p = NULL;
        }
        else
        {
            pre->next = p->next;
            p->next = NULL;
            free(p);
            p = NULL;
        }
    }

    return first;
}
/*
    Delete_all_x_node:在first指向的链表中,查找节点值为x的节点,将其删除
    如果有多个则删除所有
    返回值:
        返回删除之后链表的首节点地址
*/
struct Node *Delete_all_x_node(struct Node *first, Elemtype x)
{
    struct Node *p = first; // 遍历指针
    struct Node *pre = NULL;

    // 查找节点值为x的节点
    while (p)
    {
        if (p->data == x)
        {
            // 删除操作
            if (p == first) // 要删除的是首节点
            {
                first = first->next;
                p->next = NULL;
                free(p);
                p = first;
            }
            else
            {
                pre->next = p->next;
                p->next = NULL;
                free(p);
                p = pre->next;
            }
        }
        else
        {
            pre = p;
            p = p->next;
        }
    }

    return first;
}
/*
    Create_sort_LinkedList:从键盘上输入数据,创建一条升序的整型数据链表
    返回值:
        返回新链表的首节点地址
*/
struct Node *Create_sort_LinkedList()
{
    struct Node *first = NULL; // 指向首节点
    struct Node *last = NULL;  // 指向尾节点
    while (1)
    {
        int d;
        scanf("%d", &d);
        if (d == 0)
            break;
        // 创建新节点并赋值
        struct Node *p = malloc(sizeof(*p));
        p->data = d;
        p->next = NULL;

        // 把新节点增加到链表中
        if (first == NULL && last == NULL) // 空链表
        {
            first = p;
            last = p;
        }
        else // 非空链表
        {
            // 查找链表中第一个比我大的节点,找到的情况下在其前面增加新节点
            // 1. 查找链表中第一个比我大的节点
            struct Node *q = first;
            struct Node *new = NULL;
            while (q != NULL && q->data < d)
            {
                new = q;
                q = q->next;
            }

            // 在其前面增加新节点
            if (new == NULL) // 新节点比首节点小
            {
                p->next = first;
                first = p;
            }
            else if (q == NULL) // 新节点比所有节点都大,尾插法
            {
                last->next = p;
                last = p;
            }
            else // 中间插入
            {
                new->next = p;
                p->next = q;
            }
        }
    }
    return first;
}

struct Node *Create_sort_LinkedList_1()
{
    struct Node *first = NULL;
    struct Node *last = NULL;
    while (1)
    {
        int d;
        scanf("%d", &d);
        if (d == 0)
            break;
        // 创建新节点
        struct Node *p = malloc(sizeof(*p));
        p->data = d;
        p->next = NULL;

        // 加入到链表中
        if (first == NULL && last == NULL)
        {
            first = p;
            last = p;
        }
        else // 非空链表
        {
            if (first->data > d)
            {
                // 头插法
                p->next = first;
                first = p;
                continue;
            }
            struct Node *pnew = first;
            // 查找位置
            while (pnew->next && pnew->data <= d)
            {
                pnew = pnew->next;
            } // p.一定不为空
            // 执行插入操作
            p->next = pnew->next;
            pnew->next = p;
        }
    }
    return first;
}

QM897
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
无头节点的单链表
07-17
无头节点单链表的实现可是说是对C语言指针一个最直接、最贴合实际、也是最具有归纳性的程序设计应用。许多C语言基础面试题都涉及单链表的实现和构造，其目的就是考察面试者对C语言基础数据类型是否有足够的了解，对...
单链表的两种简单实现（有头节点和无头节点）
12-09
在本文中，我们将深入探讨单链表的两种简单实现：有头节点和无头节点。这两种方法虽然看似微小的区别，但在实际编程中可能会产生显著的影响。 首先，我们来理解链表的基本概念。链表不像数组那样在内存中连续存储...
无头节点--单链表
qq_53010164的博客
04-01 1708
目录 一、单链表打印： 二、增容 三、单链表尾插 四、单链表头插 五、单链表尾删 六、单链表头删 七、单链表的查找 八、单链表在pos之后插入X 九、单链表在pos之前插入X 十、删除pos位置 十一、删除pos之后的位置 十二、销毁链表 总代码： Slistexe.h Slistexe.c test.c 部分运行结果：​ 一、单链表打印： //打印 void SListprint(SL* phead) { SL* cur = phead; whil...
链表(1)C语言实现 单链表 无头结点 基本操作 无头结点单链表的基本操作 详解 链表的概念及结构 数据结构
weixin_63666347的博客
04-28 2470
3.链表 3.1 链表的概念及结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表 中的指针链接次序实现的 注意： 1.从上图可看出，链式结构在逻辑上是连续的，但是在物理上不一定连续 2.现实中的结点一般都是从堆上申请出来的 3.从堆上申请的空间是按照一定的策略来分配的，两次申请的空间可能连续也可能不连续 3.2 链表的分类 1. 单向或者双向 2. 带头或者不带头 3. 循环或者非循环 3.3 单链表的实现 ...
单链表 无头节点
天道酬勤
09-09 444
单链表 无头节点就这书上代码敲了一边，加深印象，没有头结点的时候插入第一个就有所不同了，而删除时要找到前一个，注意current->link==null 就这样。代码#include <iostream> #include <cstdio> #include <cstdlib>using namespace std;struct linknode { int data; linkno
C++ 单链表（无头结点）
qq_43650934的博客
11-17 4955
文章目录总结归纳代码实现 总结归纳 头结点可以没有，头指针必须有。访问整个链表，是用过遍历头指针来进行的。 这里没有特别的设置一个头指针，因为当指针指向整个链表 L 时，该指针的实现效果就是头指针。 不带头结点的单链表，即单链表的第一个结点就存储数据，头指针也指向第一个结点；带头结点的单链表，第一个结点是头结点，不存储数据，从头结点的 next 开始存储，头指针可以从头结点的 next 开始遍历。 对于结点的前插操作，找到对应位置的结点，设新结点为该节点的后继结点，将该结点的 data 后移至新结点的 d
无头节点单链表基本操作（头插、尾插、删除）————附完整代码
韩江雪de 小屋
11-09 2355
文章目录0 背景1 创建链表操作1.1 头插法1.2 尾插法2 删除元素3 完整示例 0 背景 一般使用单链表多使用带头节点的单链表，好处是： 1 对表首操作和在表的其他位置的操作一致，无需特殊处理； 2 判链表是否为空时，头指针都是指向头节点的非空指针，空表和非空表的处理也得到统一。【如果不带头节点时，空链表的头指针为NULL】 1 创建链表操作 存储结构定义： typedef struct LNode{ int data;//数据 struct LNode* next;//指针域 }
实现无头节点的单链表
nefss_的博客
07-08 303
class Node{ public int data; public Node next; public Node(int data){ this.data=data; } } public class MyLinkedList{ public Node head; public void addFirst(int data){ Node node=new node(data); //判断是否是空链表 if(this.head==null){ this.head=node; }else{ node.
单链表之无头链表(C语言版)
ShiXiAoLaNga的博客
08-07 658
单链表之无头链表 1. 定义节点结构 NODE为 节点类型 LPNODE 为节点指针类型 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> //定义节点结构 typedef struct Node_tlg{ int data; //数据域 struct Node_tlg* next; //指针域 }NODE,*LPNODE; 2. 定义链表结构 size
【数据结构】单链表（无头单向非循环链表）的实现
m0_52347974的博客
01-06 405
单链表
无头节点单链表和有头节点单链表
CrazyQiQi的博客
09-15 2342
无头结点和有头节点 无头结点：第一个节点既有数据域又有指针域。 但是通过一个 pHead 指针指向和标记第一个节点 有头节点：在第一个节点之前加入一个头节点，头节点的 data 域可以设置表长等相关信息，但也可以不设置。头节点的指针域指向第一个节点。 引入头节点的优势 对第一个位置元素的操作（添加、删除）更加方便 若使用头结点，则第1个位置的插入和删除都是对p—>next进行操作，...
单链表（无头结点）（C/C++）
沉默安的博客
08-04 1122
带头结点与不带头结点的单链表，在进行操作时有哪些区别呢？ 当对单链表的表首元素进行删除或插入操作时，要进行区别处理，无头结点的单链表进行头指针的更新。 带头结点的单链表，无论单链表是否为空链表，头指针都指向头结点。不带头结点的单链表，当单链表为非空链表时，头指针指向链表第一个结点(LNode)，当单链表为空链表时，头指针指向空（NULL）。 //不带头结点的链表 #include<stdio.h> #include<stdlib.h> typedef int Elemtype;
无头单链表及其操作.zip
02-20
无头单链表是一种特殊的链表类型，其区别于常规的单链表在于它没有明显的头部节点。在大多数链表实现中，头部节点通常包含一个指向第一个元素的指针，而在无头链表中，我们并不直接保存这个引用。这增加了操作链表的...
无头结点的单链表的c算法的实现
11-02
无头结点的单链表指的是链表的结构不包括一个额外的头结点，而是直接从第一个数据节点开始。 在C语言中，首先需要定义链表节点的数据结构。通常，这会涉及到创建一个结构体类型，包含数据域和指针域： ```c ...
Python实现-无头单向非循环链表
12-22
无头单向非循环链表链表 无头单向非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等 无头单向非循环链表 对于任意一个数据元素a(i)来说，储存本身的...
算法复杂度＜数据结构 C版＞
最新发布
hukang的博客
07-13 1638
简单来说算法复杂度是用来衡量一个算法的优劣的，一个程序在运行时，对运行时间和运行空间有要求，即时间复杂度和空间复杂度。
数据结构—链式二叉树-C语言
h_number_1的博客
07-11 897
上述内容，即是我个人对数据结构-链式二叉树-搜索二叉树-C语言的个人见解以及自我实现。若有大佬发现哪里有问题可以私信或评论指教一下我这个小萌新。
数据结构（Java）：队列&Queue集合&力扣面试OJ题
2401_83595513的博客
07-12 2403
队列、Queue、Deque、循环队列、队列OJ题
数据结构之单链表在不带标准头的情况下C，C#，C++分别怎么实现？
qq_35320456的博客
07-12 439
数据结构是计算机科学中非常重要的一部分，它帮助我们理解和操作数据。单链表是数据结构中的一种基本类型，它由一系列节点组成，每个节点包含数据域和指向列表中下一个节点的指针。在本文中，我们将详细讨论单链表的概念、操作和如何在几种常见的编程语言中实现它。
无头节点的单链表代码
08-18
以下是一个示例无头节点的单链表代码，包括节点的定义、插入、删除、查找和输出操作： ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next class LinkedList: ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值