【算法修炼】链表一、二

已于 2022-04-29 19:03:11 修改
阅读量1.6k 收藏
点赞数
分类专栏： 算法修炼 文章标签： 算法 数据结构 java
于 2022-04-27 22:21:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mxeron/article/details/123431635
版权
本文详细介绍了链表的各种操作，包括合并两个有序链表、删除排序链表中的重复元素、单链表的倒数第K个节点、删除链表的倒数第N个节点、链表的中间节点、链表环检测以及相交链表的检测。通过递归和迭代两种方式展示了如何解决这些问题，同时提到了链表操作中的关键技巧，如使用虚拟头节点和快慢指针。此外，还讨论了合并K个有序链表的优先级队列解决方案和K个一组翻转链表的难题。
摘要由CSDN通过智能技术生成

链表一、二


前面介绍了树、图等题目的解法，接下来主要对链表相关题目进行讲解和练习。
学习自：https://labuladong.gitee.io/algo/2/18/17/

链表一

21、合并两个有序链表（简单）

在这里插入图片描述
题目比较简单，可以直接看代码，主要用到了虚拟头节点dummy，有了dummy可以避免处理空指针的情况，降低代码的复杂性。

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode dummy = new ListNode(-1);
        // 指向虚头
        ListNode p = dummy;
        ListNode a = list1, b = list2;
        while (a != null && b != null) {
            if (a.val > b.val) {
                // p.next 指向 b 指向的内存区域
                p.next = b;
                // b不再指向那片内存区域，转去指向b.next的内存区域
                // 但是p.next仍然指向那片内存区域，不影响p.next
                // 注意p.next指向的那片内存区域仍然有b.next!!!
                b = b.next;
            } else {
                p.next = a;
                a = a.next;
            }
            // p移向下一个位置
            p = p.next;
        }
        // 如果两个链表还有剩余的，直接把剩余部分接在后面即可
        if (a != null) {
            p.next = a;
        }
        if (b != null) {
            p.next = b;
        }
        // 虚头的下一个位置就是要返回的值
        return dummy.next;
    }
}

面试常常要求要去重，可以做做下面两道题：

83、删除排序链表中的重复元素（简单）

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null) return head;
        ListNode p = head;
        while (p.next != null) {
            if (p.val == p.next.val) {
                p.next = p.next.next;
            } else {
                p = p.next;
            }
        }
        return head;
    }
}
82、删除排序链表中的重复元素Ⅱ（中等）

在这里插入图片描述
和上一题不同，本题需要把重复的节点全部进行删除，因为涉及删除头节点，所以最好使用dummy节点，很方便进行重复节点的删除。

链表的题通常需要注意两点：

  • 舍得用变量，千万别想着节省变量，否则容易被逻辑绕晕
    head 有可能需要改动时，先增加一个 假head，返回的时候直接取 假head.next，这样就不需要为修改 head 增加一大堆逻辑了。
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode p = dummy;
        while (p.next != null && p.next.next != null) {
            if (p.next.val == p.next.next.val) {
                int x = p.next.val;
                while (p.next != null && p.next.val == x) {
                    p.next = p.next.next;
                }
            } else {
                p = p.next;
            }
        }
        return dummy.next;
    }
}

好了，回到合并两个有序链表，下面还有一个非常经典的问题，合并K个升序链表：
在这里插入图片描述

并 k 个有序链表的逻辑类似合并两个有序链表，难点在于，如何快速得到 k 个节点中的最小节点，接到结果链表上？
这里我们就要用到 优先级队列 这种数据结构，把链表节点放入一个最小堆，就可以每次获得 k 个节点中的最小节点：

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) return null;
        // 虚拟头节点
        ListNode dummy = new ListNode(-1);
        ListNode p = dummy;
        // 优先队列（最小堆）
        PriorityQueue<ListNode> pq = new PriorityQueue<>(new Comparator<ListNode>() {
        	@Override
        	public int compare(ListNode a, ListNode b) {
        		return a.val - b.val;
        	}
        });
        // 把链表的头节点加入优先队列
        for (ListNode head : lists) {
            if (head != null) {
                pq.add(head);
            }
        }
        while (!pq.isEmpty()) {
            // 获取最小值节点，加到新链表中
            ListNode node = pq.poll();
            p.next = node;
            if (node.next != null) {
                // 下一个节点再入队
                pq.add(node.next);
            }
            // p指针不断前进
            p = p.next;
        }
        return dummy.next;
    }
}

