【戊】链表

最新推荐文章于 2025-04-06 16:11:58 发布
最新推荐文章于 2025-04-06 16:11:58 发布
阅读量226 收藏 1
点赞数
分类专栏： leetcode 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42886721/article/details/106958406
版权

文章目录


链表是空节点，或者有一个值和一个指向下一个链表的指针，因此很多链表问题可以用递归来处理。

部分转自：

1. 找出两个链表的交点

160. Intersection of Two Linked Lists (Easy)

Leetcode / 力扣

例如以下示例中 A 和 B 两个链表相交于 c1：

A:          a1 → a2
                    ↘
                      c1 → c2 → c3
                    ↗
B:    b1 → b2 → b3

但是不会出现以下相交的情况，因为每个节点只有一个 next 指针，也就只能有一个后继节点，而以下示例中节点 c 有两个后继节点。

A:          a1 → a2       d1 → d2
                    ↘  ↗
                      c
                    ↗  ↘
B:    b1 → b2 → b3        e1 → e2

要求时间复杂度为 O(N)，空间复杂度为 O(1)。如果不存在交点则返回 null。

设 A 的长度为 a + c，B 的长度为 b + c，其中 c 为尾部公共部分长度，可知 a + c + b = b + c + a。

当访问 A 链表的指针访问到链表尾部时，令它从链表 B 的头部开始访问链表 B；同样地，当访问 B 链表的指针访问到链表尾部时，令它从链表 A 的头部开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。

如果不存在交点，那么 a + b = b + a，以下实现代码中 l1 和 l2 会同时为 null，从而退出循环。

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    ListNode l1 = headA, l2 = headB;
    while (l1 != l2) {
        l1 = (l1 == null) ? headB : l1.next;
        l2 = (l2 == null) ? headA : l2.next;
    }
    return l1;
}

如果只是判断是否存在交点，那么就是另一个问题，即 编程之美 3.6 的问题。有两种解法：

  • 把第一个链表的结尾连接到第二个链表的开头，看第二个链表是否存在环；
  • 或者直接比较两个链表的最后一个节点是否相同。

1.1判断链表是否有环

有的问题的隐藏问题其实是判断链表是否有环,比如

202. 快乐数

使用hash或快慢指针可以判断

class Solution {
    public boolean isHappy(int n) {
        int fast = getNext(n);
        int slow = n;
        while(fast != slow && fast != 1){
            slow = getNext(slow);
            fast = getNext(fast);
            fast = getNext(fast);
        }
        return fast==1;
    }

    private int getNext(int num) {
        int res = 0;
        while(num != 0){
            res += (num % 10) * (num % 10);
            num /= 10;
        }
        return res;
    }
}

hash

def isHappy(self, n: int) -> bool:

    def get_next(n):
        total_sum = 0
        while n > 0:
            n, digit = divmod(n, 10)
            total_sum += digit ** 2
        return total_sum

    seen = set()
    while n != 1 and n not in seen:
        seen.add(n)
        n = get_next(n)

    return n == 1

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/happy-number/solution/kuai-le-shu-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2. 链表反转

206. Reverse Linked List (Easy)

Leetcode / 力扣

递归

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

头插法

public ListNode reverseList(ListNode head) {
    ListNode newHead = new ListNode(-1);
    while (head != null) {
        ListNode next = head.next;
        head.next = newHead.next;
        newHead.next = head;
        head = next;
    }
    return newHead.next;
}

3. 归并两个有序的链表

21. Merge Two Sorted Lists (Easy)

Leetcode / 力扣

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    if (l1 == null) return l2;
    if (l2 == null) return l1;
    if (l1.val < l2.val) {
        l1.next = mergeTwoLists(l1.next, l2);
        return l1;
    } else {
        l2.next = mergeTwoLists(l1, l2.next);
        return l2;
    }
}

4. 从有序链表中删除重复节点

83. Remove Duplicates from Sorted List (Easy)

Leetcode / 力扣

Given 1->1->2, return 1->2.
Given 1->1->2->3->3, return 1->2->3.

public ListNode deleteDuplicates(ListNode head) {
    if (head == null || head.next == null) return head;
    head.next = deleteDuplicates(head.next);
    return head.val == head.next.val ? head.next : head;
}

5. 删除链表的倒数第 n 个节点

19. Remove Nth Node From End of List (Medium)

Leetcode / 力扣

Given linked list: 1->2->3->4->5, and n = 2.
After removing the second node from the end, the linked list becomes 1->2->3->5.

