编程导航算法通关村第一关 | 链表高频算法题

最新推荐文章于 2024-07-19 19:11:19 发布
最新推荐文章于 2024-07-19 19:11:19 发布
阅读量94 收藏
点赞数
文章标签： 算法 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mamba_Stan/article/details/131900878
版权

1. 两个链表的第一个公共子节点问题

输入两个链表，找出它们的第一个公共节点。例如下面的两个链表：
在这里插入图片描述
两个链表的头结点都是已知的，相交之后成为一个单链表，但是相交的位置未知，并且相交之前的结点数也是未知的，请设计算法找到两个链表的合并点。

1.1 哈希和集合

先将一个链表元素全部存到Map里, 然后一边遍历第二个第二个链表, 一边检测Hash中是否存在当前节点, 如果有交点, 那么一定能够检测出来。对于本题, 使用集合更加适合, 代码也更加整洁。

 /**
   * 使用集合找出两个链表的第一个公共子节点
   * @param headA
   * @param headB
   * @return
   */
  public ListNode findFirstCommonNodeBySet(ListNode headA, ListNode headB) {
    Set<ListNode> set = new HashSet<>();
    // 先遍历链表A, 将所有节点保存到set集合中
    while (headA != null) {
      set.add(headA);
      headA = headA.next;
    }
    
    // 再遍历链表B, 判断set集合中是否包含链表B的节点
    while (headB != null) {
      if (set.contains(headB)) {
        return headB;
      }
      headB = headB.next;
    }
    
    return null;
  }

1.2 使用栈

分别将两个链表压入两个栈中, 然后同时出栈, 如果相同就继续出栈, 一直找到最晚出栈的那一组。

图示:
在这里插入图片描述

代码实现:

/**
   * 使用栈找出两个链表的第一个公共子节点
   * @param headA
   * @param headB
   * @return
   */
  public ListNode findFirstCommonNodeByStack(ListNode headA, ListNode headB) {
    Stack<ListNode> stackA = new Stack<>();
    Stack<ListNode> stackB = new Stack<>();
    // 将两个链表分别压入两个栈中
    while (headA != null) {
      stackA.push(headA);
      headA = headA.next;
    }
    while (headB != null) {
      stackB.push(headB);
      headB = headB.next;
    }
    // 从两个栈中同时弹出节点,直到最后一个相同的节点即为第一个公共子节点 (如果第一个就不同, 说明两个链表没有公共节点)
    ListNode preNode = null;
    while (stackA.size() > 0 && stackB.size() > 0) {
      if (stackA.peek() == stackB.peek()) {
        preNode = stackA.pop();
        stackB.pop();
      }else {
        break;
      }
    }
    return preNode;
  }

1.3 拼接两个字符串

将链表A和B拼接形成两个新链表, 新链表形式为AB和BA, 通过这种方式消除了两个链表非公共部分长度差, 分别遍历两个链表, 出现的第一个相同节点即为第一个公共子节点。

图示:
在这里插入图片描述

代码实现:

  /**
   * 思路: 将两个链表拼接成AB和BA形式
   * 通过拼接消除非公共部分长度差 (因为两个链表有公共子节点, 拼接后, 新形成的两个链表长度一致, 所以链表的公共部分就都到了后面)
   * @param headA
   * @param headB
   * @return
   */
  public ListNode findFirstCommonNode(ListNode headA, ListNode headB) {
    if (headA == null || headB == null) {
      return null;
    }
    ListNode p1 = headA;
    ListNode p2 = headB;
    // 
    while (p1 != p2) {
      p1 = p1.next;
      p2 = p2.next;
      if (p1 != p2) { // 这里加判断是为了防止不存在交集的两个链表进入死循环
        // 一个链表访问完了就跳到另一个链表继续访问 (模拟两个链表拼接)
        if (p1 == null) {
          p1 = headB;
        }
        if (p2 == null) {
          p2 = headA;
        }
      }
    }
    return p1;
  }