这个算法是面试常考题，它的时间复杂度是多少呢？

优先队列 pq 中的元素个数最多是 k，所以一次 poll 或者 add 方法的时间复杂度是 O(logk)；所有的链表节点都会被加入和弹出 pq，所以算法整体的时间复杂度是 O(Nlogk)，其中 k 是链表的条数，N 是这些链表的节点总数。

单链表的倒数第K个节点

正数的第K个节点很好找，关键是倒数，解决方法类似于快慢指针，首先让两个节点都指向头节点，第一个节点先走k步，然后再让两个节点一起走，直到第一个节点为null，此时第二个节点指向的位置，就是倒数第k个节点的位置。

19、删除链表的倒数第N个节点（中等）

在这里插入图片描述
先找到倒数第k个节点即可，但是注意，这个节点可能是头节点，所以还要对找到的节点判断一下。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        // 快慢指针，第一个先走n步
        ListNode p1 = head;
        ListNode p2 = head;
        for (int i = 0; i < n; i++) {
            p1 = p1.next;
        }
        ListNode prev = null;
        while (p1 != null) {
            prev = p2;
            p1 = p1.next;
            p2 = p2.next;
        }
        // 此时p2指向的就是倒数第n个节点
        if (head == p2) {
            // 如果删除的是头节点
            return head.next;
        }
        prev.next = prev.next.next;
        return head;
    }
}

优化，由于需要修改头节点，引入dummy节点，删除节点其实需要的是倒数第N+1个节点，所以去找倒数第N+1个节点。

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        // 找到倒数第n + 1个节点
        ListNode p1 = dummy;
        ListNode p2 = dummy;
        for (int i = 0; i < n + 1; i++) {
            p1 = p1.next;
        }
        while (p1 != null) {
            p1 = p1.next;
            p2 = p2.next;
        }
        p2.next = p2.next.next;
        return dummy.next;
    }
}
876、链表的中间节点（简单）

在这里插入图片描述
经典模板题

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode middleNode(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        // 快慢指针，快的走两步，慢的走一步，快的=null，慢的指向中间节点
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
}
链表环检测
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) return true;
        }
        return false;
    }
}
链表环检测Ⅱ

在上一题的基础上，需要找到入环节点。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;
        boolean flag = false;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (slow == fast) {
                flag = true;
                break;
            }
        }
        if (flag == false) return null;
        // 让其中一个节点从头节点开始走，与另一节点的相遇位置就是入环节点
        slow = head;
        // 判断条件是：slow == fast
        while (slow != fast) {
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}
160、相交链表（简单）

在这里插入图片描述
也是双指针，只不过优化方法比较巧妙：当A走完时，让A再去走B；B走完时，B再去走A，这样就可以保证A、B走的步伐一致，如果有交点，它们肯定会同时到达；如果没有交点A、B总会走到尾部null，也是可以的。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p1 = headA;
        ListNode p2 = headB;
        // 如果不相交，p1 p2最后都会走到null，也会退出循环
        while (p1 != p2) {
            if (p1 == null) {
                // 如果A走到头了，继续走B
                p1 = headB;
            } else {
                p1 = p1.next;
            }
            if (p2 == null) {
                // 如果B走到头了，继续走A
                p2 = headA;
            } else {
                p2 = p2.next;
            }
        }
        // 如果是相交的，那么p1!=null
        // 如果不是相交的，那么p1==null,也是可以的
        return p1;
    }
}

链表二

主要是反转链表的考察，递归、迭代都得会。

206、反转链表（简单）

在这里插入图片描述
递归写法：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
图源：https://labuladong.gitee.io/algo/2/17/17/

写递归函数的关键：相信这个函数、这个函数的作用（返回值）到底是什么，有了这个返回值（作用），我们还需要哪些操作？

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) return head;
        // 将头节点之后的链表反转，并返回反转后的头节点
        ListNode last = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return last;
    }
}

迭代写法：关键用到了三个指针，刚开始只有cur指针指向头节点，其它都是null，三个指针的交换顺序呈现循环状态。

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode nxt = null;
        // 三个指针的交换顺序呈现环状
        while (cur != null) {
            nxt = cur.next;
            cur.next = pre;
            pre = cur;
            cur = nxt;
        }
        // 最后的pre指针就是翻转后的链表的头节点
        return pre;
    }
}
反转链表的前n个节点

