【算法】面试题 - 链表（附讲解视频）

已于 2023-03-01 14:57:37 修改
阅读量316 收藏
点赞数
分类专栏： 面试题2022 文章标签： 链表 算法 数据结构
于 2022-12-26 22:30:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yzx3105/article/details/128448830
版权

链表相关面试题

876. 链表的中间结点

题目描述：
给定一个头结点为 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。
示例：1

输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

示例：2

输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

代码：

static ListNode middleNode(ListNode head) {
     ListNode fast = head;
     ListNode slow = head;
     
     while (fast.next != null && fast.next.next != null) {
         fast = fast.next.next;
         slow = slow.next;
     }
     //如果是奇数个节点，fast最后指向的是最后一个节点，如果是偶数个节点，fast最后指向的是倒数第二个节点
     //因此，如果fast.next==null，证明是奇数个节点，直接返回slow
     //如果fast.next.next==null，证明是偶数个节点，返回slow.next（返回第二个中间节点）
     if(fast.next == null){
         return slow;
     }else{
         return slow.next;
     }
 }

206. 反转链表

题目描述：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例：1
在这里插入图片描述

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例：2
在这里插入图片描述

输入：head = [1,2]
输出：[2,1]

示例：3

输入：head = []
输出：[]

代码：

public ListNode reverseList(ListNode head) {
    ListNode dummy = new ListNode(0);
     while (head != null) {
         ListNode next = head.next;
         head.next = dummy.next;
         dummy.next = head;
         head = next;
     }
     return dummy.next;
 }

86. 分隔链表

题目描述：
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。
你应当 保留 两个分区中每个节点的初始相对位置。
示例：1
在这里插入图片描述

输入：head = [1,4,3,2,5,2], x = 3
输出：[1,2,2,4,3,5]

示例：2

输入：head = [2,1], x = 2
输出：[1,2]

代码：

/**
 * 利用两个链表，将小于num的节点放到minListNodeDummy链表，大于等于num的节点放到maxListNodeDummy链表，最后，将minListNodeDummy拼接maxListNodeDummy返回
 * @param head
 * @param num
 * @return
 */
    static ListNode partition(ListNode head, int num) {
        ListNode minListNodeDummy = new ListNode(0);
        ListNode maxListNodeDummy = new ListNode(0);

        ListNode min = minListNodeDummy;
        ListNode max = maxListNodeDummy;

        while (head != null) {
            if (head.val < num) {
                min.next = head;
                min = min.next;
            } else {
                max.next = head;
                max = max.next;
            }
            head = head.next;
        }
        //避免成环，因为max指向的节点next可能指向其他节点，比如上面示例中，指向2，如果不清空，就会成环，报错Exception in thread "main" java.lang.StackOverflowError，因此将max.next=null就可以
        max.next = null;
        min.next = maxListNodeDummy.next;
        return minListNodeDummy.next;
    }

160. 相交链表

题目描述：
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
图示两个链表在节点 c1 开始相交：
在这里插入图片描述
示例：1
在这里插入图片描述

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例：2
在这里插入图片描述

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例：3
在这里插入图片描述

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

代码：

static ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    ListNode a = headA;
    ListNode b = headB;
    while (a != b) {
        a = a != null ? a.next : headB;
        b = b != null ? b.next : headA;
    }
    return a;
}

141. 环形链表

题目描述：
给定一个链表，判断链表中是否有环。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
示例 1：
在这里插入图片描述

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：
在这里插入图片描述

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例3：
在这里插入图片描述

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

代码：

public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null) {
            return false;
        }
        
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                break;
            }
        }
        return fast != null && fast.next != null;
    }
}

问题：快慢指针为什么一定会相遇

慢指针每次移动一格，快指针每次移动两格，在有环的链表里，他们一定会相遇
1、当快指针就在慢指针后面，那么下一次慢指针移动一位，快指针移动两位，相遇
2、当快指针和慢指针差一个位置，那么下一次慢指针移动一位，快指针移动两位，他们会变成第一种情况
3、当快指针和慢指针差两个位置，那么下一次慢指针移动一位，快指针移动两位，他们会变成第二种情况
我知道你也在纠结为什么会没有快指针跳过慢指针他们没有相遇的这种情况发生，但是这种情况只会发生在他们相遇后的下一次移动
原因：其实从上面的三步不难看出：快指针是一格一格追赶慢指针的，即他们的距离是…4->3->2->1->0这样缩短的。所以一定会相遇

在这里插入图片描述

