02 链表-常见题型及思路总结

已于 2023-08-12 20:27:10 修改
阅读量222 收藏
点赞数
文章标签： 链表 数据结构 java leetcode
于 2023-08-11 17:44:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52115065/article/details/132223471
版权

【Day 3】 -【代码随想录训练营20期】打卡

链表总结

链表理论基础

链表的类型

单链表：只有一个指针域，并且只指向下一个节点。

双链表：有两个指针域并指向前一个节点和后一个节点。

循环链表：链表末端指针域指向头节点。

 

链表的储存

不像数组一样是连续的，而是非连续的，彼此之间通过指针来指向。

链表的初始化

public class ListNode {
    // 结点的值
    int val;

    // 下一个结点
    ListNode next;

    // 节点的构造函数(无参)
    public ListNode() {
    }

    // 节点的构造函数(有一个参数)
    public ListNode(int val) {
        this.val = val;
    }

    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}

链表的创建


public class MyLinkedList {
 
    public ListNode head;//先声明一个链表的头

    public void creatList(){

        //创建两个节点

        ListNode listNode1 = new ListNode(a);

        ListNode listNode2 = new ListNode(b);

        //头节点指向listNode1

        this.head = listNode1;

        //头节点连上下一个节点

        listNode1.next = listNode2;
    }
}

链表的增加和删除

若是头尾，时间复杂度O(1)，若中间某个点，则是O(n)。

增加和删除：改变插入位置前后节点指针的指向，单链表只用改一个指针。

性能分析

203. 移除链表元素

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

思路：

这是典型的删除链表题型，注意需要返回新的头节点。可能存在删除的节点就是头节点的情况，因此设置一个虚拟头节点是方便的。

虚拟头节点

public ListNode removeElements(ListNode head, int val) {
    if (head == null) {
        return head;
    }
    // 因为删除可能涉及到头节点，所以设置dummy节点，统一操作
    // -1 和 head 分别表示 val 和 next
    ListNode dummy = new ListNode(-1, head);
    // 前节点设置为虚拟节点，后节点设置为头节点
    ListNode pre = dummy;
    ListNode cur = head;
    // 后节点不为空的情况下
    while (cur != null) {
        //如果后节点的值就是val，那么跳过该节点
        if (cur.val == val) {
            pre.next = cur.next;
        } else {
        //如果不是val，那么前节点后移
            pre = cur;
        }
        //后节点后移
        cur = cur.next;
    }
    //返回的不是虚拟头节点，而是其后节点，也就是真正的头节点
    return dummy.next;
}

不添加虚拟头节点

public ListNode removeElements(ListNode head, int val) {
    //考虑到头节点val相等的情况，头节点后移
    while (head != null && head.val == val) {
        head = head.next;
    }
    // 已经为null，提前退出
    if (head == null) {
        return head;
    }
    // 已确定当前head.val != val
    ListNode pre = head;
    ListNode cur = head.next;
    while (cur != null) {
        if (cur.val == val) {
            pre.next = cur.next;
        } else {
            pre = cur;
        }
        cur = cur.next;
    }
    return head;
}

707. 设计链表

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

  • MyLinkedList() 初始化 MyLinkedList 对象。
  • int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
  • void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
  • void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
  • void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
  • void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

思路：

这题就是讲链表操作的，比较复杂但是不难的，按部就班来就行。

单链表
//单链表
class ListNode {
    int val;//链表的val值
    ListNode next;//next代表下一个节点
    //这里提供了两个构造器
    ListNode(){}
    ListNode(int val) {
        this.val=val;
    }
}
class MyLinkedList {
    //size是存储链表元素的个数
    int size;
    //虚拟头结点
    ListNode head;

