链表相关算法

已于 2022-08-24 20:25:28 修改
阅读量1k 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： java 算法 链表
于 2022-04-29 20:09:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_48928539/article/details/124503258
版权

文章目录

1 带环的链表

1-1 判断链表是否有环

🚀 题目链接：https://leetcode-cn.com/problems/linked-list-cycle/
🚀 代码

public boolean hasCycle(ListNode head) {
    if (null == head) {
        return false;
    }
    
    // 快慢指针
    ListNode fast = head, slow = head;
    while (null != fast && null != fast.next && null != slow) {
        // 快指针移动两步
        fast = fast.next.next;
        // 慢指针移动一步
        slow = slow.next;
        
        if (fast == slow) {
            // 两个指针相遇，说明有环
            return true;
        }
    }
    return false;
}

1-2 求带环链表的环入口

🚀 题目链接：https://www.acwing.com/problem/content/86/
🚀 代码

public ListNode entryNodeOfLoop(ListNode head) {
    if (null == head) {
        return null;
    }

    // 快慢指针
    ListNode fast = head, slow = head;
    while (null != fast && null != fast.next && null != slow) {
        fast = fast.next.next;
        slow = slow.next;

        if (fast == slow) {
            // 快慢指针相遇，再从头移动
            ListNode temp = head;
            while (null != temp && null != slow) {
                // 两个同步指针一起移动
                temp = temp.next;
                slow = slow.next;

                if (temp == slow) {
                    // 同步指针相遇的位置就是环的起点
                    return slow;
                }
            }
        }
    }
    // 找不到环，返回null
    return null;
}

2 删除指定节点/元素

2-1 单链表删除，给出头节点

public void deleteNode(ListNode head, ListNode target) {
    if (null == head) {
        return ;
    }
    // 如果目标值就是头节点，则直接返回下一个节点即可
    if (head == target) {
        return head.next;
    }

    ListNode p = head;
    // 头节点是目标值已排除，直接从next开始，方便删除
    while (null != p.next) {
        if (p.next == target) {
            p.next = p.next.next;
            return ;
        }
        p = p.next;
    }
}

2-2 单链表删除，只给出待删除的节点

🚀 题目链接：https://www.acwing.com/problem/content/85/
🚀 代码

// 前提：不知道前一个节点、不需要删除整个节点对象（地址）、待删除节点不是尾节点
public void deleteNode(ListNode node) {
    // 记住下一个节点
    ListNode nextNode = node.next;

    // 将后面的节点值复制给当前节点
    node.val = nextNode.val;

    // 再删除下一个节点即可（当前节点指向下下一个节点）
    node.next = nextNode.next;
}

2-3 双向链表删除

public void deleteNode(DoubleListNode node) {
    // 前节点的后节点指向当前节点的后节点
    node.pre.next = node.next;
    // 后节点的前节点指向当前节点的前节点
    node.next.pre = node.pre;
}

2-4 删除重复元素，保留1个重复元素

🚀 题目链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-list/
🚀 代码

public ListNode deleteDuplicates(ListNode head) {
    if (null == head) {
        return null;
    }

    ListNode p = head;
    while (null != p && null != p.next) {
        if (p.val == p.next.val) {
            // 当前节点与下一个节点值相同，直接删除下一个节点，不移动p
            p.next = p.next.next;
        } else {
            // 不相同，正常移动p
            p = p.next;
        }
    }
    return head;
}

2-5 删除重复元素，不保留重复元素

🚀 题目链接：https://www.acwing.com/problem/content/27/
🚀 代码

public ListNode deleteDuplicates(ListNode head) {
    if (null == head) {
        return null;
    }

    // 创建一个虚拟头节点，这里初始化的val值不能与原链表的头节点值相等
    ListNode headPre = new ListNode(-1);
    headPre.next = head;

    ListNode p = headPre;
    while (null != p.next) {
        // 遍历重复元素
        ListNode q = p.next;
        while (null != q && p.next.val == q.val) {
            // 依次与p.next比较，有重复元素就继续移动
            q = q.next;
        }

        if (p.next.next == q) {
            // 如果q只移动了一格，说明没有与p.next重复的元素
            // p正常移动
            p = p.next;
        } else {
            // 如果q移动了不止一格，则存在重复元素，直接删除
            p.next = q;
        }
    }

    // 返回虚拟头节点的下一个节点
    return headPre.next;
}

3 反转链表

3-1 整条链反转

🚀 题目链接：https://www.acwing.com/problem/content/33/
🚀 代码

  • 迭代版本

    public ListNode reverseList(ListNode head) {
    if (null == head) {
        return null;
    }

    // 前后指针
    ListNode pre = null, curr = head;
    while (null != curr) {
        // 头指针先移动
        head = head.next;
        // 当前指针下一个节点指向pre
        curr.next = pre;
        // 修改pre和curr
        pre = curr;
        curr = head;
    }

    // 最后返回pre，不是curr/head
    return pre;
}

  • 递归版本

    public ListNode reverseList(ListNode head) {
    if (null == head) {
        return null;
    }

    // 递归
    return dfs(null, head);
}