快慢指针为什么一定会相遇（文章参考）：https://blog.csdn.net/Leslie5205912/article/details/89386769

142. 环形链表 II

题目描述：
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
**说明：**不允许修改给定的链表。

示例 1：
在这里插入图片描述

输入：head = [3,2,0,-4], pos = 1
输出：tail connects to node index 1
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：
在这里插入图片描述

输入：head = [1,2], pos = 0
输出：tail connects to node index 0
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：
在这里插入图片描述

输入：head = [1], pos = -1
输出：no cycle
解释：链表中没有环。

代码：

public class Solution {
    static ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                break;
            }
        }
        //无环
        if (fast == null || fast.next == null) {
            return null;
        }

        //有环 这时候起点至入口的距离等于相交点至入口的距离，因此两个指针用同样的速度直到相遇就是入口
        slow = head;
        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }
        return fast;
    }
}

问题：如何确认入口

在这里插入图片描述

如图：
慢指针走了 x+y 的距离
快指针走了 x+y+n(y+z)的距离
由于快指针是慢指针的二倍速度，因此得出公式
2(x+y) = x+y+n(y+z)
x = n(y+z)-y //放出去一个x+y
x = (n-1)(y+z)+z //n至少等于1，当n=1的时候可以推导出 x=z
因此，当两个指针用同样的速度走，相遇点就是入口

具体详解视频：https://www.bilibili.com/video/BV1if4y1d7ob

237. 删除链表中的节点

题目描述：
有一个单链表的 head，我们想删除它其中的一个节点 node。
给你一个需要删除的节点 node 。你将 无法访问 第一个节点 head。
链表的所有值都是 唯一的，并且保证给定的节点 node 不是链表中的最后一个节点。
删除给定的节点。注意，删除节点并不是指从内存中删除它。这里的意思是：

给定节点的值不应该存在于链表中。
链表中的节点数应该减少 1。
node 前面的所有值顺序相同。
node 后面的所有值顺序相同。

示例：1
在这里插入图片描述

输入：head = [4,5,1,9], node = 5
输出：[4,1,9]
解释：指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9

示例：2
在这里插入图片描述

输入：head = [4,5,1,9], node = 1
输出：[4,5,9]
解释：指定链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9

代码：

void deleteNode(ListNode node) {
    node.val = node.next.val;
    node.next = node.next.next;     
}

19. 删除链表的倒数第 N 个结点

题目描述：
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例：1
在这里插入图片描述

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例：2

输入：head = [1], n = 1
输出：[]

示例：3

输入：head = [1,2], n = 1
输出：[1]

代码：

static ListNode removeNthFromEnd(ListNode head, int k) {
     // 虚拟头结点
     ListNode dummy = new ListNode(-1);
     dummy.next = head;
     // 删除倒数第 k 个，要先找倒数第 k + 1 个节点
     ListNode x = findFromEnd(dummy, k + 1);
     // 删掉倒数第 n 个节点
     x.next = x.next.next;
     return dummy.next;
 }

//找到倒数第K个节点
static ListNode findFromEnd(ListNode head, int k) {
   ListNode slow = head;
   ListNode fast = head;

   for (int i = 0; i < k; i++) {
       fast = fast.next;
   }

   while (fast != null) {
       fast = fast.next;
       slow = slow.next;
   }
   return slow;
}

21. 合并两个有序链表

题目描述：
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：1

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

代码：

static ListNode mergeTwoLists(ListNode l1, ListNode l2) {
     ListNode dummy = new ListNode(0);

     ListNode pre = dummy;
     while (l1 != null && l2 != null) {
         if (l1.val > l2.val) {
             pre.next = l2;
             l2 = l2.next;
         } else {
             pre.next = l1;
             l1 = l1.next;
         }
         pre = pre.next;
     }
     //如果两边长度不一致，剩下的则可以直接追加
     pre.next = l1 == null ? l2 : l1;

     return dummy.next;
 }

23. 合并K个升序链表（两种解法）

题目描述：
合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
示例：1

输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

代码：（利用数组遍历找到最小值）
在这里插入图片描述

    static ListNode merge(ListNode[] listNodeArr) {
        ListNode result = new ListNode(0);
        ListNode cur = result;
        
        while (true) {
            int minIndex = -1;
            //找到最小索引
            for (int i = 0; i < listNodeArr.length; i++) {
                if (listNodeArr[i] != null) {
                    if (minIndex == -1) {
                        minIndex = i;
                    } else {
                        if (listNodeArr[i].val < listNodeArr[minIndex].val) {
                            minIndex = i;
                        }
                    }
                }
            }

            //如果minIndex：-1，证明数组中没有数据了
            if (minIndex == -1) {
                return result.next;
            }

            //result拼接当前最小节点
            cur.next = listNodeArr[minIndex];
            //cur后移
            cur = cur.next;

            //listNodeArr[minIndex]后移
            listNodeArr[minIndex] = listNodeArr[minIndex].next;
        }
    }