    //初始化链表
    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
    }

    //获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
    public int get(int index) {
        //如果index非法，返回-1
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode currentNode = head;
        //包含一个虚拟头节点，所以查找第 index+1 个节点
        for (int i = 0; i <= index; i++) {
            currentNode = currentNode.next;
        }
        return currentNode.val;
    }

    //在链表最前面插入一个节点，等价于在第0个元素前添加
    public void addAtHead(int val) {
        //该方法在后面有定义
        addAtIndex(0, val);
    }

    //在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }

    // 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果 index 大于链表的长度，则返回空
    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        if (index < 0) {
            index = 0;
        }
        size++;
        //找到要插入节点的前驱
        ListNode pred = head;
        for (int i = 0; i < index; i++) {
            pred = pred.next;
        }
        //定义一个新节点储存，准备插进去
        ListNode toAdd = new ListNode(val);
        //该新节点指向原先pre的下一个节点
        toAdd.next = pred.next;
        //pre指向该新节点
        pred.next = toAdd;
    }

    //删除第index个节点，关键在于直接跳过next指向next.next
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        size--;
        if (index == 0) {
            head = head.next;
	    return;
        }
        ListNode pred = head;
        for (int i = 0; i < index ; i++) {
            pred = pred.next;
        }
        pred.next = pred.next.next;
    }
}

双向链表

//双链表
class ListNode{
    int val;
    ListNode next,prev;
    ListNode() {};
    ListNode(int val){
        this.val = val;
    }
}


class MyLinkedList {  

    //记录链表中元素的数量
    int size;
    //记录链表的虚拟头结点和尾结点
    ListNode head,tail;
    
    public MyLinkedList() {
        //初始化操作
        this.size = 0;
        this.head = new ListNode(0);
        this.tail = new ListNode(0);
        //这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
        head.next=tail;
        tail.prev=head;
    }
    
    public int get(int index) {
        //判断index是否有效
        if(index<0 || index>=size){
            return -1;
        }
        ListNode cur = this.head;
        //判断是哪一边遍历时间更短
        if(index >= size / 2){
            //tail开始
            cur = tail;
            for(int i=0; i< size-index; i++){
                cur = cur.prev;
            }
        }else{
            for(int i=0; i<= index; i++){
                cur = cur.next; 
            }
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        //等价于在第0个元素前添加
        addAtIndex(0,val);
    }
    
    public void addAtTail(int val) {
        //等价于在最后一个元素(null)前添加
        addAtIndex(size,val);
    }
    
    public void addAtIndex(int index, int val) {
        //index大于链表长度
        if(index>size){
            return;
        }
        //index小于0
        if(index<0){
            index = 0;
        }
        size++;
        //找到前驱
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        //新建结点
        ListNode newNode = new ListNode(val);
        newNode.next = pre.next;
        pre.next.prev = newNode;
        newNode.prev = pre;
        pre.next = newNode;
        
    }
    
    public void deleteAtIndex(int index) {
        //判断索引是否有效
        if(index<0 || index>=size){
            return;
        }
        //删除操作
        size--;
        ListNode pre = this.head;
        for(int i=0; i<index; i++){
            pre = pre.next;
        }
        pre.next.next.prev = pre;
        pre.next = pre.next.next;
    }
}

206. 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

思路：

1. 反转单链表，需要用到一个temp节点来作为中转，类似于数组排序中的temp值，不过要复杂一点。

2. 用双指针法来完成前后两个节点的指向。

双指针法

1. 定义prev前指针（左边）指向空，cur后指针（右边）指向头指针，临时节点用于中转。

2. 执行单链表的断指针前，一定要用临时节点储存.next。

3. 断指针并反转，cur.next指向pre

4. 接下来就是pre和cur的右移，分别通过 pre = cur 和 cur = temp 实现。

5. 注意，是先移动后翻转，因此while的临界点是 cur != null。同时翻转后的头节点为prev。

class Solution {
    public ListNode reverseList(ListNode head) {
        //定义前指针节点
        ListNode prev = null;
        //定义后指针节点
        ListNode cur = head;
        //定义临时节点用于中转
        ListNode temp = null;
        while (cur != null) {
            temp = cur.next;// 临时节点保存下一个节点
            cur.next = prev;//cur断开指针，连上前指针节点
            prev = cur;//前指针右移
            cur = temp;//cur指针右移
        }
        return prev;
    }
}

时间复杂度：O(n)

空间复杂度：O(1)

递归解法

递归有亿点抽象。。。搞不懂很正常，来让我们看看。

递归的使用条件：首先反转链表的操作是可以递归的，因为每一次反转的操作都一样，同时上一步的操作会影响下一步的操作。

第一步，定义递归函数，怎么确定其传入参数呢？一般是满足几个条件：

1. 该参数随着每次操作改变。

2. 该参数同时是每次操作的输入值和输出值。

在本题中，pre cur 和 temp的值都会改变，但 temp 只是临时储存相当于备胎而已无关紧要的，因此只用pre和cur。

第二步，确定递归的终止条件，这个条件一般是由传入参数来决定的，通常与传入参数的变化趋势一致，在本题中 cur 不断减小，最终就是cur == null。

第三步，实现递归的业务层，这里描述了具体的操作。在本题中，即为完成前后节点的指针反转。本来还要实现 pre 和 cur 的右移，但在下一个递归调用中通过传参巧妙绕开了这部分代码。

class Solution {
    public ListNode reverseList(ListNode head) {
        return reverse(null, head);
    }