递归写法：
在这里插入图片描述
和上一题的区别在于head.next = null，因为只用反转前n个节点，所以还有后驱节点要连接，所以head.next = postNode，与后驱节点相连。

class Solution {
    // 记录后驱节点
    ListNode postNode = null;
    public ListNode reverseList(ListNode head, int n) {
        if (n == 1) {
            // 只有一个节点那么说明head.next为后驱节点
            postNode = head.next;
            return head;
        }
        // 以head.next为起点，需要反转前n-1个节点
        ListNode last = reverseList(head.next, n - 1);
        head.next.next = head;
        // 这里需要考虑存在后驱节点
        head.next = postNode;
        return last;
    }
}
反转链表的一部分

在这里插入图片描述
递归写法：

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        if (left == 1) {
            // 如果开始节点为起点，那就直接是返回开始节点的前right个节点
            return reverseN(head, right);
        }
        // 把head.next视作1号节点，那么left、right都要-1
        head.next = reverseBetween(head.next, left - 1, right - 1);
        return head;
    }

    // 使用反转前n个节点的函数
    // 反转head开始的前n个节点
    ListNode postNode = null;  // 记录后驱节点
    ListNode reverseN(ListNode head, int n) {
        if (n == 1) {
            postNode = head.next;
            return head;
        }
        // 反转以head.next开头的前n - 1个节点
        ListNode last = reverseN(head.next, n - 1);
        head.next.next = head;
        // 连接到后驱节点
        head.next = postNode;
        return last;
    }
}

迭代写法：

/** 反转区间 [a, b) 的元素，注意是左闭右开 */
ListNode reverse(ListNode a, ListNode b) {
    ListNode pre, cur, nxt;
    pre = null; cur = a; nxt = a;
    // while 终止的条件改一下就行了
    while (cur != b) {
        nxt = cur.next;
        cur.next = pre;
        pre = cur;
        cur = nxt;
    }
    // 返回反转后的头结点
    return pre;
}

值得一提的是，递归操作链表并不高效。和迭代解法相比，虽然时间复杂度都是 O(N)，但是迭代解法的空间复杂度是 O(1)，而递归解法需要堆栈，空间复杂度是 O(N)。所以递归操作链表可以作为对递归算法的练习或者拿去和小伙伴装逼，但是考虑效率的话还是使用迭代算法更好。

K个一组翻转链表（困难）

在这里插入图片描述
递归写法：
比较好理解，就是分成几个部分进行翻转，每个部分节点数=k，然后每次翻转完成后，把前后两部分连接起来。
在这里插入图片描述
图源：https://labuladong.gitee.io/algo/2/17/18/

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        if (head == null) return head;
        ListNode a, b;
        a = head;
        b = head;
        // 先看够不够k个节点
        for (int i = 0; i < k; i++) {
            // 不够k个节点就直接返回
            if (b == null) return head;
            b = b.next;
        }
        // 翻转前k个节点，并得到翻转后的头节点
        ListNode newHead = reverse(a, b);
        // 继续反转接着的k个节点，并与之前的翻转 结果连接起来
        a.next = reverseKGroup(b, k);
        return newHead;
    }
    // 翻转[a,b)的节点
    // 注意这里的翻转不能翻转到b，只能翻转到b的上一个节点
    ListNode reverse(ListNode a, ListNode b) {
        ListNode cur = a;
        ListNode pre = null;
        ListNode nxt = null;
        while (cur != b) {
            nxt = cur.next;
            cur.next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }
}

迭代写法：还没看明白，待更！