代码2：（利用小顶堆）

static ListNode merge2(ListNode[] listNodeArr) {
    //使用小顶堆，每次取出的都是最小的节点
    Queue<ListNode> minHeap = new PriorityQueue<>((o1, o2) -> o1.val - o2.val);
    ListNode dummy = new ListNode(0);
    ListNode cur = dummy;

    //将节点放进去
    for (ListNode node : listNodeArr) {
        if (node != null) {
            minHeap.offer(node);
        }
    }

    while (!minHeap.isEmpty()) {
        //弹出最小值
        ListNode tempNode = minHeap.poll();
        cur.next = tempNode;
        cur = cur.next;

        //往堆里放入当前节点的next
        if (tempNode.next != null) {
            minHeap.offer(tempNode.next);
        }
    }

    return dummy.next;
}

扩展：PriorityQueue

2. 两数相加

问题描述
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

代码

static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    ListNode head = new ListNode(0);//先给出一个节点，避免下面判断空，return head.next就好

    ListNode pre = head;
    int more = 0; //进位
    int sum = 0;//两个数字相加之和
    while (l1 != null || l2 != null || more != 0) {
        sum = (l1 != null ? l1.val : 0) + (l2 != null ? l2.val : 0) + more;
        more = sum / 10; //加出来的数字超过10，进一位
        sum = sum % 10; //加出来的数字值需要个位数

        //链表增加节点
        ListNode newNode = new ListNode(sum);
        pre.next = newNode;
        //pre指向当前最新节点，方便后面增加节点
        pre = newNode;

        //l1 l2都指向下一个节点，继续相加
        l1 = l1.next != null ? l1.next : null;
        l2 = l2.next != null ? l2.next : null;
    }
    return head.next;
}

83. 删除排序链表中的重复元素

逆序打印单向链表（栈）

LinkedList linkedList = new LinkedList<Integer>();
linkedList.add(0,0);
linkedList.add(1,1);
linkedList.add(2,2);
linkedList.add(3,3);

Stack<Integer> stacks = new Stack<>(); //先进后出
//将元素压入栈
LinkedList.Node cur = linkedList.getFirst();
while (cur != null) {
    stacks.push((Integer) cur.element);
    cur = cur.next;
}
//元素出栈
while (stacks.size() > 0) {
    System.out.println(stacks.pop());
}

在这里插入图片描述

约瑟夫环问题

在这里插入图片描述

1. 构建环形链表并遍历

在这里插入图片描述

2. 出圈

在这里插入图片描述

public class JosepfuDemo {
    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);
        circleSingleLinkedList.show();
        circleSingleLinkedList.countBoy(1, 2, 5);
    }
}

class CircleSingleLinkedList {
    private Boy first;

    void addBoy(int nums) {
        Boy cur = null;//指向最后一个节点
        for (int i = 1; i <= nums; i++) {
            Boy boy = new Boy(i);
            if (i == 1) {
                first = boy;
                first.setNext(first); //组成环
                cur = boy;
            } else {
                cur.setNext(boy); //当前节点加入环
                boy.setNext(first); //组成环
                cur = boy; //指向最后一个节点
            }
        }
    }

    /**
     * @param startNo  从第几个小孩开始
     * @param countNum 数多少下
     * @param nums     一共多少小孩
     */
    void countBoy(int startNo, int countNum, int nums) {
        // 先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数输入有误， 请重新输入");
            return;
        }

        //创建辅助指针，指向最后一个元素
        Boy helper = first;
        while (true) {
            if (helper.getNext() == first) {
                break;
            }
            helper = helper.getNext();
        }

        //小孩报数前，先让 first 和  helper 移动 k - 1次
        for (int i = 0; i < startNo - 1; i++) {
            helper = helper.getNext();
            first = first.getNext();
        }