    //这里定义了一个递归函数，将传入参数是pre和cur，也就是说每次递归的变量都是pre和cur
    private ListNode reverse(ListNode prev, ListNode cur) {
    //递归的终止条件
        if (cur == null) {
            return prev;
        }

        //每次递归的业务层：进行指针反转
        ListNode temp = null;
        temp = cur.next;// 先保存下一个节点
        cur.next = prev;// 反转

        //每次递归的传输层：更新prev、cur位置
        // 相当于：prev = cur; cur = temp;
        return reverse(cur, temp);
    }
}

024. 两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

思路：

1. 可以通过模拟或归纳来解。

2. 注意边界，当前节点为null或当前节点的next为null时停止。

模拟法

1. 要定义虚拟头节点，不然返回不了头节点，因为没有指针指向它。

2. 注意边界是怎么定义的。

class Solution {
  public ListNode swapPairs(ListNode head) {
        ListNode dumyhead = new ListNode(-1); // 设置一个虚拟头结点
        dumyhead.next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
        ListNode cur = dumyhead;
        ListNode temp; // 临时节点，保存两个节点后面的节点
        ListNode firstnode; // 临时节点，保存两个节点之中的第一个节点
        ListNode secondnode; // 临时节点，保存两个节点之中的第二个节点
        while (cur.next != null && cur.next.next != null) {
            temp = cur.next.next.next;
            firstnode = cur.next;
            secondnode = cur.next.next;
            cur.next = secondnode;       // 步骤一
            secondnode.next = firstnode; // 步骤二
            firstnode.next = temp;      // 步骤三
            cur = firstnode; // cur移动，准备下一轮交换
        }
        return dumyhead.next;  
    }
}

递归法

1. 注意传入参数是每次执行交换的链表头节点，也就是说返回的也是每次的头节点。

2. 终止条件是下次执行的第一个节点为空或第二个节点为空。

3. 由于每次都返回

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

        //定义三个节点来执行储存
        ListNode node1 = head;
        ListNode node2 = head.next;
        ListNode node3 = node2.next;

        node1.next = swapPairs(node3); // 1 指向递归返回的链表头，先执行这个避免空指针
        node2.next = node1; // 2 指向 1

        return node2; // 返回交换后的链表头节点
    }
}

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

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

提示：

  • 链表中结点的数目为 sz
  • 1 <= sz <= 30
  • 0 <= Node.val <= 100
  • 1 <= n <= sz

思路：

1. 模拟：该题不难，主要是要考虑到不同情况的边界问题，先用纸将思路写出来，罗列好各种情况再动手写代码。如 n = 1, n = sz 的情况。

2. 该题可以使用快慢指针，一次遍历就可以找到目标节点。由于不知道链表的长度，我们无法直接从后往前数，因此可以利用快慢指针的区间来进行距离的测量！让快指针在n+1处开始，慢指针在1处开始，当快指针移动到末端时，慢指针就是倒数第n个！

模拟法

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        int count = 1;
        ListNode cur = head;
        ListNode pre; 
        //考虑空链表的情况
        if(cur == null){
            return head;
        }
        //先得到链表长度        
        while(cur.next != null){
            cur = cur.next;
            ++count;
        }
        //考虑删除最后一个节点的情况
        if(count == n){
            cur = head.next;
            head.next = null;
            return cur;
        }
        //当删除的是中间节点时
        cur = head;
        //先遍历找到节点，然后执行删除操作
        while(count > n){
            if(count == n + 1){
                pre = cur;
                cur = cur.next;
                pre.next = cur.next;
                cur.next = null;
                return head;
            }
            cur = cur.next;
            --count;
        }
        return head；
    }
}