1.4 差和双指针

思路和拼接字符串方法类似, 只不过该方法不是消除非公共部分长度差, 而是先让长的那个链表先遍历两个链表的长度差, 再同时遍历, 第一个相同的节点即为第一个公共子节点。

/**
     * 方法5：通过差值来实现
     *
     * @param pHead1
     * @param pHead2
     * @return
     */
    public static ListNode findFirstCommonNodeBySub(ListNode pHead1, ListNode pHead2) {
        if (pHead1 == null || pHead2 == null) {
            return null;
        }
        // 计算两个链表的长度
        ListNode current1 = pHead1;
        ListNode current2 = pHead2;
        int l1 = 0, l2 = 0;
        while (current1 != null) {
            current1 = current1.next;
            l1++;
        }

        while (current2 != null) {
            current2 = current2.next;
            l2++;
        }
        current1 = pHead1;
        current2 = pHead2;

        // 两个链表的长度差
        int sub = l1 > l2 ? l1 - l2 : l2 - l1;

        // 长度较长的先遍历长度差个节点
        if (l1 > l2) {
            int a = 0;
            while (a < sub) {
                current1 = current1.next;
                a++;
            }
        }

        if (l1 < l2) {
            int a = 0;
            while (a < sub) {
                current2 = current2.next;
                a++;
            }
        }

        // 同时遍历两个链表
        while (current2 != current1) {
            current2 = current2.next;
            current1 = current1.next;
        }

        return current1;
    }

2. 判断两个链表是否为回文链表

示例：
输入: 1->2->2->1
输出: true

2.1 使用栈实现

将链表元素全部压栈, 然后一边出栈, 一边重新遍历链表, 比较两者元素值, 只要有一个不相等, 就不是回文链表。

图示:
在这里插入图片描述

代码实现:

 /**
     * 全部压栈
     *
     * @param head
     * @return
     */
    public static boolean isPalindromeByAllStack(ListNode head) {
        ListNode temp=  head;
        Stack<Integer> stack = new Stack<>();
        while (temp != null) {
            stack.push(temp.val);
            temp = temp.next;
        }
        
        while (stack.size() > 0) {
            if (head.val != stack.pop()) {
                return false;
            }
            temp = head.next;
        }
        
        return true;
    }

优化:
先得到链表的总长度, 之后一边遍历链表, 一边压栈。到达链表长度一半后就不再压栈, 而是一边出栈, 一边继续遍历链表, 同时比较两者元素值, 只要有一个不相等, 就不是回文链表, 这样可以节省一半的空间。

在这里插入图片描述

/**
     * 只将一半的数据压栈
     *
     * @param head
     * @return
     */
    public static boolean isPalindromeByHalfStack(ListNode head) {
        if (head == null) {
            return true;
        }
        ListNode temp = head;
        Stack<Integer> stack = new Stack<>();
        // 链表长度
        int length = 0;
        while (temp != null) {
            // 将链表节点的值压入栈中
            stack.push(temp.val);
            temp = temp.next;
            length++;
        }
        // 链表长度除以2
        length >>= 1;
        while (length-- >= 0) {
            if (head.val != stack.pop()) {
                return false;
            }
            head = head.next;
        }
        return true;
    }

2.2 反转链表法

将原链表逆序保存到一个新链表中, 然后重新一边遍历两个链表，一遍比较元素的值，只要有一个位置的元素值不一样，就不是回文链表。

/**
     * 反转链表法
     *
     * @param head
     * @return
     */
    public static boolean isPalindromeByReverse(ListNode head) {
        // 将链表反转
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode temp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = temp;
        }
        // 遍历两个链表并比较元素值
        while (prev != null && head != null) {
            if (prev.val != head.val) {
                return false;
            }
            prev = prev.next;
            head = head.next;
        }
        return true;
    }

优化:
使用快慢指针, 快指针一次走两步, 慢指针一次走一步。当快指针到达表尾的时候, 慢指针正好到达一半的地方, 那么接下来可以从头开始逆序一半的元素，或者从slow开始逆序一半的元素，都可以。