public ListNode removeNthFromEnd(ListNode head, int n) {
    ListNode fast = head;
    while (n-- > 0) {
        fast = fast.next;
    }
    if (fast == null) return head.next;
    ListNode slow = head;
    while (fast.next != null) {
        fast = fast.next;
        slow = slow.next;
    }
    slow.next = slow.next.next;
    return head;
}

5.1 删除值为某数的节点

203. 移除链表元素

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode pre = new ListNode(-1);
        pre.next = head;
        ListNode res = pre;
        while(head != null){
            if(head.val == val){
                pre.next = head.next;
                head = pre.next;
                continue;
            }
            head = head.next;
            pre = pre.next;

        }
        return res.next;
    }
}

6. 交换链表中的相邻结点

24. Swap Nodes in Pairs (Medium)

Leetcode / 力扣

Given 1->2->3->4, you should return the list as 2->1->4->3.

题目要求：不能修改结点的 val 值，O(1) 空间复杂度。

public ListNode swapPairs(ListNode head) {
    ListNode node = new ListNode(-1);
    node.next = head;
    ListNode pre = node;
    while (pre.next != null && pre.next.next != null) {
        ListNode l1 = pre.next, l2 = pre.next.next;
        ListNode next = l2.next;
        l1.next = next;
        l2.next = l1;
        pre.next = l2;

        pre = l1;
    }
    return node.next;
}

7. 链表求和

445. Add Two Numbers II (Medium)

Leetcode / 力扣

Input: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
Output: 7 -> 8 -> 0 -> 7

题目要求：不能修改原始链表。

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    Stack<Integer> l1Stack = buildStack(l1);
    Stack<Integer> l2Stack = buildStack(l2);
    ListNode head = new ListNode(-1);
    int carry = 0;
    while (!l1Stack.isEmpty() || !l2Stack.isEmpty() || carry != 0) {
        int x = l1Stack.isEmpty() ? 0 : l1Stack.pop();
        int y = l2Stack.isEmpty() ? 0 : l2Stack.pop();
        int sum = x + y + carry;
        ListNode node = new ListNode(sum % 10);
        node.next = head.next;
        head.next = node;
        carry = sum / 10;
    }
    return head.next;
}

private Stack<Integer> buildStack(ListNode l) {
    Stack<Integer> stack = new Stack<>();
    while (l != null) {
        stack.push(l.val);
        l = l.next;
    }
    return stack;
}

8. 回文链表

234. Palindrome Linked List (Easy)

Leetcode / 力扣

题目要求：以 O(1) 的空间复杂度来求解。

切成两半，把后半段反转，然后比较两半是否相等。

public boolean isPalindrome(ListNode head) {
    if (head == null || head.next == null) return true;
    ListNode slow = head, fast = head.next;
    while (fast != null && fast.next != null) {
        slow = slow.next;
        fast = fast.next.next;
    }
    if (fast != null) slow = slow.next;  // 偶数节点，让 slow 指向下一个节点
    cut(head, slow);                     // 切成两个链表
    return isEqual(head, reverse(slow));
}

private void cut(ListNode head, ListNode cutNode) {
    while (head.next != cutNode) {
        head = head.next;
    }
    head.next = null;
}

private ListNode reverse(ListNode head) {
    ListNode newHead = null;
    while (head != null) {
        ListNode nextNode = head.next;
        head.next = newHead;
        newHead = head;
        head = nextNode;
    }
    return newHead;
}

private boolean isEqual(ListNode l1, ListNode l2) {
    while (l1 != null && l2 != null) {
        if (l1.val != l2.val) return false;
        l1 = l1.next;
        l2 = l2.next;
    }
    return true;
}

9. 分隔链表

725. Split Linked List in Parts(Medium)

Leetcode / 力扣

Input:
root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
Output: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
Explanation:
The input has been split into consecutive parts with size difference at most 1, and earlier parts are a larger size than the later parts.

题目描述：把链表分隔成 k 部分，每部分的长度都应该尽可能相同，排在前面的长度应该大于等于后面的。

public ListNode[] splitListToParts(ListNode root, int k) {
    int N = 0;
    ListNode cur = root;
    while (cur != null) {
        N++;
        cur = cur.next;
    }
    int mod = N % k;
    int size = N / k;
    ListNode[] ret = new ListNode[k];
    cur = root;
    for (int i = 0; cur != null && i < k; i++) {
        ret[i] = cur;
        int curSize = size + (mod-- > 0 ? 1 : 0);
        for (int j = 0; j < curSize - 1; j++) {
            cur = cur.next;
        }
        ListNode next = cur.next;
        cur.next = null;
        cur = next;
    }
    return ret;
}