快慢指针

public ListNode removeNthFromEnd(ListNode head, int n){
    ListNode dummyNode = new ListNode(0);
    dummyNode.next = head;

    ListNode fastIndex = dummyNode;
    ListNode slowIndex = dummyNode;

    //只要快慢指针相差 n 个结点即可
    for (int i = 0; i < n  ; i++){
        fastIndex = fastIndex.next;
    }

    while (fastIndex.next != null){
        fastIndex = fastIndex.next;
        slowIndex = slowIndex.next;
    }

    //此时 slowIndex 的位置就是待删除元素的前一个位置。
    //具体情况可自己画一个链表长度为 3 的图来模拟代码来理解
    slowIndex.next = slowIndex.next.next;
    return dummyNode.next;
}

02.07. 链表相交

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

图示两个链表在节点 c1 开始相交：

思路：

该题可以暴力解，也就是用两个while循环来分别将两个链表的节点都比较一下。

也可以用快慢指针的变种，先确定两个链表的差值，然后让长的那个链表指针先移动对应位数，再一起比较两个指针。

暴力解法

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode aIndex = headA;
        ListNode bIndex = headB;
        while(aIndex != null){
            while(bIndex != null){
                if(aIndex == bIndex){
                    return bIndex;
                }
                bIndex = bIndex.next;
            }
            //这里要注意重新赋值指针，让它重新回到头节点，重头遍历
            bIndex = headB;
            aIndex = aIndex.next;
        }
        return null;
        
    }
}

快慢指针

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode aIndex = headA;
        ListNode bIndex = headB;
        int countA = 1;
        int countB = 1;
        while(aIndex != null){
            aIndex = aIndex.next;
            ++countA;
        }
        while(bIndex != null){
            bIndex = bIndex.next;
            ++countB;
        }
        int max = countA > countB ? countA : countB;
        int min = countA < countB ? countA : countB;
        //这里注意要重新赋值指针，让它们回到头节点
        aIndex = headA;
        bIndex = headB;
        for(int i = 0; i < max - min; i++){
            if(max == countA){
                aIndex = aIndex.next;
            }else{
                bIndex = bIndex.next;
            }
        }
        while(aIndex != null){
            if(aIndex == bIndex){
                return aIndex;
            }
            aIndex = aIndex.next;
            bIndex = bIndex.next;
            
        }
        return null;
    }
}

142. 环形链表 II

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

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

思路：

暴力+快慢指针解法：直接循环10000次，每次fast进1，如果空就无环，如果有环就每循环10000次，slow进一步，直到它们相交。

数学归纳+快慢指针解法：注意循环次数太大了，会造成资源的浪费，那么有什么办法可以判断有没有环呢？有的，可以设置快慢双指针，快指针移动两步，慢指针移动一步，当快指针赶上慢指针时，就有环。如果有环，那么此时快指针和head指针到相交点的距离是一样的（ x = z ），因为当快指针多跑的距离（n个环）正好就是慢指针的移动距离。

暴力+快慢指针解法

public class Solution {
    public ListNode detectCycle(ListNode head) {
        if(head == null){
            return null;
        }
        ListNode slowIndex = head;
        ListNode fastIndex = head.next;
        ListNode guideIndex = fastIndex;
        int count = 1;
        if(fastIndex == null){
            return null;
        }
        
        while(true){
            while(guideIndex != fastIndex){
                if(fastIndex == null){
                    return null;
                }
                if(fastIndex == slowIndex){
                    return fastIndex;
                }
                if(count % 2 == 1 ? false : true){
                    guideIndex = guideIndex.next;
                }
                fastIndex = fastIndex.next;
                ++count;
            }
            fastIndex = fastIndex.next;
            if(fastIndex == guideIndex){
                return fastIndex;
            }
            slowIndex = slowIndex.next;
        }
    }
}

数学归纳+快慢指针解法

