力扣链表专题 -2 【单链表 java js c++】 leetcode707 设计链表 通过设计一个自己的链表来强化对（单/双）链表的理解

最新推荐文章于 2024-01-11 10:07:56 发布
最新推荐文章于 2024-01-11 10:07:56 发布
阅读量333 收藏 1
点赞数 3
分类专栏： 力扣刷题 算法强化之路 # 分门别类刷力扣 文章标签： 链表 js 数据结构 java 算法
嘿朋友谢谢你复制我的文章 喜欢的话给点个赞 交个朋友吧~
本文链接：https://blog.csdn.net/qq_45704942/article/details/119518282
版权

欢迎来到力扣刷题笔记的第三部分 —— 超极高频的链表！
总路线戳这里~

文章目录

707.设计链表【双链表专题记得再来写双链表方法】

练习设计自己的单链表~

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。

val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

在链表类中实现这些功能：

  • get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
  • addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
  • addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
  • addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。
    • 如果 index 等于链表的长度，则该节点将附加到链表的末尾。
    • 如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
  • deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

示例：

MyLinkedList linkedList = new MyLinkedList();
linkedList.addAtHead(1);
linkedList.addAtTail(3);
linkedList.addAtIndex(1,2);   //链表变为1-> 2-> 3
linkedList.get(1);            //返回2
linkedList.deleteAtIndex(1);  //现在链表是1-> 3
linkedList.get(1);            //返回3

解题思路

就挨个功能实现咯

设计题考察对数据结构基本操作的熟练哈~

官方题解中提示的面试要点如下：
请添加图片描述
注意两个要点

  • 哨兵节点 sentinel node

哨兵节点在树和链表中被广泛用作伪头(pseudo-head)、伪尾等，通常不保存任何数据。

我们将使用伪头来简化我们的插入和删除。我们将在在单链表、双链表中应用此方法。

  • 双链表的双向搜索

我们可以从头部或尾部进行搜索。

另外需要注意本题的index是从0开始算起的（从示例可以看出 第0个节点 第1个节点…）

Java代码

单链表

public class ListNode{
    //以下为单链表中结点的典型定义
    int val;
    ListNode next;
    ListNode(int x){
        val = x;
    }
}
class MyLinkedList {
    /** Initialize your data structure here. */
    //以下是对单链表的实现
    int size;//size存储链表中元素的个数 进行插入操作size++ 进行删除操作size--
    ListNode head;//哨兵节点
    //哨兵节点被用作伪头始终存在，这样结构中永远不为空，它将至少包含一个伪头。
    public MyLinkedList(){
        //MyLinkedList 中所有节点均包含：值 + 链接到下一个元素的指针。
        size = 0;
        head = new ListNode(0);
    }
        /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
    //获取链表中第 index 个节点的值(从0算起)
    public int get(int index) {
        if(index < 0 || index >= size) return -1;
        ListNode ans = head;
        //接下来遍历寻找要get的节点
        for(int i = 0; i < index + 1; i++){
            ans = ans.next;
        }
        return ans.val;
    }
    
    /** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
    public void addAtHead(int val) {
        addAtIndex(-666, val);//传入的index值只要<=0 即可插入到头节点
    }
    
    /** Append a node of value val to the last element of the linked list. */
    public void addAtTail(int val) {
        addAtIndex(size, val);//传入的index值 >= size 即可插入到尾节点
    }
    
    /** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
    //单链表的插入操作
    public void addAtIndex(int index, int val) {
        //如果index大于链表长度 返回空 index小于0 添加到头节点
        if (index > size) return;
        if(index < 0) index = 0;
        size++;
        //先设置 然后找到插入位置节点的前驱节点prev 注意这里是一个模板！
        ListNode prev = head;//初始化prev为虚拟头节点head 在链表为空时进行插入删除/插入头节点操作时将更好理解
        for(int i = 0; i < index; i++){
            prev = prev.next;
        }
        ListNode toAdd = new ListNode(val);
        //01 先让要插入的节点指向prev的下一个节点 也就是插入过后toAdd的下一个节点
        toAdd.next = prev.next;
        //02 然后prev再指向toAdd
        prev.next = toAdd;
    }
    
    /** Delete the index-th node in the linked list, if the index is valid. */
    //单链表的删除操作
    public void deleteAtIndex(int index) {
        if(index < 0 || index >= size) return;
        size--;
        //和上面添加的操作类似 找到要删除的那个节点的前一个 之后prev跨过要删除的节点直接指向.next.next即可
        ListNode prev = head;
        for(int i = 0; i < index; i++){
            prev = prev.next;
        }
        prev.next = prev.next.next;
    }
}