/**
     * 通过双指针的方式来判断
     *
     * @param head
     * @return
     */
    public static boolean isPalindromeByTwoPoints(ListNode head) {
        if (head == null || head.next == null) {
            return true;
        }
        // 定义快慢指针
        ListNode fast = head, slow = head;
        ListNode curr = head, prev = null;
        while (fast != null && fast.next != null) {
            curr = slow;
            slow = slow.next;
            fast = fast.next.next;
            curr.next = prev;
            prev = curr;
        }
        // fast指针走到倒数第二个节点的情况
        if (fast != null) {
            slow = slow.next;
        }
        while (curr != null && slow != null) {
            if (curr.val != slow.val) {
                return false;
            }
            curr = curr.next;
            slow = slow.next;
        }
        return true;
    }

3. 合并有序链表

3.1 合并两个有序链表

将两个升序链表合并为一个新的升序链表并返回，新链表是通过拼接给定的两个链表的所有节点组成的。

解决思路:

新建一个链表, 分别遍历两个链表, 每次将最小的那个节点接到新链表上。

/**
     *
     * @param list1
     * @param list2
     * @return
     */
    public static ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode current = new ListNode(-1);
        // 虚拟头节点
        ListNode newHead = current;
        while (list1 != null && list2 != null) {
            if (list1.val < list2.val) {
                current.next = list1;
                // 链表1接着遍历, 链表2暂不遍历, 等待链表1下一个节点继续比较元素值
                list1 = list1.next;
            } else {
                current.next = list2;
                list2 = list2.next;
            }
            current = current.next;
        }
        //下面的两个while最多只有一个会执行
        while (list2 != null) {
            current.next = list2;
            list2 = list2.next;
            current = current.next;
        }
        while (list1 != null) {
            current.next = list1;
            list1 = list1.next;
            current = current.next;
        }
        return newHead.next;
    }

优化代码:

最后的两个while循环最多只会执行一个, 所以只需要判断哪一个链表不为空, 并将那一个链表后面的部分全部接入新链表表尾即可。

 /**
     * 优化后的实现方法
     *
     * @param list1
     * @param list2
     * @return
     */
    public static ListNode mergeTwoListsMoreSimple(ListNode list1, ListNode list2) {
        ListNode current = new ListNode(-1);
        // 虚拟头节点
        ListNode newHead = current;
        while (list1 != null && list2 != null) {
            if (list1.val < list2.val) {
                current.next = list1;
                // 链表1接着遍历, 链表2暂不遍历, 等待链表1下一个节点继续比较元素值
                list1 = list1.next;
            } else {
                current.next = list2;
                list2 = list2.next;
            }
            current = current.next;
        }
        // 最多只有一个还未被合并完，直接接上去就行了,这是链表合并比数组合并方便的地方
        current.next = list1 == null ? list2 : list1;
        return newHead.next;
    }

3.2 合并K个链表

在合并两个链表的基础上, 先将前两个链表合并, 之后再将后面的链表逐步合并起来即可。

/**
     * 合并K个链表
     *
     * @param lists
     * @return
     */
    public static ListNode mergeKLists(ListNode[] lists) {
        ListNode res = null;
        for (ListNode list : lists) {
            res = mergeTwoListsMoreSimple(res, list);
        }
        return res;
    }

4 双指针

4.1 寻找中间节点

给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

示例1
输入：[1,2,3,4,5]
输出：此列表中的结点 3
示例2：
输入：[1,2,3,4,5,6]
输出：此列表中的结点 4

使用快慢指针, 慢指针一次走一步, 快指针一次走两步。当快指针到达表尾时, 慢指针必然位于中间位置。

/**
     * 寻找中间节点
     * @param head
     * @return
     */
    public static ListNode middleNode(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }

4.2 寻找倒数第K个元素

