【C语言】单链表常见算法

最新推荐文章于 2024-07-24 10:10:28 发布
最新推荐文章于 2024-07-24 10:10:28 发布
阅读量80 收藏
点赞数
文章标签： c语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55582076/article/details/134889688
版权 
#include <stdio.h>
#include <stdlib.h>

typedef struct LNode
{
    int data;
    struct LNode *next;
} LNode, *Linklist;

// 单链表的遍历
void LinklistPrint(Linklist L)
{
    Linklist p = L->next;
    while (p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
}

// 单链表的按位查找
Linklist Search_by_pos(Linklist L, int pos)
{
    if (pos < 1)
        return NULL;
    int cur = 1;
    Linklist p = L->next;
    while (p != NULL && cur < pos)
    {
        p = p->next;
    }
    return p;
}

// 单链表的按值查找
Linklist Search_by_num(Linklist L, int e)
{
    Linklist p = L->next;
    while (p != NULL && p->data != e)
    {
        p = p->next;
    }
    return p;
}

// 头插法建立单链表
Linklist CreateHeadLinklist(Linklist *L)
{
    (*L) = (Linklist)malloc(sizeof(LNode)); // 带头结点
    (*L)->next = NULL;
    Linklist temp;
    int e;
    scanf("%d", &e);
    while (e != -1)
    {
        temp = (Linklist)malloc(sizeof(LNode));
        temp->data = e;
        temp->next = (*L)->next;
        (*L)->next = temp;
        scanf("%d", &e);
    }
    return (*L);
}

// 尾插法建立单链表
Linklist CreateTailLinklist(Linklist *L)
{
    (*L) = (Linklist)malloc(sizeof(LNode));
    (*L)->next = NULL;
    Linklist r = (*L), temp;
    int e;
    scanf("%d", &e);
    while (e != -1)
    {
        temp = (Linklist)malloc(sizeof(LNode));
        temp->data = e;
        temp->next = NULL;
        r->next = temp;
        r = temp;
        scanf("%d", &e);
    }
    r->next = NULL;
    return (*L);
}

// 单链表原地逆置
void Reverse(Linklist *L)
{
    Linklist p = (*L)->next;
    Linklist r;
    (*L)->next = NULL;
    while (p != NULL)
    {
        r = p->next;
        p->next = (*L)->next;
        (*L)->next = p;
        p = r;
    }
}

// 将单链表A分解成2个带头结点的单链表A,B,
// 且A中含原链表奇数项元素，B表含原表偶数项元素，相对顺序不变,返回B表
Linklist Divide_A_and_B(Linklist *A)
{
    Linklist B = (Linklist)malloc(sizeof(LNode));
    B->next = NULL;
    Linklist ra = (*A);
    Linklist rb = B;
    Linklist p = (*A)->next;
    (*A)->next = NULL;
    while (p != NULL)
    {
        ra->next = p;
        ra = p;
        p = p->next;
        if (p != NULL)
        {
            rb->next = p;
            rb = p;
            p = p->next;
        }
    }
    ra->next = NULL;
    rb->next = NULL;
    return B;
}

// 将A={a1,b1,a2,b2....,an,bn}拆分成2个带头结点的单链表A,B
// 使得A={a1,a2,...,an},B={bn,...,b2,b1};
Linklist Divide_A_and_B2(Linklist *A)
{
    Linklist p = (*A)->next;
    Linklist ra = (*A);
    Linklist B = (Linklist)malloc(sizeof(LNode));
    B->next = NULL;
    Linklist rb;
    while (p != NULL)
    {
        ra->next = p;
        ra = p;
        p = p->next;
        if (p != NULL)
        {
            rb = p;
            p = p->next;
            rb->next = B->next;
            B->next = rb;
        }
    }
    ra->next = NULL;
    return B;
}
// 将单链表A，B有序合并成1个A
void Merge(Linklist *A, Linklist *B)
{
    Linklist p = (*A)->next;
    Linklist q = (*B)->next;
    Linklist r;
    (*A)->next = NULL;
    while (p != NULL && q != NULL)
    {
        if (p->data < q->data)
        {
            r = p->next;
            p->next = (*A)->next;
            (*A)->next = p;
            p = r;
        }
        else
        {
            r = q->next;
            q->next = (*A)->next;
            (*A)->next = q;
            q = r;
        }
    }
    if (p != NULL)
    {
        p = q;
    }
    while (p != NULL)
    {
        r = p->next;
        p->next = (*A)->next;
        (*A)->next = p;
        p = r;
    }
    free(B);
}

// 找到链表最小值并删除
void FindMin(Linklist *L)
{
    Linklist pre = (*L), p = (*L)->next;
    Linklist minpre = pre, minp = p;
    while (p != NULL)
    {
        if (p->data < minp->data)
        {
            minp = p;
            minpre = pre;
        }
        pre = p;
        p = p->next;
    }
    minpre->next = minp->next;
    free(minp);
}

// 删除单链表中所有值为x的结点
void Delete_x(Linklist *L, int x)
{
    Linklist pre = *L;
    Linklist p = pre->next;
    while (p != NULL)
    {
        if (p->data == x)
        {
            pre->next = p->next;
            free(p);
            p = pre->next;
        }
        else
        {
            pre = p;
            p = p->next;
        }
    }
}
// 删除单链表中所有值介于两个给定值之间的结点
void Delete_between_x_t(Linklist *L, int x, int t)
{
    Linklist pre = (*L);
    Linklist p = pre->next;
    while (p != NULL)
    {
        if (p->data <= t && p->data >= x)
        {
            pre->next = p->next;
            free(p);
            p = pre->next;
        }
        else
        {
            pre = p;
            p = p->next;
        }
    }
}
// 删除一个有序单链表中值重复的结点
void Delete_Repeat(Linklist *L)
{
    Linklist pre = (*L)->next;
    Linklist p = pre->next;
    while (p != NULL)
    {
        if (p->data == pre->data)
        {
            pre->next = p->next;
            free(p);
            p = pre->next;
        }
        else
        {
            pre = p;
            p = p->next;
        }
    }
}
// 找出2个递增有序的单链表中值相同的结点，生成单链表c
Linklist FindSameAB(Linklist *A, Linklist *B)
{
    Linklist p = (*A)->next;
    Linklist q = (*B)->next;
    Linklist C = (Linklist)malloc(sizeof(LNode));
    Linklist rc = C, temp;
    while (p != NULL && q != NULL)
    {
        if (p->data < q->data)
        {
            p = p->next;
        }
        else if (p->data > q->data)
        {
            q = q->next;
        }
        else
        {
            temp = (Linklist)malloc(sizeof(LNode));
            temp->data = p->data;
            temp->next = NULL;
            rc->next = temp;
            rc = temp;
        }
    }
    return C;
}

// 求2个递增有序的单链表的交集并放入A中，释放其他空间
Linklist FindCro(Linklist *A, Linklist *B)
{
    Linklist p = (*A)->next;
    Linklist q = (*B)->next;
    Linklist ra = (*A);
    Linklist temp;
    while (p != NULL && q != NULL)
    {
        if (p->data < q->data)
        {
            temp = p;
            p = p->next;
            free(temp);
        }
        else if (p->data > q->data)
        {
            temp = q;
            q = q->next;
            free(temp);
        }
        else
        {
            ra->next = p;
            ra = p;
            p = p->next;
            temp = q;
            q = q->next;
            free(q);
        }
    }
    if (q != NULL)
    {
        p = q;
    }
    while (p != NULL)
    {
        temp = p;
        p = p->next;
        free(temp);
    }
}

// 有一头指针为head的单链表，按递增次序输出结点，并删除
void PrintLinklist(Linklist *head)
{
    while ((*head)->next != NULL)
    {
        Linklist pre = (*head);
        Linklist minpre = pre;
        Linklist p = pre->next;
        Linklist minp = p;
        while (p != NULL)
        {
            if (p->data < minp->data)
            {
                minp = p;
                minpre = pre;
            }
            pre = p;
            p = p->next;
        }
        minpre->next = minp->next;
        printf("%d", minp->data);
        free(p);
    }
}

// 判断B链表是否是A链表的连续子序列
int JudgeBA(Linklist A, Linklist B)
{
    Linklist p = A->next;
    Linklist q = B->next;
    Linklist pre = A->next;
    while (p != NULL && q != NULL)
    {
        if (p->data == q->data)
        {
            p = p->next;
            q = q->next;
        }
        else
        {
            p = pre->next;
            pre = p;
            q = B->next;
        }
    }
    return (q == NULL) ? 1 : 0;
}

// 判断单链表是否有环
int IsLoop(Linklist L)
{
    Linklist fast = L->next;
    Linklist slow = L->next;
    while (fast != NULL && fast->next != NULL)
    {
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow)
        {
            return 1;
        }
    }
    return 0;
}
// 链接2个不带头结点的循环单链表,将h2链接到h1后
Linklist ConbLink(Linklist *h1, Linklist *h2)
{
    Linklist rh1 = (*h1), rh2 = (*h2);
    while (rh1->next != h1)
    {
        rh1 = rh1->next;
    }
    while (rh2->next != h2)
    {
        rh2 = rh2->next;
    }
    rh1->next = h2;
    rh2->next = h1;
    return h1;
}
// 递增次序输出循环单链表的各结点并删除，直至单链表为空，再删除头结点
void Delete_print(Linklist *L)
{

    while ((*L)->next != (*L))
    {
        Linklist p = (*L)->next;
        Linklist pre = (*L);
        Linklist minpre = (*L), minp = (*L)->next;
        while (p->next != (*L))
        {
            if (p->data < minp->data)
            {
                minp = p;
                minpre = pre;
            }
            else
            {
                pre = p;
                p = p->next;
            }
        }
        printf("%d", minp->data);
        minpre->next = minp->next;
        free(minp);
    }
    free(*L);
}