        while (true) {
            if (first == helper) {
                System.out.println("最后一个小孩：" + first.getNo());
                break;
            }

            //让 first 和  helper 移动 m - 1次 (假设m是2，只需要移动一次，自己喊1，下一个就是被移除的元素)
            for (int i = 0; i < countNum - 1; i++) {
                helper = helper.getNext();
                first = first.getNext();
            }
            //这时first指向的节点，就是要出圈的小孩节点
            System.out.println("出圈：" + first.getNo());
            //元素出圈
            first = first.getNext();
            helper.setNext(first);
        }
    }


    void show() {
        Boy cur = first;
        while (true) {
            System.out.println(cur.getNo());
            if (cur.getNext() == first) {
                break;
            }
            cur = cur.getNext();
        }
    }
}

class Boy {
    private int no;
    private Boy next;

    public Boy(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }
}

在这里插入图片描述

快慢指针为什么一定会相遇：https://blog.csdn.net/Leslie5205912/article/details/89386769
142. 环形链表 II（详解视频）：https://www.bilibili.com/video/BV1if4y1d7ob
160. 相交链表（详解视频）：https://www.bilibili.com/video/BV1aK411N7fW
19. 删除链表的倒数第 N 个结点（详解视频）： https://www.bilibili.com/video/BV1fq4y1y7z3
21. 合并两个有序链表（视频讲解）： https://www.bilibili.com/video/BV1vo4y1Q7Ew
23. 合并K个有序链表（视频讲解）：https://www.bilibili.com/video/BV1QK4y1N7ww
2. 两数相加（视频讲解）：https://www.bilibili.com/video/BV11C4y1t7iY
86. 分隔链表（视频讲解）：https://www.bilibili.com/video/BV1Gq4y1e7GH
876. 链表的中间结点（视频讲解）：https://www.bilibili.com/video/BV1UK411n7RN
约瑟夫环问题：https://www.bilibili.com/video/BV1E4411H73v?p=28&vd_source=b901ef0e9ed712b24882863596eab0ca
206. 反转链表（真的一看就懂）：https://www.bilibili.com/video/BV1Ai4y157mn/?spm_id_from=333.337.search-card.all.click&vd_source=b901ef0e9ed712b24882863596eab0ca