10. 链表元素按奇偶聚集

328. Odd Even Linked List (Medium)

Leetcode / 力扣

Example:
Given 1->2->3->4->5->NULL,
return 1->3->5->2->4->NULL.


public ListNode oddEvenList(ListNode head) {
    if (head == null) {
        return head;
    }
    ListNode odd = head, even = head.next, evenHead = even;
    while (even != null && even.next != null) {
        odd.next = odd.next.next;
        odd = odd.next;
        even.next = even.next.next;
        even = even.next;
    }
    odd.next = evenHead;
    return head;
}

奇偶链表

328. 奇偶链表

  • 边界情况的谈论切忌复杂，本题even永远在odd后面，所以只关注这一个即可
public class Solution {
    public ListNode oddEvenList(ListNode head) {
        if (head == null) return null;
        ListNode odd = head, even = head.next, evenHead = even;
        while (even != null && even.next != null) {
            odd.next = even.next;
            odd = odd.next;
            even.next = odd.next;
            even = even.next;
        }
        odd.next = evenHead;
        return head;
    }
}

旋转链表

61. 旋转链表
给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非
负数。

  • 使用循环移动法简单
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if (head == null) return null;
        ListNode prev = head;
        // 记录长度
        int length = 1;
        while (prev.next != null) {
            prev = prev.next;
            length++;
        }
        //将链表变成圈状，方便循环移位，太巧妙了
        prev.next = head;
        // k是可以大于长度的，所以循环取模
        int n = length - k % length;
        while (--n >= 0) {
            prev = prev.next;
        }
        head = prev.next;
        prev.next = null;
        return head;
    }
}

链表合并

合并两个有序链表

可以使用递归或迭代

private ListNode merge2Lists(ListNode l1, ListNode l2) {
    if (l1 == null) {
        return l2;
    }
    if (l2 == null) {
        return l1;
    }
    if (l1.val < l2.val) {
        l1.next = merge2Lists(l1.next, l2);
        return l1;
    }
    l2.next = merge2Lists(l1, l2.next);
    return l2;
}

使用一个哑节点非常方便

private ListNode merge2Lists(ListNode l1, ListNode l2) {
    ListNode dummyHead = new ListNode(0);
    ListNode tail = dummyHead;
    while (l1 != null && l2 != null) {
        if (l1.val < l2.val) {
            tail.next = l1;
            l1 = l1.next;
        } else {
            tail.next = l2;
            l2 = l2.next;
        }
        tail = tail.next;
    }
    tail.next = l1 == null? l2: l1;

    return dummyHead.next;
}

其他

合并k个链表

比较好的方法：
1.两两合并

  1. 迭代
  2. 递归

2.优先级队列

下面是代码
1.1
//方法非常好，从头到尾两两组队,且是原地合并

class Solution {
      public ListNode mergeKLists(ListNode[] lists) {
            if(lists.length < 1) return null;
            //法1：分治
            int k = lists.length;
            //方法非常好，从头到尾两两组队,且是原地合并
            while(k > 1){
                  int cur = 0;
                  for (int i = 0; i < k; i+=2) {
                        if(i==k-1) lists[cur++] = lists[i];
                        else lists[cur++] = merge2Lists(lists[i],lists[i+1]); 
                  }
                  k = cur;
            }
            return lists[0];
      }
      
      private ListNode merge2Lists(ListNode l1, ListNode l2) {
            if (l1 == null) {
                  return l2;
            }
            if (l2 == null) {
                  return l1;
            }
            if (l1.val < l2.val) {
                  l1.next = merge2Lists(l1.next, l2);
                  return l1;
            }
            l2.next = merge2Lists(l1, l2.next);
            return l2;
      }
}

1.2
就是一个简单的归并。

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) {
            return null;
        }
        return merge(lists, 0, lists.length - 1);
    }

    private ListNode merge(ListNode[] lists, int lo, int hi) {
        if (lo == hi) {
            return lists[lo];
        }
        int mid = lo + (hi - lo) / 2;
        ListNode l1 = merge(lists, lo, mid);
        ListNode l2 = merge(lists, mid + 1, hi);
        return merge2Lists(l1, l2);
    }
}

作者：sweetiee
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/4-chong-fang-fa-xiang-jie-bi-xu-miao-dong-by-sweet/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