public class Solution {
    public 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) {// 有环
                ListNode index1 = fast;
                ListNode index2 = head;
                // 两个指针，从头结点和相遇结点，各走一步，直到相遇，相遇点即为环入口
                while (index1 != index2) {
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}

Fantastic Nana
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
python-leetcode面试题解之第61题旋转链表-题解.zip
03-19
这是一道常见的面试题目，旨在考察开发者对于链表操作的熟练程度，特别是链表结构的理解和算法设计能力。让我们深入探讨这个问题以及如何使用Python来解决它。 ### 题目描述 旋转链表，也称为循环链表的旋转，要求...
python-leetcode面试题解之第206题反转链表-题解.zip
05-28
本篇将深入探讨第206题——反转链表，这是一道常见的链表操作题目，对于理解和掌握链表的特性及其操作至关重要。 链表是一种线性数据结构，与数组不同，链表的元素并不在内存中连续存储。每个元素称为节点，包含两...
c语言基础-c语言编程基础之链表操作示例-反转链表.zip
03-17
基本思路是将链表分为两部分：头部（当前节点）和剩余部分（当前节点的下一个节点及其后的部分）。通过递归调用函数处理剩余部分，然后将剩余部分的头节点连接到当前节点的前面，完成当前节点的反转。 在实际编程中...
链表树-复合数据结构应用实例.zip
06-17
my_resource文件可能是所有资源的集合，其中可能包含了详细讲解、示例代码和练习案例，帮助学习者深入理解和掌握链表与树的原理及实际应用。 学习数据结构对于IT专业人士至关重要，因为它直接影响到算法设计和程序...
php-leetcode题解之链表的中间结点.zip
06-10
本话题聚焦于一个特定的题目——找到链表的中间节点，这是链表数据结构中常见的问题，对于理解和掌握链表操作至关重要。我们将详细探讨这个问题以及如何用PHP来解决它。 链表是一种线性数据结构，它不像数组那样...
数组算法--基本查找
2303_78660417的博客
07-20 279
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1022
可以参考以下视频。
数据结构day3
qq_55245263的博客
07-18 255
顺序表实现学生管理系统
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 698
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 215
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1075
如有错误，欢迎指出~
数据结构第32节 无锁编程
hummhumm的专栏
07-17 845
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
数据结构——栈
weixin_45942515的博客
07-19 241
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
数据结构之细说链表
m0_73634434的博客
07-17 1057
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1079
24暑假刷题day15打卡 二叉树进阶
数据结构 day2
没有百宝袋的哆啦A梦的博客
07-17 1159
由相同数据类型或不同数据类型构成的集合，但是，该集合中的成员共享同一块内存空间union 结构体名称成员类型1 成员变量1;成员类型2 成员变量2；。。。成员类型n 成员变量n;当程序员写程序时，可能会因为数据类型的问题，在定义变量时，导致该程序比较晦涩难懂，例如：unsigned long int ,struct Stu为了提高代码的简洁性，以及为了更加方便理解使得代码更加优雅，我们可以将这些类型重新起一个简洁好记的名字。引入了关键字 typedef。
常见排序算法
weixin_56898048的博客
07-17 935
介绍了常见的排序算法，冒泡排序，插入排序，希尔排序，选择排序，堆排序，快速排序，归并排序和计数排序的代码实现以及这些排序算法的时间复杂度和空间复杂度
排序思想-快排
m0_58257626的博客
07-17 332
快速排序核心思想就是每次在当前区间 [left, right] 中选择出一个元素 nums[p]，然后将区间内所有大于它的元素和所有小于它的元素都放到其两侧【具体放在哪一侧取决于是升序还是降序】，然后再递归去处理两侧区间。将大于切分值的元素都放到左侧，小于切分值得元素都放到右侧。因此我们可以使用双指针分别从两端往中间搜索，分别找到左侧小于切分值的元素和右侧大于切分值的元素，交换之，直到两个指针相遇。
数组算法--二分查找
最新发布
2303_78660417的博客
07-20 502
二分查找也叫折中查找，为什么会这样叫呢？就是因为我们二分查找的核心逻辑就是每查找完一次，都能将查找的范围给缩小一半，也就是折中。但使用二分查找又有个很大的前提，那就是该数组里的元素得是有序排序的，也就是从小到大排序或者从大到小排序。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值