桃月十二_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
玩转算法面试-- Leetcode真题分门别类讲解
weixin_43608645的博客
04-04 1368
如何“正确”的回答一个算法问题 对一组数据进行排序： 1、这组数据有什么样的特征？     • ①有没有可能包含有大量重复的元素？     如果有这种可能的话，三路快排是更好的选择(Java种快排的基本实现就是使用三路快排)。     • ②是否大部分数据距离它正确的位置很近？是否近乎有序？     如果是这样的话，插入排序是更好的选择（如对银行的业务按照业务发生的时间进行排序，大多数业务先发生也...
嵌入式岗位笔试面试真题讲解1-5.pdf
03-11
### 嵌入式岗位笔试面试真题讲解 #### 数据结构与算法部分解析 ##### 数组与链表的区别 数组和链表都是常用的数据结构，它们各有特点： 1. **数组**： - 元素个数在定义时就必须确定，并且所有元素必须具有相同...
[leetcode] 160.相交链表
fanfangyu的博客
08-31 156
给你两个单链表的头节点headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。 图示两个链表在节点 c1 开始相交： 题目数据保证整个链式结构中不存在环。 注意，函数返回结果后，链表必须保持其原始结构。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Intersected ...
哈希表题目：相交链表
stormsunshine的博客
12-15 393
文章目录题目标题和出处难度题目描述要求示例数据范围进阶解法一思路和算法代码复杂度分析解法二思路和算法证明代码复杂度分析 题目 标题和出处 标题：相交链表 出处：160. 相交链表 难度 2 级 题目描述 要求 给你两个单链表的头结点 headA\texttt{headA}headA 和 headB\texttt{headB}headB，请你找出并返回两个单链表相交的起始结点。如果两个链表不存在相交结点，返回 null\texttt{null}null。 图示两个链表在结点 c1\texttt{c1}c1 开
剑指 Offer 52. 两个链表的第一个公共节点
qq_43624038的博客
02-09 123
输入两个链表，找出它们的第一个公共节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8 输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8
160. 相交链表
Tzecto
06-12 122
相交链表 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。 图示两个链表在节点 c1 开始相交： 题目数据 保证 整个链式结构中不存在环。 注意，函数返回结果后，链表必须 保持其原始结构 。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Intersected at '8' 解.
【数据结构与算法】【腾讯阿里链表面试题】算法题--链表易懂版讲解
终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路
02-10 1585
腾讯面试题：复制随机节点 题目说明： 给定一个链表，每个节点包含一个指向任意节点的随机指针，同时每个节点有一个指向同一链表中节点的指针，输出这个链表的深拷贝。 阿里巴巴面试题：合并K个排序链表 题目说明： 给你一个链表数组，每个链表都已经按升序排列，请你将所有的链表合并到一个升序链表中，返回合并后的链表。
LeetCode算法之--链表系列
程序大视界
12-21 785
LeetCode链表常见算法题型
链舞算法谱---链表经典题剖析
2303_79972050的博客
05-04 1267
欢迎来到我的链表算法博客，这将是您深入了解链表算法，提升编程技能的绝佳机会。链表作为数据结构的重要成员之一，其动态性和灵活性在实现某些功能上发挥不可替代的功效。前面，我们学习单链表的基本实现，比如链表的创建，销毁，增删查改等。如果您不是很了解单链表的相关操作，可以读一下鄙人的单链表博客，或者自行学习。我们要注重理论实践结合，阅读他人的代码和相关题解（力扣网站每道题都有大佬（官方）的优秀题解供我们学习），更能熟悉掌握链表的核心知识。本期精选链表算法的高级话题，选自力扣网站（后面附带刷题链接）。
【算法专题--链表】删除排序链表中的重复元素II -- 高频面试题（图文详解，小白一看就懂！！）
weixin_45031801的博客
06-16 1267
删除排序链表中的重复元素II元素这道题，可以说是--链表专题--，最经典的一道题，也是在面试中频率最高的一道题目，通常在面试中，面试官可能会从多个方面考察这道题目，所以大家需要对这道题目非常熟悉哦！！
【算法专题--链表】合并两个有序链表--高频面试题（图文详解，小白一看就会！！）
weixin_45031801的博客
06-12 1890
合并两个有序链表这道题，可以说是--链表专题--，比较经典的一道题，也是在面试中频率较高的一道题目，通常在面试中，面试官可能会要求我们写出多种解法来实现这道题目，所以大家需要对这道题目非常熟悉哦！！
算法大全-面试题-数据结构.pdf.zip_算法
09-23
这个文档详细讲解了这些概念，并通过面试题的形式帮助读者理解和掌握，是提升算法能力的绝佳资源。在学习过程中，结合实际编程练习，将理论知识转化为实践技能，是成为一名优秀程序员的关键步骤。
2021数据结构与算法面试题
08-14
数据结构与算法是计算机科学的基础，对于...以上知识点是数据结构与算法面试题中常见的部分，每个主题下都可能有深入的理论讲解和实践题目，对于准备面试的开发者来说，全面掌握这些内容将大大提升在面试中的竞争力。
大厂面试算法100题
10-31
下面将详细讲解两道典型的面试题及其解决方案。 1. **二元查找树转化为排序双向链表** 这道题目的核心在于如何利用二元查找树的特性（左子节点值小于父节点，右子节点值大于父节点）来构建一个有序的双向链表。...
面试-Java一些常见面试题+题解之算法-Algorithm.zip
03-03
本资料包"面试-Java一些常见面试题+题解之算法-Algorithm.zip"正是为了帮助求职者准备这类面试而设计的。以下是基于这个主题的详细知识点讲解： 1. **基础概念**： - **Java语法**：包括变量、数据类型、运算符、...
排序（归并排序，非比较排序）
最新发布
qq_63074244的博客
08-20 524
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的 相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，⽽在排序后的序列中，r[i]仍在r[j]之 前，则称这种排序算法是稳定的；否则称为不稳定的。数据结构结构初阶的排序基本上总结完毕了，这里我学了冒泡，插入，选择，快排，希尔，堆，归并，计数排序，这几种排序在时间复杂度，空间复杂度以及稳定性上各有各的优点。下面我们用一张图进行总结。
代码随想录算法训练营第十七天（二叉树 五）
b1ankwall的博客
08-16 761
参加代码随想录第43期算法训练营day17|654.最大二叉树，617.合并二叉树，700.二叉搜索树中的搜索，98.验证二叉搜索树
【Python】生成二维迷宫的算法
HarryXYC的博客
08-16 312
基于Pygame和PIL的迷宫生成器
Leetcode 219. 存在重复元素 II
铁马冰河入梦来
08-20 191
哈希表解决存在重复元素二问题
算法面试通关：链表、队列、栈实战+LeetCode解题技巧
在求职面试中，掌握基础算法对于提升编码能力和算法思维至关重要。本文将聚焦于链表、队列、栈等数据结构，并通过实战题目...在准备秋招时，系统地练习并理解这些基础算法和数据结构，无疑是通关算法面试的关键。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值