算法与数据结构——算法基础——链表（java）（左程云b站课程笔记总结）

最新推荐文章于 2023-01-07 20:35:30 发布
最新推荐文章于 2023-01-07 20:35:30 发布
阅读量315 收藏 5
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Borslav/article/details/125133240
版权

链表

方法论

  • 对于笔试，不用太在乎空间复杂度，一切为了时间复杂度
  • 对比面试，时间复杂度依然放在第一位，但是需要找到空间最省的方法
  • 重要技巧
    • 额外数据结构记录（哈希表等）
    • 快慢指针

单链表、双链表基本结构

value next和value next last

反转单向链表

【如果链表长度为N，时间复杂度要求为O(N)，额外空间复杂度要求为O(1)】

栈（若没有额外空间复杂度要求）

public ListNode reverseList(ListNode head){
    Stack<ListNode> stack=new Stack<>();
    while(head!=null){
        stack.push(head);
        head=head.next;
    }
    if(stack.isEmpty()){
        return null;
    }
    ListNode node=stack.pop();
    ListNode dummy=node;
    while(!stack.isEmpty()){
        ListNode tempNode=stack.pop();
        node.next=tempNode;
        node=node.next;
    }
    //最后一个结点就是反转前的头结点，一定要让他的next
    //等于空，否则会构成环
    node.next=null;
    return dummy;
}

递归

public ListNode reverseListNode(ListNode head){
    if(head==null||head.next==null){
        return head;
    }
    ListNode newHead=reverseListNode(head.next);
    head.next.next=head;
    head.next=null;
    return newHead;
}

左神

把原链表的结点一个个摘掉，每次摘掉的链表都让他成为新的链表的头结点，然后更新新链表

image-20220604153333756

public ListNode reverseListNode(ListNode head){
    ListNode pre=null;
    ListNode next=null;
    while(head!=null){
        next=head.next;
        head.next=pre;
        pre=head;
        head=next;
    }
    return pre;
}

反转单向链表Ⅱ

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

穿针引线

image-20220604153247644

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        ListNode dummyNode=new ListNode(-1);//一般操作
        dummyNode.next=head;
        ListNode pre=dummyNode;
        for(int i=1;i<left;i++){
            pre=pre.next;
        }
        ListNode cur=pre.next;
        ListNode next=null;
        for(int i=0;i<right-left;i++){
            next=cur.next;
            cur.next=next.next;
            next.next=pre.next;
            pre.next=next;
        }
        return dummyNode.next;
    }
}

反转双向链表

【如果链表长度为N，时间复杂度要求为O(N)，额外空间复杂度要求为O(1)】

public DoubleNode reverseDoubleNode(DoubleNode head){
    DoubleNode pre=null;
    DoubleNode next=null;
    while(head!=null){
        next=head.next;
        head.next=pre;
        head.last=next;
        pre=head;
        head=next;
    }
    return pre;
}

打印两个有序链表的公共部分

要求：如果两个链表的长度之和为N，时间复杂度要求为O(N)，额外空间复杂度为O(1)

谁小谁移动，相等就一起移动并打印（保存），一个越界了就停

public static void printCommonPart(Node head1, Node head2) {
    System.out.print("Common Part: ");
    while (head1 != null && head2 != null) {
        if (head1.value < head2.value) {
            head1 = head1.next;
        } else if (head1.value > head2.value) {
            head2 = head2.next;
        } else {
            System.out.print(head1.value + " ");
            head1 = head1.next;
            head2 = head2.next;
        }
    }
    System.out.println();
}

判断一个链表是否是回文链表

笔试：栈

全部进栈，出栈的时候就相当于是反着读，与正着读的时候比较即可

public boolean isPalidromeList(ListNode head){
    Stack<ListNode> stack=new Stack<>();
    ListNode cur=head;
    while(cur!=null){
        stack.push(cur);
        cur=cur.next;
    }
    while(head!=null){
        if(head.value!=stack.pop().value){
            return false;
        }
        head=head.next;
    }
    return true;
}

优化

快慢指针

快指针一次走两步，慢指针一次走一步，快指针走完的时候满指针在中点