@u@
关注
专栏目录
算法修炼之路——【链表】Leetcode 86 分区链表
技术更新每天
04-07 211
文章目录题目描述思路分析步骤罗列解题代码复杂度分析GitHub源码 题目描述 给定一链表及一值x,对链表进行分区，使得所有小于x的节点均在 大于等于x节点的之前。 你应当保留节点的初始相对位置。 示例1： 输入： head = [1, 4, 3, 2, 5, 2], x = 3 输出： head = [1, 2, 2, 4, 3, 5] 思路分析 这道题我第一印象就是和插入排序很像，只不过插入...
Leetcode题解记录-链表
后而来者
09-01 407
25. K 个一组翻转链表 给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 示例： 给你这个链表：1->2->3->4->5 当 k = 2 时，应当返回: 2->1->4->3->5 当 k = 3 时，应当返回: 3->2->1->4->5 说明： 你的算法只能使用常数的额外空间。 你不能只是单纯
算法修炼15、反转链表
秉持Love and share的态度去学习和生活
10-16 82
题目描述：   输入一个链表，反转链表后，输出新链表的表头。   解题思路：   本题比较简单，有两种方法可以实现：（1）三指针。使用三个指针，分别指向当前遍历到的结点、它的前一个结点以及后一个结点。将指针反转后，三个结点依次前移即可。（2）递归方法。同样可以采用递归来实现反转。将头结点之后的链表反转后，再将头结点接到尾部即可。   编程实现（Java）： //方法一：三指针 public ListNode ReverseList(ListNode head) {
算法修炼之旋转链表
Code_Pawn的博客
07-12 108
算法修炼之旋转链表一. 题目描述二. 算法分析1. 常规解法2. 循环链表三. 总结 一. 题目描述 leetcode : 旋转链表 给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。 示例 1: 输入: 1->2->3->4->5->NULL, k = 2 输出: 4->5->1->2->3->NULL 解释: 向右旋转 1 步: 5->1->2->3->4->NULL
算法修炼36、两个链表的第一个公共结点
秉持Love and share的态度去学习和生活
10-21 177
题目描述：   输入两个链表，找出它们的第一个公共结点。   解题思路：   本题首先可以很直观的想到蛮力法，即对链表1(假设长度为m)的每一个结点，遍历链表2(假设长度为n)，找有没有与其相同的结点，这显然复杂度为O(mn)。   进一步考虑，我们可以得到以下三种改进的解法：   方法一：借助辅助栈。我们可以把两个链表的结点依次压入到两个辅助栈中，这样两个链表的尾结点就位于两个栈的栈顶，接下来比较两个栈顶的结点是否相同。如果相同，则把栈顶弹出继续比较下一个，直到找到最后一个相同的结点。此方法也很
算法修炼25、复杂链表的复制
秉持Love and share的态度去学习和生活
10-19 128
题目描述：   输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）。   解题思路：   本题有以下三种解法：   第一种：先按照next复制，然后依次添加random指针，添加时需要定位random的位置，定位一次需要一次遍历，需要O（n^2）的复杂度。   第二种：先按照next复制，然后用一个hashmap保存原节点和复制后节点的
算法修炼16、合并两个排序的链表
秉持Love and share的态度去学习和生活
10-16 147
题目描述：   输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。   解题思路：   首先需要判断几个特殊情况，即判断输入的两个指针是否为空。如果第一个链表为空，则直接返回第二个链表；如果第二个链表为空，则直接返回第一个链表。如果两个链表都是空链表，合并的结果是得到一个空链表。   两个链表都是排序好的，我们只需要从头遍历链表，判断当前指针，哪个链表中的值小，即赋给合并链表指针，剩余的结点仍然是排序的，所以合并的步骤和之前是一样的，所以这是典型的递归过程，
算法修炼3、从尾到头打印链表
秉持Love and share的态度去学习和生活
10-15 129
 题目描述：   输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。   解题思路：   (三种方法：借助栈、递归、列表的首位插入)   从头到尾打印链表比较简单，从尾到头很自然的可以想到先将链表进行反转，然后再打印。但是，通常我们不希望改变原链表的结构，这是一个只读操作。   因此，我们进一步分析，可以发现排在后面的先输出，这是一个典型的“后入先出”的思想，因此很自然的可以想到用栈来实现，每遍历一个结点，可以将其压入栈中，遍历结束后再逐个弹栈，将结点值存入ArrayList，这样就