// 递归反转链表
private ListNode dfs(ListNode pre, ListNode curr) {
    if (null == curr) {
        return pre;
    }

    // 记住下一个节点
    ListNode nextNode = curr.next;
    // 修改当前节点下一个节点为前节点
    curr.next = pre;

    // 递归继续修改下一个节点
    return dfs(curr, nextNode);
}

3-2 在指定区间内反转

🚀 题目链接：https://www.nowcoder.com/practice/b58434e200a648c589ca2063f1faf58c
🚀 代码

// 只反转[m,n]区间的链表，链表节点索引从1开始
public ListNode reverseBetween(ListNode head, int m, int n) {
    if (null == head) {
        return null;
    }
    
    // 因为反转的可能是head，所以需要虚拟头节点
    ListNode headPre = new ListNode(-1, head);
    // 辅助指针，pre指向m-1位置的节点，p指向要反转的链表头节点
	ListNode pre = headPre, p = head;
    // 记住(m,n)之间的节点数（不包括m和n）
    int diff = n - m;
    
    // 移动到第m个节点，如果m=1就不用移了
    while (--m > 0) {
        pre = p;
        p = p.next;
    }
    
    // 依次反转[m,n]之间的节点
    while (diff-- > 0) {
        // 辅助指针，记住p.next，将p和temp两个节点反转
        ListNode temp = p.next;
        // p下一个节点指向temp的下一个节点
        p.next = temp.next;
        // temp下一个节点再指向pre的下一个节点（pre始终在m-1的位置）
        // 注意这里不能写temp.next = p，因为p是一直往后移动，pre始终在m-1的位置，故pre后面不一定是p
        temp.next = pre.next;
        // pre的下一个节点指向temp，完成p和temp的反转
        pre.next = temp;
    }
    
    return headPre.next;
}

4 链表排序

相关：常见排序算法

4-1 合并两个有序链表

🚀 题目链接：https://leetcode-cn.com/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/comments/
🚀 代码

public ListNode merge(ListNode l1, ListNode l2) {
    if (null == l1 && null == l2) {
        return null;
    }

    // 分别指向两个链表的指针
    ListNode p1 = l1, p2 = l2;
    // 创建新的链表
    ListNode newHead = new ListNode(-1), p = newHead;

    // 一次归并排序
    while (null != p1 && null != p2) {
        if (p1.val < p2.val) {
            p.next = p1;
            p1 = p1.next;
        } else {
            p.next = p2;
            p2 = p2.next;
        }

        p = p.next;
    }

    if (null != p1) {
        p.next = p1;
    } else {
        p.next = p2;
    }

    return newHead.next;
}

4-2 排序链表

🚀 题目链接：https://leetcode-cn.com/problems/sort-list/
🚀 代码