只需要存一半进栈

1.奇数时慢指针出现在中点，偶数时满指针出现在第一个

ListNode fast=head;
ListNode slow=head;
while(fast.next!=null&&fast.next.next!=null){
    slow=slow.next;
    fast=fast.next.next;
}

2.奇数时出现在中点的下一个，偶数时出现在第二个

ListNode fast=head.next;
ListNode slow=head;
while(fast.next!=null&&fast.next.next!=null){
    slow=slow.next;
    fast=fast.next.next;
}

public boolean isPalindrome(ListNode head){
    if(head==null||head.next==null){
        return true;
    }
    ListNode right=head.next;
    ListNode cur=head;
    while (cur.next != null && cur.next.next != null) {
        right = right.next;
        cur = cur.next.next;
    }
    Stack<Node> stack = new Stack<Node>();
    while (right != null) {
        stack.push(right);
        right = right.next;
    }
    while (!stack.isEmpty()) {
        if (head.value != stack.pop().value) {
            return false;
        }
        head = head.next;
    }
    return true;
}

如何做到额外空间复杂度为O(1)

笔试的做法

快慢指针+反转+对比+恢复

public boolean isPalindrome(ListNode head){
    if(head==null||head.next==null){
        return true;
    }
    ListNode fast=head;
    ListNode slow=head;
    while(fast.next!=null&&fast.next.next!=null){
        slow=slow.next;
        fast=fast.next.next;
    }
    fast=slow.next;
    slow.next=null;// mid.next -> null
    ListNode next=null;
    //反转
    while(fast!=null){
        next=fast.next;
        fast.next=slow;
        slow=fast;
        fast=next;
    }
    next=slow;//save last node
    fast=head;
    boolean res=true;//后面还要恢复链表
    while(slow!=null&&fast!=null){
        if(slow.value!=fast.value){
            res=false;
            break;
        }
        slow=slow.next;
        fast=fast.next;
    }
    slow=next.next;
    next.next=null;
    while(slow!=null){
        fast=slow.next;
        slow.next=next;
        next=slow;
        slow=fast;  
    }
    return res;
}

将单向链表按某个值划分成左边小，中间相等，右边大的形式

笔试：先将链表的每一个节点放到数组中，在数组上进行partition，再按链表串起来

public ListNode listPartition(ListNode head,int num){
    if(head==null){
        return head;
    }
    ListNode cur=head;
    int i=0;
    
    //记录长度
    while(cur!=null){
        i++;
        cur=cur.next;
    }
    ListNode[] nodeArr=new Node[i];
    i=0;
    cur=head;
    for(int i=0;i!=nodeArr.length;i++){
        nodeArr[i]=cur;
        cur=cur.next;
    }
    arrPartition(nodeArr,num);
    for(i=1;i!=nodeArr.length;i++){
        nodeArr[i-1].next=nodeArr[i];
    }
    nodeArr[i-1].next=null;
    return nodeArr[0];
}

public void arrPartition(ListNode[] nodeArr,int num){
    int small=-1;
    int big=nodeArr.length;
    int index=0;
    while(index!=big){
        if(nodeArr[index].value<num){
            swap(nodeArr,++small,index++);
        }else if(nodeArr[index].value==num){
            index++
        }else{
            swap(nodeArr,--big,index);
        }
    }
}

public void swap(ListNode[] nodeArr,int a,int b){
    Node tmp=nodeArr[a];
    nodeArr[a]=nodeArr[b];
    nodeArr[b]=tmp;
}

面试：在链表上直接partition（六个变量）可以不改变相对次序，即保持稳定性且没有额外的空间

注：最后将三个区域合并时，需要讨论清楚边界，避免出现该区域没值的情况