2
特殊情况：双null
lists是个null
lists里面的元素是null

class Solution {
      public ListNode mergeKLists(ListNode[] lists) {
            ListNode d = new ListNode(-1);
            ListNode res = d;
            Queue<ListNode> pq = new PriorityQueue<>((l1,l2)->l1.val-l2.val);
            for (int i = 0; i < lists.length; i++) {
                if(lists[i] != null)  //一定要主意测试用例里面的情况
                    pq.offer(lists[i]);
            }
            while(!pq.isEmpty()){
                  ListNode t =  pq.poll();
                  d.next = t;
                  d = t;
                  if(t.next != null){
                        pq.offer(t.next);
                  }
            }
            return res.next;
      }
}

反转一个链表

206. 反转链表
递归：
其实挺难想的，每次递归调用当前节点的next后，返回的是翻转后的头节点，所以要将这个头节点慢慢传递到第一层。
在当前层需要做的一个工作是：倒转，即将当前的next的next变成当前的，然后将当前的next置为null。
当前层返回到上一层的是一个以最终返回值为头，当前值为尾的链表。

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head == null ||head.next == null) return head;
        ListNode temp = reverseList(head.next);                     
        head.next.next = head;  
        head.next = null;  
        return temp;
    }
}

迭代：
一开始的pre是翻转后链表的尾节点，所以是null.

class Solution {
    public ListNode reverseList(ListNode head) {
    //迭代
        ListNode pre = null;
        while (head != null){
            ListNode temp = head.next;
            head.next = pre;
            pre = head;
            head = temp;
        }
        return pre;
    }
}

判断是否是回文链表

234. 回文链表
法1：求出一个翻转后的链表：两两比较

https://leetcode-cn.com/problems/palindrome-linked-list/solution/234java-shuang-zhi-zhen-tu-jie-by-ustcyyw/

   class Solution {
    public boolean isPalindrome(ListNode head) {
        ListNode r = reverse(head);
        while(head != null){
            if(head.val != r.val) return false;
            head = head.next;
            r = r.next;
        }
        return true;
    }

    private ListNode reverse(ListNode head) {
        ListNode pre = null;
        ListNode newHead = null;
        while (head != null){
            newHead = new ListNode(head.val);            
            newHead.next = pre;
            pre = newHead;
            head = head.next;
        }
        return newHead;
    }
}

法2：
将链表转化成一个数组，然后按照数组的方式判断。双指针法。

法3 将链表的前面翻转，然后与后面的判断
寻找中间节点的方法：使用快慢指针，所以可以在此过程中直接将前半部分翻转。