双链表

双链表是最常用的一种方法

因为它提供了——

  • 常数时间内的addAtHead 和 addAtTail操作
  • 而单链表的addAtHead是常数时间的 但是由于没有设置虚拟尾节点 所以 addAtTail方法是线性时间的（ O(n) ）
public class ListNode{
    //以下为双链表中结点的典型定义
    int val;
    ListNode next;
    ListNode prev;//下一个节点 的意思
    ListNode(int x){
        val = x;
    }
}
class MyLinkedList {
    /** Initialize your data structure here. */
    //以下是对单链表的实现
    int size;//size存储链表中元素的个数 进行插入操作size++ 进行删除操作size--
    ListNode head, tail;//哨兵节点 用作虚拟头节点head 和 虚拟尾节点tail
    //哨兵节点被用作伪头始终存在，这样结构中永远不为空，它将至少包含一个伪头。
    public MyLinkedList(){
        //MyLinkedList 中所有节点均包含：值 + 链接到下一个元素的指针。
        size = 0;
        head = new ListNode(0);
        tail = new ListNode(0);//虚拟尾节点
        head.next = tail;
        tail.prev = head;
    }
        /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
    //获取链表中第 index 个节点的值(从0算起)
    public int get(int index) {
        // if index is invalid
        if (index < 0 || index >= size) return -1;

        // choose the fastest way: to move from the head
        // or to move from the tail
        ListNode curr = head;
        if (index + 1 < size - index)
        for(int i = 0; i < index + 1; ++i) curr = curr.next;
        else {
            curr = tail;
            for(int i = 0; i < size - index; ++i) curr = curr.prev;
        }

        return curr.val;
    }
    
    
    public void addAtHead(int val) {
        ListNode pred = head, succ = head.next;

        ++size;
        ListNode toAdd = new ListNode(val);
        toAdd.prev = pred;
        toAdd.next = succ;
        pred.next = toAdd;
        succ.prev = toAdd;
    }
    
    public void addAtTail(int val) {
        ListNode succ = tail, pred = tail.prev;

        ++size;
        ListNode toAdd = new ListNode(val);
        toAdd.prev = pred;
        toAdd.next = succ;
        pred.next = toAdd;
        succ.prev = toAdd;
    }
    
    //单链表的插入操作
    public void addAtIndex(int index, int val) {
        //如果index大于链表长度 返回空 index小于0 添加到头节点
        if (index > size) return;
        if(index < 0) index = 0;
        
        //先设置 然后找到插入位置节点的前驱节点pred 注意这里是一个模板！
        ListNode pred, succ;
        if(index < size - index){
            //插入点在前半部分
            pred = head;
            for(int i = 0; i < index; i++){
                pred = pred.next;
            }
            succ = pred.next;
        }
        else{
            //插入点在后半部分 速度加快了！
            succ = tail;
            for(int i = 0; i < size - index; i++){
                //往前倒 找插入位置的上一个节点
                succ = succ.prev;
            }
            pred = succ.prev;
        }
        size++;
        ListNode toAdd = new ListNode(val);
        //双链表的插入方式
        toAdd.prev = pred;
        toAdd.next = succ;
        pred.next = toAdd;
        succ.prev = toAdd;
    }
    
    /** Delete the index-th node in the linked list, if the index is valid. */
    //单链表的删除操作
    public void deleteAtIndex(int index) {
        // if the index is invalid, do nothing
        if (index < 0 || index >= size) return;

        // find predecessor and successor of the node to be deleted
        ListNode pred, succ;
        if (index < size - index) {
        pred = head;
        for(int i = 0; i < index; ++i) pred = pred.next;
        succ = pred.next.next;
        }
        else {
            succ = tail;
            for (int i = 0; i < size - index - 1; ++i) succ = succ.prev;
            pred = succ.prev.prev;
        }

        // delete pred.next 
        --size;
        pred.next = succ;
        succ.prev = pred;
    }   
}

JS代码

这里参考的 「代码随想录」带你搞定链表！707. 设计链表：【链表基础题目】详解

整体的思路很清晰 还附带了链表基础知识、虚拟头节点的总结

class LinkNode {
    constructor(val, next) {
        this.val = val;
        this.next = next;
    }
}