算法修炼14、链表中倒数第k个结点
秉持Love and share的态度去学习和生活
10-16 91
题目描述：   输入一个链表，输出该链表中倒数第k个结点。为了符合习惯，从1开始计数，即链表的尾结点是倒数第1个节点。例如，一个链表有6个结点，从头结点开始，它们的值依次是1,2,3,4,5,6。则这个链表倒数第三个结点是值为4的结点。   解题思路：   对于单链表来说，没有从后向前的指针，因此一个直观的解法是先进行一次遍历，统计出链表中结点的个数n，第二次再进行一次遍历，找到第n-k+1个结点就是我们要找的结点，但是这需要对链表进行两次遍历。   为了实现一次遍历，我们这里采用双指针解法。我们可
算法修炼26、二叉搜索树与双向链表
秉持Love and share的态度去学习和生活
10-19 121
题目描述：   输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。   解题思路：   首先要理解此题目的含义，在双向链表中，每个结点都有前后两个指针；二叉树中，每个结点都有两个指向子结点的左右指针，同时，二叉搜索树树也是一种排序的数据结构。因此，从结构上看，双向链表的前后指针和二叉搜索树的左右指针结构相似，因此，可以实现互相之间的转换。   首先，根据二叉搜索树的特点，左结点的值<根结点的值<右结点的值，据此不难发现，使用
算法修炼之路——【链表】Leetcode 445 两数相加 II
技术更新每天
04-13 340
文章目录题目描述思路分析边界条件考虑解题代码复杂度分析进阶GitHub源码 题目描述 给定两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储单个数字。将这两数相加会返回一个新链表。 你可以假设除了数字0之外，这两个数字都不会以零开头。 示例1： 输入： listA = [7, 2, 4, 3]; listB = [5, 6, 4] 输出： [7, 8, 0, 7] ...
【算法修炼道路】链表的中间节点
Ck_Max的博客
02-21 227
给定一个头结点为 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.nex..
算法修炼之路——【链表】Leetcode142 环检测 II
技术更新每天
03-31 198
文章目录问题描述解题思路解题代码1复杂度分析进阶思考解题代码2复杂度分析GitHub代码 问题描述 给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回null； 为了表示给定链表中的环，我们使用整数 pos来表示链表尾连接到链表中的位置(索引从0开始)。如果pos是-1，则在该链表中没有环。 说明：不允许修改给定的链表 示例1： 输入： head=[3,2,0,-4], pos =...
通达信 移动平均算法_算法一看就懂之 数组与链表
weixin_39854951的博客
10-22 537
(给算法爱好者加星标，修炼编程内功)来源：不止思考数据结构是我们软件开发中最基础的部分了，它体现着我们编程的内功。大多数人在正儿八经学习数据结构的时候估计是在大学计算机课上，而在实际项目开发中，反而感觉到用得不多。其实也不是真的用得少，只不过我们在使用的时候被很多高级语言和框架组件封装好了，真正需要自己去实现的地方比较少而已。但别人封装好了不代表我们就可以不关注了，数据结构作为程序员的内...
数对的最大曼哈顿距离[ABC178E] Dist Max
2301_80882026的博客
10-30 495
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数
Zuoriqiufeng的博客
10-30 398
【代码】代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数。
xtu oj 连接字符串
Go offline for a while
10-30 960
最后总结一下：这题思路比较直观，找公共的元素，代码细节比较多，一个是要求输出字典序小的，第二是前面字符串要枚举完最后一个元素才算满足条件，第三是两个字符串可能完全没有公共部分，需要特判。
数据结构初阶排序全解
最新发布
枫の大一分享
11-03 711
排序顾名思义，就是将一组乱序的数，按从大到小或者从小到大进行排列的操作。常见的排序如下可以看到排序也是有分类的，既然有分类，那么这边给出宝子们一个思考，在最后测试的时候给出答案，思考1：排序方法这么多，哪个最好呢？最差的有什么用呢？那么废话不多说，今天的重点内容就是理解并写出一个个排序算法，现在直接上高速，带着宝子们攻破一个个排序算法！这边给出各个排序算法的声明，会在对应内容进行解释，宝子们先有个印象即可~~今天讲解了各种类型的排序算法，最常用的还是时间复杂度最小的堆排序、快排、归并排序。
【力扣打卡系列】二分查找(搜索旋转排序数组)
qq_45734745的博客
10-29 301
坚持按题型打卡&刷&梳理力扣算法题系列，语言为go，Day11。
JavaScript数据结构与算法：链表详解
2. **静态链表**：静态链表是用数组实现的链表，每个数组元素包含数据和指向下一个元素的索引。这种方式结合了数组和链表的特点，但在插入和删除时仍需移动元素。 3. **循环链表**：循环链表的最后一个节点指向链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@u@

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值