// 判断带头结点的循环双链表L是否对称
typedef struct DNode
{
    int data;
    struct DNode *prior, *next;
} DNode, *DLinklist;

int Fuc(DLinklist L)
{
    DNode *p = L->next, *q = L->prior;
    while (p != q && q->next != p)
    {
        if (p->data == q->data)
        {
            p = p->next;
            q = q->prior;
        }
        else
        {
            return 0;
        }
    }
    return 1;
}

红尘各半
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【C语言】单链表的排序
ZDF0414的专栏
11-26 5689
void BubbleList(PLinkList *pplist) {            PLinkList prev,next,end ;           end= NULL;            while(end!=(*pplist )->next)           {                    prev=* pplist;
用数组实现的单链表[C语言]
kevin@hbstu.net
05-08 6310
#include #include #define MAXSIZE 10 // 存储空间最大存储10个元素 #define SUCCESS 1 #define ERROR 0 typedef int ElementType; typedef int Status; typedef struct { ElementType data[MAXSIZE]; int len
C语言实现单链表的查询
专业^团队的博客
04-07 2014
一.单链表按位查找 //单链表的按位查找 LNode *GetElem(LinkList L, int i) { if (i < 1) return false; LNode* p; int j = 0; p = L; while (p != NULL && j < i) {//循环找到第i个结点 p = p->next; j++; } return p; } 二.单链表的按值查找 //单链表按值查找 LNode *Locate(.
单链表的查找（C语言）
像鱼的博客
05-03 4313
这段代码里写了两种查找，按位置查找，按值查找。 再看代码前有一点瑕疵需要记录。 就是这两个警告。警告的意思就是代码里并不是每一个判断语句里都有返回值。找到警告出现的位置。 就是我写的两个查找的函数里，我为了能够展示出效果来所以写了printf输出语句。 所以为了看到效果，我下面的运行结果图并没有注释这里，所以警告还存在，但是不影响结果。 接下来，为了代码的严谨，我将上面输出语句注释了。修改如下（有两种方案）： 方案一：函数类型是 int, 结束语句就是 return 1; 方案二
单链表按值查找结点（纯C语言小白版本）
qq_60567426的博客
08-30 477
【代码】单链表按值查找结点（纯C语言小白版本）
单链表的查找(按值查找、按位查找)(数据结构与算法)
AII_IIA的博客
11-03 4595
什么是单链表？单链表是一种常见的链式数据结构，用于存储和操作数据元素的集合。它由一系列的节点组成，每个节点包含两个部分：数据域和指针域。单链表的每个节点包含了存储数据的数据域，以及指向下一个节点的指针域。通过这些指针域，节点之间可以按顺序连接起来，形成一个链式结构。链表的最后一个节点通常指向一个特殊的空节点（NULL或nullptr），表示链表的结束。相比于数组，链表的一大优势是它的动态性。在链表中，节点的添加、删除可以通过修改指针的指向来完成，不需要像数组那样进行元素的移动。
C语言链表按值查询
weixin_46073538的博客
03-01 1377
#include<stdio.h> #include<math.h> // #define 定义一个标识符来表示一个常量 #define OK 1 #define ERROR -1 // typedef 关键字来定义自己习惯的数据类型名称 typedef int Status ; typedef int ElemType ; // struct 结构体 typedef struct Lnode{ ElemType data; /*数
C语言单链表的实现
09-02
以上就是C语言中单链表实现的基本知识，包括了链表的创建、插入、删除、查找、排序、合并等常见操作。理解这些概念和实现对于学习数据结构和算法至关重要。通过实践这些函数，开发者可以更好地掌握链表的特性，并在...
C语言实现单链表逆序与逆序输出实例
09-04
在C语言中，单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。本篇将详细讲解如何实现单链表的逆序以及逆序输出。 首先，我们要理解逆序输出的概念。逆序...
C语言单链表.pdf
09-27
总之，这个C语言单链表实现涵盖了链表的基本操作，是学习数据结构和算法的好例子。理解并能够编写这样的代码对于任何想深入学习C语言和数据结构的人来说都是至关重要的。通过实践这些操作，可以更好地掌握链表的工作...
C语言实现链表，创建、插入、查找、删除、遍历等基本操作
09-13
C与语言实现链表的创建、插入（头插法、尾插法）、遍历、查找、删除操作
C语言 单链表的简单操作
09-11
在IT领域，特别是编程，...总的来说，理解和熟练运用单链表是成为一名优秀的C语言程序员的基础，它在各种复杂数据结构和算法中都有应用。通过不断练习和实践，可以逐步掌握这些技能，为后续的编程学习打下坚实的基础。
用C语言实现单链表的各种操作(一)
09-05
这些基本操作涵盖了对单链表的常见需求，如创建、销毁、检查状态、查询长度、查找元素以及访问相邻元素。然而，这里没有提到单链表的逆置、合并或找到中间节点等高级操作。这些操作通常需要更复杂的算法，比如反转...
纯C语言完整代码操作单链表(初始化、插入、删除、查找...)
qq_44697268的博客
08-26 1093
C语言操作单链表
数据结构07——单链表查找算法
weixin_45658431的博客
09-20 587
从链表的头指针出发，顺着next域逐个结点往下搜索，直到查找到与要搜索的值相等的数据为止。3）如果查遍整个链表都没有找到其值和e相等的元素，则返回0或“NULL”2）如果找到一个值与e相等的数据元素，则返回其在链表中的地址。1）从第一个结点起，依次和e比较。
数据结构--单链表的查找
m0_60593173的博客
06-27 1738
均以带头结点链表为例:按位查找操作。获取表L中第i个位置的元素的值。:按值查找操作。在表L中查找具有给定关键字值的元素。
【数据结构】—C语言实现单链表（超详细！）
B1ue还在专注
08-02 4201
这是作者对于单链表学习历程的记录，C语言做到了单链表的实现!很详细，细节都很到位！
单链表的按值查找（输入结点数据域输出结点的位置）数据结构C语言
qq_44208167的博客
03-04 7539
单链表的按值查找（输入结点数据域输出结点的位置）数据结构C语言 代码段基本上每句都有注释，如有困惑，欢迎留言。博主看到就会回复 #include<stdio.h> #include<stdlib.h> #define NULL 0 //定义结点结构体类型 typedef struct LNode{ int data; //定义数据域 struct LNode * next; //定义指针域 }LNode,*LinkList; //声明函数 LinkList Init
2024-07-24 Linux C語言使用inotify进行文件变化检测
最新发布
海月汐辰
07-24 231
inotify。
c语言单链表的创建，插入、删除、查找和打印算法
03-27
下面是C语言单链表的创建，插入、删除、查找和打印算法。 1. 创建单链表 单链表的创建过程分为两步：创建头结点和添加数据节点。 ```c struct Node { int data; // 数据域 struct Node* next; // 指针域 }; //...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值