/**
 * Initialize your data structure here.
 * 单链表 储存头尾节点 和 节点数量
 */
var MyLinkedList = function() {
    this._size = 0;
    this._tail = null;
    this._head = null;
};

/**
 * Get the value of the index-th node in the linked list. If the index is invalid, return -1. 
 * @param {number} index
 * @return {number}
 */
MyLinkedList.prototype.getNode = function(index) {
    if(index < 0 || index >= this._size) return null;
    // 创建虚拟头节点
    let cur = new LinkNode(0, this._head);
    // 0 -> head
    while(index-- >= 0) {
        cur = cur.next;
    }
    return cur;
};
MyLinkedList.prototype.get = function(index) {
    if(index < 0 || index >= this._size) return -1;
    // 获取当前节点
    return this.getNode(index).val;
};

/**
 * Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. 
 * @param {number} val
 * @return {void}
 */
MyLinkedList.prototype.addAtHead = function(val) {
    const node = new LinkNode(val, this._head);
    this._head = node;
    this._size++;
    if(!this._tail) {
        this._tail = node;
    }
};

/**
 * Append a node of value val to the last element of the linked list. 
 * @param {number} val
 * @return {void}
 */
MyLinkedList.prototype.addAtTail = function(val) {
    const node = new LinkNode(val, null);
    this._size++;
    if(this._tail) {
        this._tail.next = node;
        this._tail = node;
        return;
    }
    this._tail = node;
    this._head = node;
};

/**
 * Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. 
 * @param {number} index 
 * @param {number} val
 * @return {void}
 */
MyLinkedList.prototype.addAtIndex = function(index, val) {
    if(index > this._size) return;
    if(index <= 0) {
        this.addAtHead(val);
        return;
    }
    if(index === this._size) {
        this.addAtTail(val);
        return;
    }
    // 获取目标节点的上一个的节点
    const node = this.getNode(index - 1);
    node.next = new LinkNode(val, node.next);
    this._size++;
};

/**
 * Delete the index-th node in the linked list, if the index is valid. 
 * @param {number} index
 * @return {void}
 */
MyLinkedList.prototype.deleteAtIndex = function(index) {
    if(index < 0 || index >= this._size) return;
    if(index === 0) {
        this._head = this._head.next;
        this._size--;
        return;
    }
    // 获取目标节点的上一个的节点
    const node = this.getNode(index - 1);    
    node.next = node.next.next;
    // 处理尾节点
    if(index === this._size - 1) {
        this._tail = node;
    }
    this._size--;
};
双链表
法一

参考了 基础易懂的链表 官方题解

双链表比单链表快得多 但是它更加复杂，它包含了 size，记录链表元素个数，和伪头伪尾。

这个效率较低。。。

// 定义数据结构
var MyLinkedList = function() {
    this.ListNode = function(val, prev, next){
        this.val = val;
        this.prev = prev;
        this.next = next;
    }
    // 添加了 size 记录 结点个数
    this.size = 0;
    // 创建虚拟节点
    this.dummyHead = new this.ListNode()
};

// 获取链表结点的值
MyLinkedList.prototype.get = function(index) {
    if(index > this.size - 1 || index < 0){//这里注意要遍历到目标结点的前一个元素且index从0算起（题目要求） 所以这里要>this.size-1 下面要用虚拟头结点
        return -1;
    }
    let node = this.dummyHead;//从虚拟头结点开始往下找结点的值
    for(var i = 0; i < index; i++){
        node = node.next;
    }
    return node.next.val;
};

// 在头部加入元素 (如果index小于0，则在头部插入节点
MyLinkedList.prototype.addAtHead = function(val) {
    this.addAtIndex(0, val);//直接用下面写好的函数
};

// 在尾部加入元素 (如果 index 等于链表的长度，则该节点将附加到链表的末尾
MyLinkedList.prototype.addAtTail = function(val) {
    this.addAtIndex(this.size, val);
};

// 插入结点
MyLinkedList.prototype.addAtIndex = function(index, val) {
    if(index > this.size){
        return;//如果 index 大于链表长度，则不会插入节点
    }
    let node = this.dummyHead;
    for(var i = 0; i < index; i++){//要遍历到目标结点的前一个元素 然后执行插入操作
        node = node.next;
    }
    let next = node.next;//这个就是要插入的那个结点
    node.next = new this.ListNode(val, node, next);// 使用上面的函数 + 输入的数据(val node(前一个结点) next)创造当前结点
    if (next){
        next.prev = node.next;//把双链表连上
    }
    this.size++;   
};