class Solution {
    public boolean isPalindrome(ListNode head) {
        if (head == null || head.next == null)
            return true;
        ListNode fast = head;
        ListNode slow = head;
        ListNode pre = null;
        ListNode temp = null; 
        while (fast != null && fast.next != null){
            fast = fast.next.next;
            temp = slow.next;
            slow.next = pre;
            pre = slow;
            slow = temp;
        }
        //此时pre是翻转后的头节点，
        
        //一下是节点个数为奇数的情况
        if(fast != null){
            slow = slow.next;
        }
        while(pre != null){
            if(pre.val != slow.val){
                return false;
            }
            pre = pre.next;
            slow = slow.next;
        }
        return true;
    }
}
一文弄懂循环链表、双向链表、静态链表
weixin_46002185的博客
01-12 3256
静态链表、循环链表、双向链表 单链表请点击这里 1.静态链表 C语言具有指针这一强大的功能，也是众多计算机领域的人用来描述数据结构首选C语言的原因之一。指针可以使C非常容易的操作内存中的地址和数据，这比其他高级语言更加灵活方便。Java、C#等面向对象语言，虽然不使用指针，但因为启用了对象引用机制，从某种角度也间接实现了指针的某些作用。但对于其他一些语言，如Basic、Fortran等早期的编程语言对于一些数据结构的操作就没有那么方便了。 有前辈想出来用数组来代替指针，描述单链表：首先让数组的元素都是由两个
C语言实践项目：天干地支
Sunrise的博客
12-27 4433
C语言实践项目：天干地支 1、已知十天干和十二地支 天干:甲、乙、丙、丁、戊、己、庚、辛、壬、癸 地支:子、丑、寅、卯、辰、巳、午、未、申、酉、戌、亥 按顺序打印出六十甲子 甲子、乙丑、丙寅、丁卯、戊辰、己巳、庚午、辛未、壬申、癸酉、 甲戌、乙亥、丙子、丁丑、戊寅、己卯、庚辰、辛巳、壬午、癸未、 甲申、乙酉、丙戌、丁亥、戊子、己丑、庚寅、辛卯、壬辰、癸巳、 甲午、乙未、丙申、丁酉、戊戌、己亥、庚子...
静态链表
ningjinghai11的博客
04-13 264
文字部分转载自：https://www.cnblogs.com/zhaoxy/p/7754906.html 静态链表 对于没有指针的编程语言，可以用数组替代指针，来描述链表。让数组的每个元素由data和cur两部分组成，其中cur相当于链表的next指针，这种用数组描述的链表叫做静态链表，这种描述方法叫做游标实现法。我们对数组的第一个和最后一个元素做特殊处理，不存数据。让数组的第一个元...
2.3静态链表、循环链表和双向链表
weixin_44897707的博客
08-23 304
静态链表、循环链表和双向链表 1.静态链表 早期语言如Basic，由于没有指针，链表结构无法实现，就有人想出来用数组代替指针描述单链表。 数组的元素都是两个数据域组成，data和cur，即数组的每个下表都对应一个data和一个cur。数据域data，用来存放数据元素；cur相当于单链表中的next指针，用来存放该元素的后继在数组中的下标，cur又叫游标。 我们把这种用数组来描述的链表称为静态链表。 1.1静态链表的实现 静态链表的实现方法： 未被使用的数组元素称为备用链表 数组的第一个元素不存储数据，cu
静态链表（用数组描述的链表）
weixin_43973403的博客
01-06 811
静态链表 在C语言中，因为它具有指针的能力，使得它可以非常容易地操作内存中的地址和数据，这比其他高级语言更加灵活方便。 后来的面向对象语言，如Java、C#等，虽然不使用指针，但因为启用了对象引用机制，从某些角度也间接实现了指针的某些作用。 但对一些语言，如Basic、Fortran等早期的编程高级语言，由于没有指针，链表结构中的指针域也就没办法实现了。怎么办呢？ 为了解决指针域无法表示的问题，有人就想出用数组来代替指针，来描述单链表。 首先我们让数组的元素都是由两个数据域组成，data和cur。也就是说，
线性表详解(静态链表、单链表、双向链表、循环链表)
雅俗共赏
05-23 4029
目录申明 申明   本文章属于原创，其中参考了程杰老师《大话数据结构》行文结构和内容，侵删。
线性表静态链表存储
ZHE21
10-11 249
一、静态链表定义 定义——数组的元素都是由两个数据域组成，data和cur。数据域data用来存放数据元素，游标cur相当于单链表中的next指针，存放该元素的后继在数据中的下标。 我们对数组第一个和最后一个元素作为特殊元素处理，不存数据。通常把未被使用的数组元素称为备用链表。而数组第一个元素，即下标为0的元素的cur就存放备用链表的第一个节点的下标；而数组的最后一个元素的cur则存放第一个有数值的元素的下标，相当于单链表的头指针的作用，当整个链表为空时，则为02。如下图所示： 举例：已将数据存入静态链表
静态链表与动态链表
knaha的博客
04-25 2947
转载自 https://blog.youkuaiyun.com/zhengqijun_/article/details/78192888 静态链表和动态链表的区别： 静态链表和动态链表是线性表链式存储结构的两种不同的表示方式。 1、静态链表是用类似于数组方法实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配地址空间大小。所以静态链表的初始长度一般是固定的，在做插入和删除操作时不需要移动元素，仅...
数据结构-线性结构-静态链表
suxiaorui的博客
07-25 335
静态链表存储结构 如果用数组来代替指针，来描述单链表，让数组的元素都是由两个数据域组成，data 和 cur。也就是数组的每个下标都对应一个 data 和一个 cur。数据域 data 用来存放数据元素，也就是通常要处理的数据，而游标 cur 相当于单链表中的 next 指针，存放该元素的后继在数组中的下标。把这种用数组描述的链表叫做静态链表，也可以叫做游标实现法。 一般会把数组建立的大一点，...
第三章 线性表 第四节 静态链表
最新发布
m0_49433560的博客
04-06 1091
这里space[0].cur = k = 1，把要删除的分量下标赋值给第一个元素的cur，此时删除甲后往下的空位得到优先使用权。这里 L[999].cur = L[1].cur = 2，告诉尾元素现在“乙”才是第一个元素。这里 k = L[999].cur = 1，再循环1次，k = L[1].cur = 2。得到静态链表有数据元素的位置，即 i = L[999].cur = 2。这里space[1].cur=space[0].cur=8。再把新元素丙的下标[7]赋值给第[2]个元素乙的cur。
2020年CSP-J入门单项选择题解析
08-20
- **解释**: 干支纪年法通过天干（甲、乙、丙、丁、戊、己、庚、辛、壬、癸）和地支（子、丑、寅、卯、辰、巳、午、未、申、酉、戌、亥）的组合来表示年份。根据题目中的公式，1949年的天干地支是“己丑”。正确答案...
数据结构-线性表
赵凯的博客
10-11 454
       线性表 （顺序表、单链表、静态链表、循环链表、双向链表）在程序员求职笔面试当中占有十分重要的比例，今天转载一篇解决了自己很多的困惑的文章，并做简单整理，以便于更多的人可以从中受益！ 博主地址：http://blog.youkuaiyun.com/daijin888888 https://blog.youkuaiyun.com/daijin888888/article/details/68925248 原...
