基础链表问题练习1

最新推荐文章于 2022-11-04 23:36:54 发布
最新推荐文章于 2022-11-04 23:36:54 发布
阅读量306 收藏
点赞数
分类专栏： 算法刷题 文章标签： 链表
版权声明：本文为CSDN博主小智RE0-李智青-原创文章,转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MrTumnus/article/details/123049268
版权

文章目录

https://leetcode-cn.com/explore/learn/card/linked-list/
建议先学习学习 力扣链表入门

1 LC:702入门级设计链表

原题位置: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 个节点。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/design-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

//节点类;
class ListNode{
    int value;
    ListNode next;
    public ListNode(int value){
        this.value = value;
    }
}
//单向链表;
class MyLinkedList {
    //头结点;
    ListNode head;
    //节点个数;
    int size;
    //构造方法;
    public MyLinkedList() {
        head = new ListNode(0);
        size = 0;
    }
    //获取链表中第 index 个节点的值。如果索引无效，则返回-1。
    public int get(int index) {
        //若当前索引明显不在链表范围内或者此时为空链表;
        if(head==null ||index >=size ||index<0){
            return -1;
        }
        ListNode node = head.next;
        for(int i =0;i<index;i++){
            node = node.next;
        }
        return node.value;
    }
    //在链表的第一个元素之前添加一个值为 val 的节点。
    //插入后，新节点将成为链表的第一个节点
    public void addAtHead(int val) {
     addAtIndex(0,val);
    }
    //将值为 val 的节点追加到链表的最后一个元素。
    public void addAtTail(int val) {
     addAtIndex(size,val);
    }
    //在链表中的第 index 个节点之前添加值为 val  的节点。
    //如果 index 等于链表的长度，则该节点将附加到链表的末尾。
    public void addAtIndex(int index, int val) {
       //如果 index 大于链表长度，则不会插入节点;
       if(index >size){
           return;
       }
       //如果index小于0，则在头部插入节点。
       if(index<0) {
           index = 0;
       }
       size+=1;
       //寻找之前的一位;
       ListNode node = head;
       for(int i =0;i<index;i++){
           node= node.next;
       }
       //要添加的节点;
       ListNode newNode = new ListNode(val);
       //调整指向;
       newNode.next = node.next;
       node.next = newNode;
    }
    //如果索引 index 有效，则删除链表中的第 index 个节点。
    public void deleteAtIndex(int index) {
        //列出几种索引失效的场景;
        if(index<0 || index >=size||head ==null){
            return;
        }
        //操作的节点;
        ListNode node = head;
        //找到待删除结点的前一个结点;
        for(int i= 0;i<index;i++){
            node = node.next;
        }
        //改变指向;
        node.next = node.next.next;
        size-=1;
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

2 LC: 2 两数相加

2. 两数相加

给你两个 非空 的链表，表示两个非负的整数。
它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

在这里插入图片描述

示例 2：
输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：
输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：
每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零

先把链表节点加到一个链表中,然后对于超过10的进行进位处理;

/**
 * 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 addTwoNumbers(ListNode l1, ListNode l2) {
        //用临时节点操作链表;
        ListNode temp1 = l1;
        ListNode temp2 = l2;
        while(temp1!=null){
            //先把值加到一个链表上;
            if(temp2!=null){
                temp1.val = temp1.val+temp2.val;
                temp2 = temp2.next;
            }
            //注意特殊情况,链表1已经结束;直接把链表2接到后面;
            if(temp1.next==null){
                temp1.next = temp2;
                break;
            }
            temp1 = temp1.next;
        }
        //对于节点的值进行计算;
        toCarry(l1);
        return  l1;
    }

    //节点的值进位计算;
    public void toCarry(ListNode node){
        //在链表范围内;
        while(node!=null){
            //进位
            if(node.val>=10){
                //进位之后的余值作为当前节点值;
                node.val = node.val%10;
                //若已经到末尾,则要补0;
                if(node.next == null){
                    node.next = new ListNode(0);
                }
                node.next.val+=1;
            }
            //链表向后移动;
            node = node.next;
        }
    }
}

3 LC: 21. 合并两个有序链表

21. 合并两个有序链表

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

在这里插入图片描述

示例 2：
输入：l1 = [], l2 = []
输出：[]

示例 3：
输入：l1 = [], l2 = [0]
输出：[0]

提示：
两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列

采用类似于归并排序的比较法,拼接到一个链表中;

/**
 * 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 mergeTwoLists(ListNode l1, ListNode l2) {
      //类似于归并排序;对于链表的元素依次比较;
      ListNode res = new ListNode();
      //操作的节点;
      ListNode curNode = res;
      while(l1!=null && l2!=null){
          if(l1.val<=l2.val){
              curNode.next = l1;
              l1=l1.next;
              curNode=curNode.next;
          }else{
              curNode.next = l2;
              l2=l2.next;
              curNode = curNode.next; 
          }
      }
      //若出现一个链表已经为空;则拼接另一个;
      if(l1==null){
          curNode.next = l2;
      }
      if(l2==null){
          curNode.next = l1;
      }
      //注意返回的节点由下一位开始;
      return res.next;  
    }
}

4 LC: 23. 合并K个升序链表

23. 合并K个升序链表

给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。
示例 1：
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
    
示例 2：
输入：lists = []
输出：[]

示例 3：
输入：lists = [[]]
输出：[]
 
提示：
k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4

一个比较容易理解的思路,将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 mergeKLists(ListNode[] lists) {
        int n = lists.length;
        //排除空用例;
        if(lists==null || n==0){
            return null;
        }
        //采用分治思想;
        for(int i = 1;i<n;i*=2){
            for(int j=0;j<n-i;j=j+i*2){
                lists[j] = mergeTwo(lists[j],lists[j+i]);
            }
        }
        //最终都合并到第一份链表中;
        return lists[0];
    }
    //合并两个升序数组的做法;
    public ListNode mergeTwo(ListNode l1,ListNode l2){
        //类似于归并排序;
        ListNode res = new ListNode(0);
        //操作的节点;
        ListNode curNode = res;
        while(l1!=null && l2!=null){
            if(l1.val<=l2.val){
                curNode.next = l1;
                l1 = l1.next;
            }else{
                curNode.next = l2;
                l2 = l2.next;
            }
            curNode = curNode.next;
        }
        //可能一个链表已经遍历结束;
        if(l1==null){
            curNode.next = l2;
        }
        if(l2==null){
            curNode.next = l1;
        }
        return res.next;
    }
}

5 LC: 24. 两两交换链表中的节点

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

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。
你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
提示：
链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100

在这里插入图片描述

可使用递归思路

/**
 * 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 swapPairs(ListNode head) {
        //特殊用例;
        if(head==null || head.next==null){
            return head;
        }
        //简易递归;
        ListNode curNode = head;
        ListNode nextNode = head.next;
        //第二个节点后面的节点递归结束;接到原来的头结点后;
        curNode.next = swapPairs(nextNode.next);
        nextNode.next = curNode;
        //新的头结点;
        return nextNode;
    }
}

不递归;在循环内处理;

/**
 * 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 swapPairs(ListNode head) {
        //非递归;
        //特殊用例判断;
        if(head==null || head.next==null){
            return head;
        }
        //采用虚拟头节点;
        ListNode dummy = new ListNode(0);
        dummy.next=head;
        ListNode curNode = dummy;
        while(curNode.next!=null&&curNode.next.next!=null){
            //注意刚开始这个curNode是空的;
            //节点的交换过程实际就是,相邻的互换,当前指导后一个的后继节点;
            ListNode oneNode = curNode.next;
            ListNode twoNode = oneNode.next;
            oneNode.next = twoNode.next;
            //第二个节点会指向到第一个节点,依次类推;
            twoNode.next = oneNode;
            //当前的操作节点指向第二个节点;
            curNode.next = twoNode;
            //注意这里需要将操作节点位到一号节点(curNode的后继);
            curNode = oneNode;
        }
        return dummy.next;
    }
}

6 LC:25. K 个一组翻转链表

25. K 个一组翻转链表

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

进阶：
你可以设计一个只使用常数额外空间的算法来解决此问题吗？
你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

在这里插入图片描述

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

示例 4：
输入：head = [1], k = 1
输出：[1]

提示：
列表中节点的数量在范围 sz 内
1 <= sz <= 5000
0 <= Node.val <= 1000
1 <= k <= sz

非常巧妙的思路;
先计算出链表的长度;然后根据K值,
首先对前K个节点进行反转处理,处理时,这部分链表暂时与整体链表分开;
在反转完成之后需要再链接到主链表上,移动操作节点,继续下一块K区域的链表处理;
注意,如果剩余的节点个数不足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 reverseKGroup(ListNode head, int k) {
        //在之前24题的两两反转基础上;
        //首先排除反转个数少于2的;
        if(head==null||head.next==null||k<2){
            return head;
        }
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        //使用两个操作节点;对于一段区域进行查看;
        ListNode curNode = dummy;
        ListNode endNode = dummy;
        while(endNode.next!=null){
            //首先截取一段k长度的链表;
            for(int i =0;i<k && endNode!=null;i++){
                endNode=endNode.next;
            }
            //注意如果不足k个,可直接退出;
            if(endNode == null) {
                break;
            }
            //此时对于区域curNode.next--endNode 进行处理;
            ListNode oneNode = curNode.next;
            //注意标记此时endNode后的节点,一会还要再链接;
            ListNode subNode = endNode.next;
            //暂时断开这段链表与主链表;
            endNode.next = null;
            //反转当前k个节点后;再让curNode指向它;
            curNode.next = reverseNode(oneNode);
            //这里注意将断开的链表接上去;
            oneNode.next = subNode;
            //当前操作指针与k阶段末尾指针移动;
            curNode = oneNode;
            endNode = curNode;
        }
        return dummy.next;
    }
    //反转链表;
    public ListNode reverseNode(ListNode node){
        //前置节点与当前操作节点;
        ListNode preNode = null;
        ListNode curNode = node;
        while(curNode!=null){
            //注意反转;将当前节点指向前一个结点;
            ListNode temp = curNode.next;
            curNode.next = preNode;
            preNode = curNode;
            //向后继续操作;
            curNode = temp; 
        }
        //注意返回时,preNode已经不是null了;
        return preNode;
    }
}

7 LC: 61. 旋转链表

61. 旋转链表

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。
提示：
链表中节点的数目在范围 [0, 500] 内
-100 <= Node.val <= 100
0 <= k <= 2 * 109

在这里插入图片描述

类似于螺旋数组的题型;
若k值正好是链表的节点个数倍数,那么不必要旋转处理,直接返回;
若k值超过了链表的节点个数,那么对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 rotateRight(ListNode head, int k) {
        if(head==null||head.next==null||k==0){
            return head;
        }
        //类似于螺旋数组;
        //若k值正好是链表的节点个数倍数,那么不必要旋转;
        //若k值超过了链表的节点个数,那么对k值进行取模运算;
        int len =1;
        ListNode temp = head;
        while(temp.next!=null){
            temp = temp.next;
            len++;
        }
        
        k = k%len;
        if(k==0){
            return head;
        }
        //找到移动之后的末尾节点;
        ListNode newTail = head;
        for(int i=1;i<len-k;i++){
            newTail = newTail.next;
        }
        //标记新的头节点;
        ListNode newHead = newTail.next;
        //将原末尾和原头结点链接;
        temp.next = head;
        newTail.next = null;
        return newHead;
    }

}

8 LC: 82. 删除排序链表中的重复元素 II

82. 删除排序链表中的重复元素 II

给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。
返回 已排序的链表 。
提示：
链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序 排列

在这里插入图片描述

注意删除的是所有重复的节点,
那么具体在预先处理时,这个操作节点就要置身事外,即删除的是这个操作节点的next节点(可能后面还有几个重复的);

/**
 * 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(0);
        dummy.next = head;
        ListNode curNode = dummy;
        while(curNode.next!=null && curNode.next.next!=null){
            //若出现重复时需要处理;
            if(curNode.next.val == curNode.next.next.val){
                //注意;删除时先从第二个开始;
                ListNode delNode = curNode.next.next;
                //注意,这是已经排序的链表,顺便看看后面是否有重复的;
                while(delNode.next!=null&&delNode.val ==delNode.next.val){
                    delNode = delNode.next;
                }
                //删掉这块重复的;
                curNode.next = delNode.next;
                delNode.next=null;
            }else{
                curNode=curNode.next;
            }
        }
        return dummy.next;
    }
}

9 LC: 83. 删除排序链表中的重复元素

83. 删除排序链表中的重复元素

给定一个已排序的链表的头 head ， 删除所有重复的元素，
使每个元素只出现一次 。返回 已排序的链表 。

提示：
链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序 排列

在这里插入图片描述

这个题目的删除要求比较简单,仅删除重复多余的,可以保留下一个数;
那么在具体操作时,操作节点就得从自己进行比较了,若出现重复的,那么删掉这个数后面重复的部分即可;

/**
 * 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||head.next==null){
            return head;
        }
        //注意;删除重复的多个,保留一个;
        ListNode curNode = head;
        while(curNode.next!=null){
            //处理重复的;
            if(curNode.val == curNode.next.val){
                ListNode delNode = curNode.next;
                curNode.next = delNode.next;
                delNode.next = null;
            }else{
                curNode= curNode.next;
            }
        }
        return head;
    }
}
小智RE0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
20210429力扣第24题：两两交换链表中的结点
EenKine的博客
04-29 186
1.题目 两两交换链表中的节点： 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 输入：head = [1,2,3,4] 输出：[2,1,4,3] 示例 2： 输入：head = [] 输出：[] 示例 3： 输入：head = [1] 输出：[1] 2.想法 遇到这样的题，想法是进行结点修改了，多定义几个指针，最后再修改指针的位置，但是这样的仔细看指针的位置。自己写的时候搞错了，看了下评论。 .
单链表基础练习题
qq_51569907的博客
05-18 307
Java、数据结构、算法、链表、题库
浅刷牛客链表题，逐步深入链表，理解链表
yanxiang3306
11-04 1028
主要思想就是定义一个快指针，一个慢指针，快的一次走两步，慢的一次走一步，当快的走到链表的尾结点的时候，慢的就是中间结点的位置，然后把它后面的结点进行反转，上面说过怎么反转了，最后，从两端开始比较即可！思路描述：为了反转链表，简单一点说就是把结点的next值进行一个修改，如果我们用cur来记录当前的结点，那么在修改指向的时候，我们需要知道它的前一个结点(pre)和后一个结点(curNext)，因为一旦指向修改完成后，后面的结点就找不到了，所以我们需要记录一下。要求：空间复杂度 O(1)，时间复杂度O(n)
Java（ListNode） 中的链表及头结点
qq_41142785的博客
04-26 4030
ListNode 头结点的理解： 一个链表头节点为head head -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 head叫做链表的头节点 1 所在的节点叫做链表的首节点（不知叫法是否准确） 从定义上严格来说, 头节点head本身并没有值，它只是一个指向首节点1的指针。也就是说head.val为空，head.next.val=1。即head的下一个节点才是1的节点。那上述的链表就有7个节点（包含头节点head）。 但是，在一些
链表ListNode基本用法，力扣第2题，两数相加
江湖的博客
02-20 7806
1.问：什么是链表，链表和数组有什么区别 答：链表也是一种数据结构，链表有指针 2.问：链表的使用场景有哪些，用的多吗 答：不多，几乎不用 3.问：new ListNode(-1)和new ListNode(0)有什么区别 答：一个值是-1一个是0 以上问答是我站在前端的角度向公司后端同事咨询得到的答复，哈哈，如有不对的地方欢迎指正，不喜勿喷！ 一、定义 先看下链表的结构，有链表的值域，指针域，和链表赋值的方法。 public class ListNode{ // 链表的某
通过ListNode了解普通循环，迭代和递归
qq_42023813的博客
02-04 835
前言 ：这几天在刷面试题的时候做到一个关于ListNode的时候蒙圈了，然后查了一下资料，突然又发现自己傻傻分不清普通循环，迭代和递归的区别了。 ListNode public class ListNode { int val; //值 ListNode next; // 下一个节点对象 ListNode(int x){ //赋值链表的值 val = x ; } } 普通循环，迭代和递归介绍 迭代：函数内某段代码实现循环。循环代码中参与运算的变量同时是
基础链表练习（附详细注释）
04-08
在这个“基础链表练习”中，我们将探讨如何创建一个带头结点的字符串链表，以及如何对这个链表进行操作。下面将详细阐述相关知识点。 首先，我们来了解**单链表**的基本概念。单链表由一系列节点组成，每个节点包含...
链表练习题目（打印）1
08-08
**链表操作练习1：删除素数节点** 题目要求从链表中删除所有数据成员为素数的结点。首先，我们需要一个辅助函数`IsPrime`来判断一个整数是否为素数： ```c int IsPrime(int n) { if(n) return 0; for(int i=2; i...
Qt基础练习，QGraphics制作可视化链表
最新发布
08-25
1. **定义链表节点类**：首先，我们需要创建一个继承自QGraphicsItem的自定义类，代表链表的节点。这个类应包含数据成员，用于存储节点的数据，以及指针成员，用于连接到下一个节点。同时，实现必要的绘图方法，如`...
新建文件夹_链表的练习_创建文件_
09-30
链表是一种基础且重要的数据结构，在计算机科学中广泛应用于各种算法和程序设计中...在“新建文件夹”中的链表练习，正是提供了一个实践和检验这些技能的平台。通过分析和解答其中的题目，你将更深入地领悟链表的精髓。
01 链表_链表_askf1p_
09-29
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在本文中，我们将深入探讨链表的概念、类型、操作以及它们在实际问题中的应用。 首先，链表不同于数组，数组是连续...
算法练习01- ListNode 单链表创建+遍历(for,while,递归)
qq_41758969的博客
06-08 704
算法练习01- ListNode 单链表创建+遍历(for,while,递归) 每日练习！
java链表ListNode
热门推荐
小陈的博客
12-28 4万+
/** * 描述：删除链表中等于给定值val的所有节点。样例：给出链表 1->2->3->3->4->5->3, 和 val = 3, 你需要返回删除3之后的链表：1->2->4->5。分析：1.首先判断head是不是空，为空就直接返回null 2.然后从head.next开始循环遍历，删除相等于val的元素 3.最后判断head是否和val相等，若相等，head = head.next
【数据结构】必掌握的链表面试题
Living_Amethyst的博客
05-09 1086
我们在学习了链表的有关知识后，有必要来看几个链表的经典面试题，让我们一起来学习一下吧 1.删除链表中等于给定值 val 的所有节点 力扣 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 示例 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5] 这个删除的核心是：要找到需要删除的节点的上一个节点 由于在一开始就处理头节点就需要......
与链表相关的OJ题(LeetCode)
零度
10-25 371
链表算法题:其实这类题最简单的解法就是画图,图出来,题结束.在这里我只给出具体算法代码,就不测试了.等我学会使用动图,我会全部进行修改的.1.反转链表.2.链表的中间节点. 1.反转链表. 输入:head=[1,2,3,4,5] 输出:[5,4,3,2,1] 具体实现方法: 刚开始,我们新建一个节点cur让他指向原始链表的head节点.(ListNode cur=head) prev节点用来保存cur的前一个节点,刚开始设为null .(ListNode prev=null) 定义一个newNode节点,
剑指[28]_对称的二叉树
从零开始的异世界JAVA学习
11-13 981
题目来源:剑指 Offer 28. 对称的二叉树 题目描述 请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 1 / \ 2 2 / \ / \ 3 4 4 3 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的: 1 / \ 2 2 \ \ 3 3 示例 1： 输入：root = [1,2,2
剑指[42]_最大子序列之和(连续子数组的最大和)
从零开始的异世界JAVA学习
11-15 948
题目来源:剑指 Offer 42. 连续子数组的最大和 题目描述: 输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。 要求时间复杂度为O(n)。 示例1: 输入: nums = [-2,1,-3,4,-1,2,1,-5,4] 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。 示例 2： 输入：nums = [1] 输出：1 示例 3： 输入：nums = [0] 输出：0 示例 4： 输入：nums = [-1] 输出：-1
二分查找算法复习
从零开始的异世界JAVA学习
02-11 812
首先二分查找算法是要基于当前数组为有序数组; 实际就是每次找中心点的值; 若目标数等于中心点了,直接返回即可,若目标数小于中间数,则在中心点的左侧查找,反之则在中心点的右边查找. 在实际的使用中,二分查找可以用不同模板的方式实现,那么具体在判断中心点时的规则就不一样. 从经典的基本问题入手;力扣原题704. 二分查找; class Solution { public int search
单链表反转,快慢指针解决链表的常见问题
从零开始的异世界JAVA学习
12-23 711
线性表的链式存储表示的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因此，为了表示每个数据元素与其直接后继数据元素 之间的逻辑关系…
数据结构练习试题和答案解析.docx
12-13
数据结构是计算机科学中的一个基础概念，用来描述数据元素之间的逻辑关系以及它们在计算机内部的存储...通过不断练习数据结构的相关试题和答案解析，可以加深对数据结构的理解和掌握，为以后的编程工作打下坚实的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小智RE0

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

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

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

打赏作者

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

抵扣说明：

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

余额充值