PS：这里涉及的归并排序merge()用上面👆的就行

  • 迭代版本
    public ListNode sortList(ListNode head) {
    if (null == head) {
        return null;
    }
    
    // 先求出链表长度
    int len = 0;
    ListNode h = head;
    while (null != h) {
        h = h.next;
        len++;
    }
    
    // 虚拟头节点，指向head
    ListNode headPre = new ListNode(-1, head);
    
    // 外循环subLen逐渐倍增，直到等于len
    for (int subLen = 1;subLen < len;subLen <<= 1) {
        // 记住此时虚拟节点，并初始化curr（初始化指向第一个节点）
        ListNode pre = headPre, curr = headPre.next;
        while (null != curr) {
            // 记住当前curr为子链表①的头节点
            ListNode head1 = curr;
            
            // 移动subLen-1个位置
            for (int i = 1;i < subLen && null != curr.next;i++) {
                curr = curr.next;
            }
            
            // 从此时的curr断开，curr下一个节点作为子链表②的头节点
            // 前面循环条件确保了curr不为null，所以这里可以直接写head2 = curr.next
            ListNode head2 = curr.next;
            curr.next = null;
            curr = head2;
            
            // 再移动subLen-1个位置
            for (int i = 1;i < subLen && null != curr && null != curr.next;i++) {
                curr = curr.next;
            }
            
            // 再从此时的curr断开，curr下一个节点作为新头节点
            // 这里不能直接将curr.next赋值给newHead，因为curr可能为null
            ListNode newHead = null;
            if (null != curr) {
                newHead = curr.next;
                curr.next = null;
            }
            
            // 合并排序两个子链表，合并后的链表拼接到pre后面
            pre.next = merge(head1, head2);
           	// pre再移动到最后一个节点
            while (null != pre.next) {
                pre = pre.next;
            }
       
            // 更新下一个curr
            curr = newHead;
        }
    }
    
    return headPre.next;
}
  • 递归版本
    public ListNode sortList(ListNode head) {
    if (null == head || null == head.next) {
        // 如果头节点为null或只有一个节点，要返回这个head，不能返回null
        return head;
    }

    // 快慢指针将链表等分
    ListNode fast = head, slow = head;
    // 注意这里结束条件是fast.next和fast.next.next
    /// 保证fast不会移动到null，也就是保证fast不会移动到链表外面
    // 如果fast移动到链表外，slow指向的节点就不是中间那个节点
    while (null != fast.next && null != fast.next.next) {
        fast = fast.next.next;
        slow = slow.next;
    }

    // 断开两条长度一样的链
    ListNode head2 = slow.next;
    slow.next = null;

    // 递归返回排序后的链表，然后再合并
    return merge(sortList(head), sortList(head2));
}
链表综合算法设计
bao_libra的专栏
05-31 1766
#include #define MaxSize 100 typedef struct node { int no; //职工号 char name[10]; //姓名 int depno; //部门号 float salary; //工资号 int pno; //职工号指针 int pdepno;
leetcode算法题-链表-设计链表
MarkusZhang的博客
02-02 459
题目描述 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则...
链表综合算法设计（c++数据结构）
2201_75440128的博客
10-01 1179
【代码】链表综合算法设计（c++数据结构）
链表相关算法汇总（详细）
泛泛之素
06-06 8184
链表基础知识 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(log
链表相关算法.rar
09-22
在面试中，链表相关的题目往往被用作考察应聘者基础编程能力与逻辑思维的第一步，尤其是链表反转问题，这是一个经典的算法题，能够体现程序员对指针操作的理解和对递归或迭代解法的掌握。 链表主要由节点构成，每个...
【算法】链表相关算法题
最新发布
m0_51064412的博客
12-02 1007
同时遍历两个链表，取 val 小的那个节点尾插到新链表中。
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
链表经典算法题
Frank的博客
10-03 1870
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
c语言链表综合算法设计
01-06
设有一个职工文件emp.dat，每个职工记录包括职工编号（no）、姓名（name）、部门号（depno）和工资数（salary）信息。设计一个程序完成如下功能： （1） 从emp.dat文件中读出职工记录，并建立一个带头节点的单链表L； （2） 输入一个职工记录； （3） 显示所有职工记录； （4） 按编号no对所有职工记录进行递增排序； （5） 按部门号depno对所有职工记录进行递增排序； （6） 按工资数salary对所有职工记录进行递增排序； （7） 删除职工文件中的全部记录； （8） 将单链表L中的所有职工记录存储到职工文件emp.da
c++写的链表综合算法设计
08-07
c++写的链表综合算法设计,上机调试通过
链表综合算法设计C++实现
09-21
有一职工文件，其结构为：职工号(no)、姓名(name)、部门号(depno)、工资数(salary)、职工号指针(pno)、部门号指针(pdepno)、工资数指针(psalary),设计一程序，从一文件中读取记录到单链表中，并完成如下功能：(1) 输入 (2) 输出 (3) 按no排序 (4) 按no输出 (5) 按depno排序 (6) 按depno输出 (7) 按salary排序 (8) 按salary输出 (9) 全清 (10) 存贮退出
剑指LeetCode -- 第七百零七题 -- 设计链表 -- 简单
蛋蛋
10-03 477
class MyLinkedList { private final ListNode list; private ListNode head; private ListNode rear; private int length; /** Initialize your data structure here. */ publ...
数据结构课程设计题目——链表综合算法设计、带头双向循环链表、插入、显示、删除、修改、排序
Crocodile1006的博客
10-06 2917
链表综合算法设计——校园人事信息系统、要求、代码实现（以带头双向循环链表为例）、基本程序结构、节点和链表的初始化、链表的插入、链表的显示、链表的删除、链表的修改、链表的排序（仿函数实现）、全部源码
多项式链表-算法设计与数据结构
qq_38445477的博客
08-28 518
借鉴了大神的思路与代码，主要还是运用来书上的，C语言是小白的我学会了结构的使用方法，有了更多的理解， 对这些代码进行了学习理解与改进，感觉不错 list.h typedef struct { int Coefficient;//系数 int Exponent;//指数 }ElementType;//针对多项式的结构声明，不知道是否可以调换，MARK并尝试；事实上必须声明 #i
算法设计与分析 链表
ljk的博客
01-19 897
算法设计与分析 算法 链表
算法设计与分析——链表
热门推荐
冯·诺依曼
08-07 1万+
链表是一种这样的数据结构，其中的各对象按线性顺序排列。数组的线性顺序是由数组下标决定的，然而与数组不同的是，链表的顺序是由各个对象里的指针决定的。链表为动态集合提供了一种简单而灵活的表示方法，并且能支持《算法设计与分析——栈和队列》中列出的所有操作。 如下图所示，双向链表LLL的每个元素都是一个对象，每个对象有一个关键字keykeykey和两个指针：nextnextnext和prevprevprev。对象中还可以包含其他的辅助数据（或称卫星数据）。设xxx为链表的一个元素，则x.nertx.nertx.ne
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值