输入一个链表，输出该链表中倒数第k个节点。本题从1开始计数，即链表的尾节点是倒数第1个节点。

示例
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.

使用快慢指针, 先将快指针向后遍历到 k + 1个, 慢指针仍然指向链表的第一个节点, 此时两个指针之间刚好间隔 k 个节点。之后两个指针同时向后走, 当快指针到达链表的尾部空节点时, 慢指针刚好指向链表的倒数第 k 个节点。

在这里插入图片描述

代码实现:

/**
     * 找链表倒数第K个结点
     * @param head
     * @param k
     * @return
     */
    public static ListNode getKthFromEnd(ListNode head, int k) {
       ListNode fast = head, slow = head;
        while (fast != null && k-- > 0 ) {
            fast = fast.next;
        }
        while (fast != null) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }

4.3 旋转链表

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

示例1:
输入：head = [1,2,3, 4,5], k = 2
输出：[4,5,1,2,3]

思路:

先使用双指针策略找到倒数 k 的位置, 将 倒数 k 位置前的部分断开并接入到表尾。

需要注意的是:

k可能大于链表长度, 所以首先应获取到链表长度len, 如果 k % len == 0, 则不用旋转, 直接返回头节点。
在这里插入图片描述

实现步骤:

  1. 快指针先走 k 步
  2. 慢指针和快指针一起走
  3. 快指针到达链表尾部时, 慢指针所在位置刚好是要断开的位置。将快指针指向的节点连到原链表头部, 慢指针指向的节点断开和下一个节点的联系 (指向 null 即可)
  4. 返回结束时慢指针指向节点的下一个节点

代码实现:

/**
     * 旋转链表
     * @param head
     * @param k
     * @return
     */
    public static ListNode rotateRight(ListNode head, int k) {
        if (head == null || k == 0) {
            return head;
        }
        // 获取链表长度
        int len = 0;
        ListNode temp = head;
        while (head != null) {
            len++;
            head = head.next;
        }
        head = temp;
        if (k % len == 0) {
            return head;
        }
        ListNode fast = head, slow = head;
        // 1. 快指针先走 k 步
        while ( (k % len) > 0) {
            k--;
            fast = fast.next;
        }
        // 2. 慢指针和快指针一起走
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        // 3. 快指针到达链表尾部时, 慢指针所在位置刚好是要断开的位置。将快指针指向的节点连到原链表头部, 慢指针指向的节点断开和下一个节点的联系 (指向 null 即可)
        fast.next = head;
        temp = slow.next;
        slow.next = null;
        // 4. 返回结束时慢指针指向节点的下一个节点
        return temp;
    }

5. 删除链表元素

5. 1 删除特定节点

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回新的头节点 。

示例1：
输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

遍历链表, 找出满足要求的节点, 将该节点的前驱节点指向该节点的下一个节点, 该节点会在某个时刻被gc回收掉。

实现步骤:

  1. 创建一个虚拟链表头节点dummyHead, 使其next指向head
  2. 开始循环链表寻找目标元素
  3. 找到目标元素, 就使用cur.next = cur.next.next来删除
  4. 最后返回dummyHead.next

代码实现:

/**
     * 删除特定值的结点
     *
     * @param head
     * @param val
     * @return
     */
    public static ListNode removeElements(ListNode head, int val) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode temp = dummyHead;
        while (temp.next != null) {
            if (temp.next.val == val) {
                temp.next = temp.next.next;
            } else {
                temp = temp.next;
            }
        }
        return dummyHead.next;
    }

5.2 删除倒数第 n 个节点

给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。

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

方法1: 计算链表长度

首先遍历一次链表, 得到链表的长度 L, 然后重新遍历链表, 当遍历到 L - n + 1 个节点时, 就是我们要删除的节点。

代码实现:

 /**
     * 方法1：利用链表长度
     *
     * @param head
     * @param n
     * @return
     */
    public static ListNode removeNthFromEndByLength(ListNode head, int n) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        int length = getLength(head);
        ListNode current = head;
        int index = 1;
        while (index++ != length - n) {
            current = current.next;
        }
        current.next = current.next.next;
        return dummyHead.next;
    }