线性表——Data Structure（C语言描述）
Amour
04-01 2813
是时候补一补基础了，那么在算法之前，要搞定的就是数据结构。基本概念 线性表的顺序存储结构 线性表的顺序存储结构的表示和实现 初始化一个空的线性表InitList 销毁线性表DestroyList 清空线性表ClearList 判断线性表是否为空isEmpty 获取长度getLength 根据位置获取元素GetElem 比较两个元素是否相等compare 查找元素FindElem 查找前驱元素PreE
【急】手撕代码高频
weixin_42886721的博客
07-20 1492
25. K 个一组翻转链表 9 3. 无重复字符的最长子串 8 102. 二叉树的层序遍历 6 124. 二叉树中的最大路径和 6 字节跳动 后端 206. 反转链表 6 字节跳动 后端 15. 三数之和 6 字节跳动 后端 146. LRU缓存机制 6 字节跳动 后端 215. 数组中的第K个最大元素 5 字节跳动 后端 2. 两数相加 5 字节跳动 后端 141. 环形链表 5 字节跳动 后端 234. 回文链表 5 字节跳动 后端 155. 最小栈 4 字节跳动 后端 105. 从前序与中序遍历序列
【丙】搜索，回溯
weixin_42886721的博客
09-11 938
文章目录BFS1. 计算在网格中从原点到特定点的最短路径长度2. 组成整数的最小平方数数量3. 最短单词路径DFS1. 查找最大的连通面积2. 矩阵中的连通分量数目(岛屿数量)2.1 岛屿周长3. 好友关系的连通分量数目4. 填充封闭区域5. 能到达的太平洋和大西洋的区域6.被围绕的区域单词接龙矩阵中的最长递增路径字符串解码克隆图括号生成回溯问题1. 数字键盘组合2. IP 地址划分3. 在矩阵中寻找字符串4. 输出二叉树中所有从根到叶子的路径5. 普通全排列6. 含有相同元素求排列第k个排列7. 组合8.
【癸】数学和数据结构的实现
weixin_42886721的博客
06-24 917
数学问题多多积累吧 坐标 223. 矩形面积 1.什么时候无重叠？ 四种情况 2.有重叠的边界怎么算？ 比如左边界：就是两个左下角横坐标的最小值 public int computeArea(int A, int B, int C, int D, int E, int F, int G, int H) { //求第一个矩形的面积 int length1 = C - A; int width1 = D - B; int area1 = length1 * width1;
【丁】数组，序列，指针
weixin_42886721的博客
07-01 871
数组 228. 汇总区间 双指针法： i与i+1比较，不满足则计算结果，start更新 注意最后一个元素一定要计算结果 class Solution { public List<String> summaryRanges(int[] nums) { List<String> res = new ArrayList<>(); //记录区间起和cur int start = 0; for (int i
【乙】树与图
weixin_42886721的博客
06-24 324
树的结构问题 大多会用上递归，因为树具有高度的自相似性 class Solution { public int countNodes(TreeNode root) { if(root==null) return 0; return countNodes(root.left) + countNodes(root.right) + 1; } } 树的遍历 ...
C语言实现链表排序
"该资源提供了一个使用C语言实现链表排序的示例程序，主要功能是创建一个链表，接收用户输入的多个整数，并通过冒泡排序算法对链表中的数据进行排序。" 在C语言中，链表是一种非常重要的数据结构，它允许动态地存储...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值