public ListNode listPartition(ListNode head,int num){
    ListNode sH=null;
    ListNode sT=null;
    ListNode eH=null;
    ListNode eT=null;
    ListNode bH=null;
    ListNode bT=null;
    ListNode next=null;
    
    while(head!=null){
        next=head.next;
        head.next=null;
        if(head.value<num){
            if(sH==null){
                sH=head;
                sT=head;
            }else{
                sT.next=head;
                sT=head;
            }
        }else if(head.value==num){
            if(eH==null){
                eH=head;
                eT=head;
            }else{
                eT.next=head;
                eT=head;
            }
        }else{
            if(bH==null){
                bH=head;
                bT=head;
            }else{
                bT.next=head;
                bT=head;
            }
        }
        head=next;
    }
    if(sT!=null){
        sT.next=eH;
        eT=eT==null?sT:eT;
    }
    if(eT!=null){
        eT.next=bH;
    }
    return sH!=null?sH:eH!=null?eH:bH;
    
}

复制含有随机指针节点的链表

image-20220605140611359

笔试：哈希表，key存老的node，value存新的node

public ListNode copyListNodeWithRan(ListNode head){
    HashMap<ListNode,ListNode> hashmap=new HashMap<>();
    ListNode cur=head;
    while(cur!=null){
        hashmap.put(cur,new ListNode(cur.value));
        cur=cur.next;
    }
    cur=head;
    while(cur!=null){
        hashmap.get(cur).next=hashmap.get(cur.next);
        hashmap.get(cur).rand=hashmap.get(cur.rand);
        cur=cur.next;
    }
    return hashmap.get(head);
}

通过克隆节点的位置（放在原节点的下一个）可以把HashMap省掉

合并——>复制——>分离

public ListNode copyListNodeWithRand(ListNode head){
    if(head==null){
        return null;
    }
    ListNode cur=head;
    ListNode next=null;
    // copy node and link to every node
    while(cur!=null){
        next=cur.next;//recording
        cur.next=new Node(cur.value);
        cur.next.next=next;
        cur=next;
    }
    cur=head;
    ListNode curCopy=null;
    // set copy node rand
    while(cur!=null){
        next=cur.next.next;
        curCopy=cur.next;
        curCopy.rand=cur.rand!=null?cur.rand.next:null;
        cur=next;
    }
    ListNode res=head.next;
    cur=head;
    //split
    while(cur!=null){
        next=cur.next.next;
        curCopy=cur.next;
        cur.next=next;
        curCopy.next=next!=null?next.next:null;
        cur=next;
    }
    return res;
}

两个单链表相交的一系列问题

image-20220605144125670

  1. 首先实现一个函数判断一个单链表是否有环，有的话返回环的入环节点loop，否则返回null(两条链表分别调用该函数)

    • 用哈希表HashSet实现，有额外空间，遍历并插入，若在遍历结束之前有无法插入的，就返回

    • 快慢指针，无额外空间

      快指针一次走两步，慢指针一次走一步，如果无环，快指针会到null，如果有环，快慢指针必会相遇

      相遇之后，快指针回到头节点，然后快慢指针同时，每次走一步，最终会在入环节点相遇

  2. 分类讨论

    1. 两个链表都无环，如果相交，相交的时刻到走到结尾都是共有的。分别遍历两个链表得到len1，end1和len2，end2，如果end1与end2内存地址不相等的话不可能相交，相等的话找出相交部分的第一个节点，让长度大的先走，直到和长度小的长度一致，然后一起走

    2. 一个有环，一个没环，这种情况两条链表不可能相交

    3. 两个链表都有环

      image-20220605153421076

      • 当loop1和loop2内存地址相同，就是第二种情况，把入环节点当成终止节点，然后操作和1相同
      • 让loop1继续往下走在回到自己之前如果能遇到loop2就是第三种情况（随便返回其中一个loop都行），否则就是第一种情况，返回null
public ListNode getIntersectNode(ListNode head1,ListNode head2){
    if(head1==null||head2==null){
        return null;
    }
    ListNode loop1=getLoopNode(head1);
    ListNode loop2=getLoopNode(head2);
    if(loop1==null&&loop2==null){
        return noLoop(head1,head2);
    }
    if(loop1!=null&&loop2!=null){
        return bothLoop(head1,loop1,head2,loop2);
    }
    //其他情况包括一个有环一个无环的情况d
    return null;
}