// 删除结点
MyLinkedList.prototype.deleteAtIndex = function(index) {
    if(index > this.size - 1 || index < 0){
        return;
    }
    let node= this.dummyHead;
    for(var i = 0; i < index + 1; i++){//这里因为要删除当前结点 所以要遍历到当前节点的位置
        node = node.next;
    }
    node.prev.next = node.next;//双链表的prev字段还是很方便的！
    if(node.next){
        node.next.prev = node.prev;
    }
    this.size--;
};
法二

这个方法效率较高
但是解题的方法比较个性化——自己创建了一个功能类 用于实现链表的这些功能

双向链表+测试方法

function ListNode(val, next = null, prev = null) {
  this.val = val
  this.next = next
  this.prev = prev
}

class MyLinkedList {
  constructor () {
    this.data = new ListNode('head', new ListNode('tail'))
    this.data.next.prev = this.data
    this.len = 0
  }
  operate (index) { // 获得操作节点，主要定位到所需要修改的节点，的前面的节点！！
    let cur = this.data
    while (index-- > 0) {
      cur = cur.next
    }
    return cur
  }
  get (index) {
    if (index < 0 || index >= this.len) {
      return -1
    }
    const operateNode = this.operate(index)
    return operateNode.next.val
  }
  addAtHead (val) {
    const cur = new ListNode(val, this.data.next, this.data) // 建立头部节点
    this.data.next = cur // 正向链接
    this.data.next.next.prev = cur // 反向链接，因为有tail，不需要判断
    this.len++
  }
  addAtTail (val) {
    const tail = this.operate(this.len + 1) // 指向尾部‘tail'节点
    const cur = new ListNode(val, tail, tail.prev) // 建立尾部节点
    tail.prev = cur // 反向链接
    tail.prev.prev.next = cur // 正向链接
    this.len++
  }
  addAtIndex (index, val) {
    if (index < 0 || index > this.len) { //不在范围之内，包括this.len，因为有可能在尾部添加
      return -1
    }
    if (index === 0) return this.addAtHead(val)
    if (index === this.len) return this.addAtTail(val)
    const operateNode = this.operate(index)
    const cur = new ListNode(val, operateNode.next, operateNode)
    operateNode.next = cur
    operateNode.next.next.prev = cur
    this.len++
  }
  deleteAtIndex (index) {
    if (index < 0 || index >= this.len) {
      return -1
    }
    const operateNode = this.operate(index)
    operateNode.next = operateNode.next.next
    operateNode.next.prev = operateNode
    this.len--
  }
}

C++代码

class MyLinkedList {
public:
    // 定义链表节点结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        _size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表最前面插入一个节点，插入完成后，新插入的节点为链表的新的头结点
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

