C语言单向链表的经典算法

1.分割链表
2.移除链表元素
3.反转链表
4.合并两个有序链表
5.链表的中间结点
6.环形链表的约瑟夫问题

1.分割链表:

1.思路:创建新链表,小链表和大链表。如图

代码如下

cs 复制代码
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x){
if(head == NULL)
return head;
ListNode* lessHead, *lessTail;
ListNode* greaterHead, *greaterTail;
lessHead = lessTail = (ListNode*)malloc(sizeof(ListNode));
greaterHead = greaterTail = (ListNode*)malloc(sizeof(ListNode));
ListNode* pcur = head;
while(pcur)
{
    if(pcur->val < x)
    {//尾插到小链表中
        lessTail->next = pcur;
        lessTail = lessTail->next;

    }else{
    //尾插到大链表中
    greaterTail->next = pcur;
    greaterTail = greaterTail->next;
    }
    pcur = pcur->next;
}
//修改大链表的指针指向
greaterTail->next = NULL;//不修改会出现死循环
//小链表的尾节点和大链表第一个有效节点连接
lessTail->next = greaterHead->next;
ListNode* ret = lessHead->next;
free(greaterHead);
free(lessHead);
greaterHead = lessHead = NULL;
return ret;
}

2.移除链表元素 :思路:链表中不为val则尾插到新链表中。(最后新链表应该置为空)指针pcur往后移动pphead不动。刚开始新链表为空,注意每次尾插都要,把该节点定位尾节点。

代码:

cs 复制代码
#define _CRT_SECURE_NO_WARNINGS 1
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
typedef struct  ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) {
    ListNode* newhead = NULL;
    ListNode* newtail = NULL;
    //遍历原链表
    ListNode* pcur = head;
    while (pcur)
    {
        if (pcur->val != val)
        {
            //创建新链表
            if (newhead == NULL)
            {
                //新链表为空
                newhead = newtail = pcur;
            }
            else
            {
                //新链表不为空相当于尾插
                newtail->next = pcur;
                newtail = newtail->next;
            }
        }
        pcur = pcur->next;
    }
    if (newtail)
        newtail->next = NULL;

    return newhead;
}

3.反转链表: 思路:创建三个指针完成原链表的翻转

看这个视频:

反转链表

代码:

cs 复制代码
#define _CRT_SECURE_NO_WARNINGS 1
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head) {
    if (head == NULL)
    {
        return head;
    }
    ListNode* n1, * n2, * n3;
    n2 = head;
    n1 = NULL;
    n3 = n2->next;
    while (n2)
    {
        n2->next = n1;
        n1 = n2;
        n2 = n3;
        if (n3)
            n3 = n3->next;
    }
    return n1;
}

4.合并两个有序链表: 创建新的空链表,遍历原链表,将节点小的链表拿到新链表中尾插。(遍历结果有两种情况,l1为空或者l2为空)。

代码:

cs 复制代码
#define _CRT_SECURE_NO_WARNINGS 1
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    //判空
    if (list1 == NULL)
    {
        return list2;
    }
    if (list2 == NULL)
    {
        return list1;
    }
    ListNode* l1 = list1;
    ListNode* l2 = list2;
    ListNode* newtail, * newhead;
    newhead = newtail = (ListNode*)malloc(sizeof(ListNode));
    while (l1 && l2)
    {
        if (l1->val < l2->val)
        {
            //l1拿下来尾插
            newtail->next = l1;
            newtail = newtail->next;
            l1 = l1->next;
        }
        else {
            //l2尾插
            newtail->next = l2;
            newtail = newtail->next;
            l2 = l2->next;
        }
    }
    //跳出循环时有两种情况,l1先为空 或 l2先为空
    if (l2)
    {
        newtail->next = l2;
    }
    if (l1)
    {
        newtail->next = l1;
    }

    ListNode* ret = newhead->next;
    free(newhead);
    newhead = NULL;
    return ret;
}

5.链表的中间结点: 思路:这里可以定义两个快慢指针,快指针 一次走两步,慢指针一次走两步(这里也要注意条件不能交换位置,两种情况都保证的情况下先满足小的,链表为偶数时fast最后一次会直接走到空,下一步就会报错)

代码:

cs 复制代码
#define _CRT_SECURE_NO_WARNINGS 1
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head) {
    ListNode* slow = head;
    ListNode* fast = head;
    while (fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

6.环形链表的约瑟夫问题

1.关于这个算法题的小故事:著名的Josephus问题 据说著名犹太 Josephus有过以下的故事:在罗⻢⼈占领乔塔帕特后,39 个犹太⼈与 Josephus及他的朋友躲到⼀个洞中,39个犹太⼈决定宁愿死也不要被⼈抓到,于是决定了⼀个⾃杀 ⽅式,41个⼈排成⼀个圆圈,由第1个⼈开始报数,每报数到第3⼈该⼈就必须⾃杀,然后再由下⼀ 个重新报数,直到所有⼈都⾃杀⾝亡为⽌。历史学家 然⽽Josephus 和他的朋友并不想遵从,Josephus要他的朋友先假装遵从,他将朋友与⾃⼰安排在 第16个与第31个位置,于是逃过了这场死亡游戏。

2.思路:第一步创建环形链表**(创建之前要先创建一个节点,可以用函数封装起来)**,第二步计数(又分为销毁链表和不销毁链表)下面我画了图以视频形式呈现

环形链表的约瑟夫问题

相关推荐
wuqingshun3141596 分钟前
蓝桥杯 11. 打印大X
数据结构·算法·职场和发展·蓝桥杯·深度优先
Blossom.1181 小时前
量子网络:构建未来通信的超高速“高速公路”
网络·opencv·算法·安全·机器学习·密码学·量子计算
A林玖1 小时前
【机器学习】朴素贝叶斯
人工智能·算法·机器学习
六边形战士DONK1 小时前
神经网络基础[损失函数,bp算法,梯度下降算法 ]
人工智能·神经网络·算法
wuqingshun3141591 小时前
蓝桥杯 2. 确定字符串是否是另一个的排列
数据结构·c++·算法·职场和发展·蓝桥杯
小刘|1 小时前
JVM 自动内存管理
java·jvm·算法
小羊不会c++吗(黑客小羊)2 小时前
c++头文件知识
算法
拓端研究室TRL2 小时前
PyMC+AI提示词贝叶斯项目反应IRT理论Rasch分析篮球比赛官方数据:球员能力与位置层级结构研究
大数据·人工智能·python·算法·机器学习
CoovallyAIHub3 小时前
Vision Transformers与卷积神经网络详细训练对比(附代码)
深度学习·算法·计算机视觉
地平线开发者3 小时前
征程 6 逆向自证hbm与bc一致性
算法·自动驾驶