//如果有环，获取入环节点
public ListNode getLoopNode(ListNode head){
    if(head==null||head.next==null||head.next.next==null){
        return null;
    }
    ListNode n1=head.next;
    ListNode n2=head.next.next;
    //防止后续进不去循环
    while(n1!=n2){
        if(n2.next==null||n2.next.next==null){
            return null;
        }
        n2=n2.next.next;
        n1=n1.next;
    }
    n2=head;
    while(n1!=n2){
        n1=n1.next;
        n2=n2.next;
    }
    return n1;
}
//如果都没有环的情况
public ListNode noLoop(ListNode head1,ListNode head2){
    if(head1==null||head2==null){
        return null;
    }
    ListNode cur1=head1;
    ListNode cur2=head2;
    int n=0;
    while(cur1.next!=null){
        n++;
        cur1=cur1.next;
    }
    while(cur2.next!=null){
        n--;
        cur2=cur2.next;
    }
    if(cur1!=cur2){
        return null;
    }
    cur1=n>0?head1:head2;
    cur2=cur1==head1:haed2:head1;
    n=Math.abs(n);
    while(n!=0){
        n--;
        cur1=cur1.next;
    }
    while(cur1!=cur2){
        cur1=cur1.next;
        cur2=cur2.next;
    }
    return cur1;
}
//如果都有环的情况
public ListNode bothLoop(ListNode head1,ListNode loop1,ListNode head2,ListNode loop2){
    ListNode cur1==null;
    ListNode cur2==null;
    if(loop1==loop2){
        cur1=head1;
        cur2=head2;
        int n=0;
        while(cur1!=loop1){
            n++;
            cur1=cur1.next;
        }
        while(cur2!=loop2){
            n--;
            cur2=cur2.next;
        }
        cur1=n>0?head1:head2;
        cur2=cur1==head1?head2:head1;
        n=Math.abs(n);
        while(n!=0){
            n--;
            cur1=cur1.next;
        }
        while(cur1!=cur2){
            cur1=cur1.next;
            cur2=cur2.next;
        }
        return cur1;
    }else{
        cur1=loop1.next;
        while(cur1!=loop1){
            if(cur1==loop2){
                return loop1;
            }
            cur1=cur1.next;
        }
        return null;
    }
}
Borslav
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
左程云——链表
m0_46266264的博客
07-31 317
hash与有序表 unordered_set用法 unordered_map用法(和map用法一样，不过map有序，这个无序)——算法笔记6.4 有序表就是 Set和 Map 哈希表里面不管放多少条记录，时间复杂爱都是常数级别。 链表 反转链表 注意：链表的调整可能会存在换头的操作，那就带返回值，不换头可以定义成void类型。 这道题其实类似于下图，外排序，用两个指针指着两个链表，谁小谁向右移动，相等时将value放入新数组，然后一起移动。有一个越界了就停。 笔试：直接放到栈里就行 栈先进后
算法和数据结构总结---单链表
Kroner的博客
11-22 587
链表 链表可以说是一种很基本的数据结构，链表通常以一种特定的组合将元素链接在一起，以便可以对元素实现方便的管理维护。这一点和我们常常使用的数组很相似，但是链表在最多的情况下可以带来比链表更为优势的操作，链表通常是在系统需要的时候动态开辟的，换句话说链表的存储空间是在程序运行的时候在进行分配的，在许多的时候，我们无法明确的确定数据的大小直接在编译前分配内存，这种动态分配的方法也是链表的优势之一。 单...
算法与数据结构——大数据题目（java）（b站左程云课程笔记总结）
Borslav的博客
07-08 494
算法与数据结构——大数据题目（Java）
【笔记：左程云算法与数据结构】4.链表
qq_42102962的博客
11-28 212
左程云算法与数据结构笔记（自用）
算法与数据结构基础学习六（链表问题总结）
Master_guoguo的博客
06-08 68
回文问题 链表排序 一种特殊链表 链表环
算法和数据结构——左程云.zip
最新发布
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
b站左程云数据结构和算法，基础不牢，地动山摇.zip
01-14
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
Python实现数据结构与算法——反转链表
12-21
题目描述： 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道...这个过程相当于，在遍历链表的过程中，每一个当前节点的nex
数据结构&算法——Java.zip
01-14
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
左程云_算法与数据结构 — 链表问题 — 04反转单向和双向链表
Art is long, but life is short.
06-26 612
问题描述实现反转链表的方法，要求时间复杂度为O(N),空间复杂度为O(1)思路分析 利用桟来实现反转：时间复杂度O(N),空间复杂度O(N)； 将链表推入桟内，然后出桟构成新的链表； 原地反转，利用其他的一些变量来进行转换：时间复杂度O(N)空间复杂度O(1)。 代码实现package algorithm_zuochengyun; public class CH2_04_reverseList {
左程云_算法与数据结构 — 链表问题 — 06环形单链表的约瑟夫问题_normal&advanced
Art is long, but life is short.
06-26 669
问题描述据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个
class3 队列、栈和链表（左程云左神算法 初级笔记 2018）
quanquanya的博客
04-23 826
class 3 用数组结构实现大小固定的队列和栈 package com.godzuo.java; /** * @author quanquan * @create 2020-04-20-22:36 */ public class Array_To_Stack_Queue { public static class arrayToStack{ private I...
LeetCode005——最长回文子串
清风阁
08-20 1362
我的LeetCode代码仓：https://github.com/617076674/LeetCode 原题链接：https://leetcode-cn.com/problems/longest-palindromic-substring/description/ 题目描述： 知识点：动态规划 思路一：暴力解法（在LeetCode中提交会超时） 注意回文子串的定义，题目中的回文子串要...
【左程云Java算法】Chapter1-3:如何仅用递归函数和栈操作逆序一个栈
知识无止境
10-25 1170
Chapter1-3:如何仅用递归函数和栈操作逆序一个栈【题目】一个栈依次压入1、2、3、4、5，那么从栈顶到栈底分别为5、4、3、2、1。将这个栈转置后，从栈顶到栈底为1、2、3、4、5，也就是实现栈中元素的逆序，但是只能用递归函数来实现，不能用其他数据结构。【要求】【难度】尉★★☆☆【解答】本题考查 栈的操作和递归函数的设计，我们需要设计出两个递归函数。递归函数一：将栈stack的栈底元素返回并移除。
Java链表基础
qq_46638003的博客
01-07 2098
以上是对链表的基础操作,大部分都是通过遍历链表实现.
两个单链表相交的一系列问题
diju7500的博客
04-12 123
【说明】： 　　本文是左程云老师所著的《程序员面试代码指南》第二章中“两个单链表相交的一系列问题”这一题目的C++复现。 　　本文只包含问题描述、C++代码的实现以及简单的思路，不包含解析说明，具体的问题解析请参考原书。 　　感谢左程云老师的支持。 【题目】： 　　在本题中，单链表可能有环也可能无环。给定两个单链表的头节点 head1 和 head2，这两个单链...
剑指offer 3. 从头到尾打印链表（ListNode,Stack,ArrayList）
DurianPudding的博客
10-19 1391
题目描述 输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。 思路： 因为不熟悉ListNode，所以看了排名第一的代码。思路是， 就是把链表倒序放入ArrayList，中间使用栈，栈先进后出，就可以自然的倒叙 知识点： ListNode是一个链表。在节点中，存储了两个变量：value 和 next。value 是这个节点的值，next 是指向下一节点的指针，维系链表节点间的关系。...
链表的相关操作
m0_49708063的博客
03-14 995
一个链表的数据结构如下 public class ListNode { public int val; public ListNode next=null; public ListNode rand=null; ListNode(int val){ //构造方法 ：构造方法和类名相同 this.val=val; //把接收的参数赋值给当前类的val变量 } } 问题：如果一个链表的next节点指向它的下一个节点，它的rand节点指向随机节点（可以为null）
《数据结构与算法——c++版》
08-11
《数据结构与算法——c 版》是一本介绍数据结构和算法的学习教材。这本书以C语言为主要编程语言，全面讲解了数据结构和算法的基本概念及其常见的应用。通过学习本书，读者可以掌握C语言中常用的数据结构和算法，提高...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值