    // 在链表最后面添加一个节点
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    void addAtIndex(int index, int val) {
        if (index > _size) {
            return;
        }
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

    // 删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }

    // 打印链表
    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;

};
敲代码的小提琴手
关注
专栏目录
LeetCode 707. 设计链表（Java）
nuts_and_bolts的博客
03-28 305
707. 设计链表 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引...
剑指LeetCode -- 第七百零七题 -- 设计链表 -- 简单
蛋蛋
10-03 436
class MyLinkedList { private final ListNode list; private ListNode head; private ListNode rear; private int length; /** Initialize your data structure here. */ publ...
力扣707. 设计链表（2022.8.5）
weixin_53412074的博客
08-05 208
在设计链表时我们主要需要实现的是addAtIndex和deleteAtIndex方法，addAtHead和addAtTail可通过addAtIndex实现。在链表题目中，若需要返回头节点，我们一般会使用虚拟头节点，用虚拟头节点的next指向头节点，可以避免对头节点单独处理。在之前设计循环队列时我们讲到Node节点的创建，在这里就不多赘述了，有意向的小伙伴可点击。以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。效率低的原因是我们实现的是单向链表，在添加删除时需要遍历整个链表。...
力扣（707.面试题02.07）补9.16
m0_65280246的博客
12-19 370
707.设计链表 可以，真的是一个工程类的题目，处处要考虑细节，其实20分钟基本能写好，但是改各种细节又要40分钟，就是各种bug，总共花了一个小时才正确。 class MyLinkedList { ListNode head=null; public MyLinkedList() { } public int get(int index) { if(head==null) return -1; List
707. 设计链表
VivBin的博客
09-12 457
设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性prev以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第index个节点的值。如果索引无效，则返回-1...
力扣链表专题 - 3 双指针专题 leetcode141 142 160 19
一碗菜粥的博客
08-17 360
四道题 让自己学会双指针解链表问题 [doge]
力扣链表专题-4 【JS Java 面试超级高频题 全员好题建议N刷！】链表的经典问题 leetcode206 203 328 234 21 2
一碗菜粥的博客
09-05 182
全员好题系列 建议N刷！！！
力扣---LeetCode160. 相交链表(代码详解+流程图)
小沈.的博客
05-05 1351
第十弹 --- 力扣LeetCode每日一题
力扣刷题--设计链表707
weixin_45332508的博客
01-11 1571
先找到最后一个节点：也就是cur的遍历次数：for(int i = 0;i < size;i++)再进行插入。i < size;
Leetcode 刷题（8）简单单链表： 删除链表倒数第N个元素
12-22
在LeetCode刷题中，第19题是一个关于链表操作的问题，名为“删除链表的倒数第N个节点”。这是一个中等难度的题目，主要考察的是对链表的理解和指针操作技巧，尤其是双指针法的应用。在链表这类数据结构问题中，指针...
力扣-LeetCode全套2000题目解答C++和Java版.rar
最新发布
06-26
力扣(LeetCode)是一个非常受欢迎的在线编程挑战平台，旨在提升程序员的算法技能和问题解决能力。这个压缩包文件包含的是LeetCode上2000道编程题目的C++和Java解法，覆盖了从第1题到第2000题的广泛范围。这些题目涵盖...
判断链表是否为回文链表leetcode-LeetCode:力扣解决方案
07-01
判断链表是否为回文链表 leetcode 力码 分而治之 划分：将问题分解为更小的子问题。 采用递归方法进行除法，直到没有子问题可以进一步除法为止。 征服：子问题被认为是自己解决的。 合并：递归地合并子问题，直到...
leetcode下载-LeetCode-Python-Java:zhouzhenping/LeetCode-Python&Java
06-29
leetcode下载 LeetCode-Python-Java ...如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例 输入：(2 -> 4 -> 3) + (5 -> 6 -
力扣树专题-6 广度优先搜索 刷熟一个模板（层序遍历打印二叉树）秒杀一堆问题leetcode102 111 116 617 java刷题笔记
一碗菜粥的博客
06-13 2581
广度优先搜索算法BFS专题 根据一个模板 秒杀其他题目
2021.5.21开始的兔系刷题之路 根据LeetCode分类进行逐个击破 培养出自己的套路~
一碗菜粥的博客
05-19 2132
从前辈们的学习经验中获得建议 并开始一点点地实践 争取一天可以刷一道题 慢慢地把这些专题都刷过来！
4 二叉树基础——第一周力扣C++ python每日一题总结
一碗菜粥的博客
04-20 1179
2021.4.13-2021.4.18 涉及题目为 二叉树基础部分 第一周刷题结束后 进行一个简单总结 其中代码详细注释见每一天的刷题笔记 本总结部分只简单复现一遍代码！ 题目参考开课吧某算法课程胡船长给出的内容~ 文章目录LC144 二叉树的前序遍历1.题目概述2.代码逻辑3.C++代码4.python代码LC589 N叉树的前序遍历1.题目概述2.代码逻辑3.C++代码4.python代码LC226 翻转二叉树1.题目概述2.代码逻辑3.C++代码4.python代码剑指offer32 I 从上到下
力扣树专题-4 用leetcode104求树的深度举例 总结递归秒杀树问题的套路！ java刷题笔记
一碗菜粥的博客
05-31 1128
递归秒杀树问题的小套路~使用leetcode104 求树的深度 来进行举例说明~
1 链表的访问、翻转、节点删除——第二周力扣C++ python Java 每日一题总结
一碗菜粥的博客
04-26 1108
第二周力扣刷题总结 链表的访问、翻转、节点删除
6-3 【好题记号！】贪心法与动态规划解决的入门题 LC53 最大子序和 【要回来看分治法~】字节校园每日一题 【别忘了回头来看这个高频面试题！】LC726 原子的数量 Java力扣刷题笔记
一碗菜粥的博客
05-15 905
高频面试题 原子的数量 贪心算法 动态规划思想的练习！ 最大子序和！
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值