方法2: 双指针

快指针先走 n 步, 然后两个指针同时向前走, 当快指针走到队尾的时候, 慢指针所指向的就是我们要找的节点。

代码实现:

/**
     * 方法2：通过双指针
     *
     * @param head
     * @param n
     * @return
     */
    public static ListNode removeNthFromEndByTwoPoints(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode fast = head, slow = dummy;
        while (fast != null && n-- > 0) {
            fast = fast.next;
        }
        while (fast != null) {
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return dummy.next;
    }

5.3 删除重复节点

5.3.1 重复元素保留一个

存在一个按升序排列的链表，请你删除所有重复的元素，使每个元素只出现一次。

示例1：
输入：head = [1,1,2,3,3]
输出：[1,2,3]

思路:

由于给定的链表是排好序的, 因此重复的元素在链表中的位置是连续的, 因此我们只需要对链表进行一次遍历就可以删除重复的元素。具体
地, 从头节点开始遍历, 如果当前节点 cur 与 cur.next 的元素相同, 我们就将cur.next从链表中删除; 否则说明链表中已经不存在其他与cur对应元素相同的节点, 因此可以将cur指向cur.next。

代码实现:

 /**
     * 重复元素保留一个
     *
     * @param head
     * @return
     */
    public static ListNode deleteDuplicate(ListNode head) {
        if (head == null) {
            return head;
        }
        ListNode cur = head;
        while (cur.next != null) {
            if (cur.val == cur.next.val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        return head;
    }

5.3.3 重复元素都不要

存在一个按升序排列的链表，请你删除链表中所有存在数字重复情况的节点，只保留原始链表中没有重复出现的数字。

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

思路:

当一个都不要时，链表只要直接对cur.next 以及 cur.next.next 两个node进行比较就行了，这里要注意两个node可能为空，稍加判断就行了。

代码实现:

 /**
     * 重复元素都不要
     *
     * @param head
     * @return
     */
    public static ListNode deleteDuplicates(ListNode head) {
        if (head == null) {
            return head;
        }
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode current = dummyHead;
        // 从头节点开始比较
        while (current.next != null & current.next.next !=null) {
            if (current.next.val == current.next.next.val) {
                int x = current.next.val;
                while (current.next != null && current.next.val == x) {
                    current.next = current.next.next;
                }
            }else {
                current = current.next;
            }
        }
        return dummyHead.next;
    }
Mamba_Stan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
算法通关村第一关-链表青铜挑战笔记
10-28
源代码
LeetCode高频算法面试题,含解题思路及代码实现
02-17
这个压缩包文件"leetcode"很可能包含了这些热门算法题目的解题思路和代码实现，这对于提升编程技能和应对面试至关重要。 1. **数据结构**：在LeetCode中，常见数据结构包括数组、链表、栈、队列、哈希表、二叉树等...
编程导航算法通关村第1关 | 链表高频面试算法题
qq_53342601的博客
07-22 132
val = x;} }
算法通关村第 1 关 | 链表高频算法题——两个链表的第一个公共节点
GallenZzz的博客
07-18 132
链表高频算法题——两个链表的第一个公共节点
编程导航算法通关村第二关 | 指定区间反转问题
aiermaAIERMA的博客
09-01 647
上回说到链表反转是学历链表的重中之重，而链表反转的拓展问题更是高频问题，本文来集中研究一下。
算法通关村第一关—链表白银挑战笔记 链表高频面试算法题
weixin_43910861的博客
07-26 280
当fast到达表尾的时候，slow正好到达一半的位置，那么接下来可以从头开始逆序一半的元素，或者从slow开始逆序一半的元素，都可以。让链表长的L1减去链表短的L2得到一个差值|L1-L2|，让L1先走|L1-L2|的步，此时L1和L2的长度已经是一致了，接下来，L1和L2同时向前走，直到遇到第一个相同的结点。常用的数据结构有数组、链表、队、栈、Hash、集合、树、堆。链表A和链表B同时推入两个栈中，再用时出栈，如果出栈的元素相等，则继续出栈，直到出栈元素不同，则上一个元素就是第一个相同的节点。
算法通关村第一关|白银挑战——链表高频面试算法题
m0_63690778的博客
12-12 1673
遇到问题时首先将常用的数据结构和算法思想都想一遍常见的数据结构有数组，链表，队，栈，Hash，集合，树，堆，常见的算法思想有查找，排序，双指针，递归，迭代，分治，贪心，回溯和动态规划。
编程导航算法通关第1关|白银教程 学习
qq_74092815的博客
11-29 153
本章节主要总结了关于单链表的高频面试题。
算法通关村第一关—链表高频面试题(白银)
孤舟一叶～的博客
11-30 146
1.首先想到的是暴力解，将第一个链表中的每一个结点依次与第二个链表的进行比较，当出现相等的结点指针时，即为相交结点。虽然简单，但是时间复杂度高，排除2.Hash,先将第一个链表元素全部存到Map里，然后一边遍历第二个链表，一边检测当前元素是否在Hash中，如果两个链表有交点，那就找到了。OK,第二种方法出来了。3.既然Hash可以，那集合呢？和Hash一样用，也能解决，OK,第三种方法出来了。4.队列和栈呢？这里用队列没啥用，但用栈呢？
算法通关村 | 第二关 | 青铜篇（链表反转）
努力成为更好的自己~~~
07-21 116
本关的主题是 “链表反转” ，包括了关于链表反转的一系列问题，如普通的单链表直接反转、指定区间的反转、两两交换链表的结点等。
算法通关村 | 第一关 | 白银挑战篇 上
努力成为更好的自己~~~
07-16 402
链表专题简单算法题的讲解和实战
python算法题 链表反转详解
01-20
链表的反转是一个很常见、很基础的数据结构题，输入一个单向链表，输出逆序反转后的链表，如图：上面的链表转换成下面的链表。实现链表反转有两种方式，一种是循环迭代，另外一种方式是递归。 第一种方式：循坏...
【18】输出字符菱形
2301_78786609的博客
07-19 185
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Held-Karp算法的C++代码
最新发布
m0_61862494的博客
07-19 103
Held-Karp算法是动态规划的一种应用，用于解决旅行商问题 (TSP)。该算法通过记录部分路径的最小成本来避免重复计算，从而有效地降低计算复杂度。Held-Karp算法使用一个状态压缩动态规划表。表示从起点出发，访问过所有由。表示的集合中的节点，并以节点。结束的最小路径长度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 165
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
常见的排序算法，复杂度
m0_61544805的博客
07-16 460
稳定 / 非稳定排序：两个相等的数 排序前后 相对位置不变。 插入排序（希尔排序）： 每一趟将一个待排序记录，按其关键字的大小插入到已排好序的一组记录的适当位置上，直到所有待排序记录全部插入为止。稳定，O(n)，O(1)。 把记录按下标增量（模）分组，对每组进行直接插入排序，每次排序后减小增量，当增量减至 1 时排序完毕。不稳定，不知道（有个实验结论），O(1)。 冒泡排序： 比较相邻的元素，如果第一个比第二个大就进行交换，对每一对相邻元素做同样的工作。稳定，O(n)，O(1)。 选择
树与二叉树
2201_76027754的博客
07-15 790
树和二叉树
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 133
完全二叉树的节点个数-递归
2023年大厂前端面试高频算法题：合并有序链表
在2023年的前端求职面试中，算法题作为高频考点，对于理解和解决这类问题至关重要。本篇内容主要关注于合并两个有序链表的问题，这是一个经典的编程题目，常用于考察面试者的数据结构和递归/迭代思维。 题⽬描述： ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值