leetcode链表

最新推荐文章于 2024-07-21 08:37:44 发布

dream——

最新推荐文章于 2024-07-21 08:37:44 发布

阅读量128

点赞数 1

文章标签： leetcode

本文链接：https://blog.csdn.net/qq_43584329/article/details/126981019

版权

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

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

示例 1：

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

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

迭代解法：

class Solution {
    public ListNode swapPairs(ListNode head) {
         ListNode dump=new  ListNode(0);
         dump.next=head;
         ListNode cur=dump;
         while(cur.next!=null&&cur.next.next!=null){
               ListNode temp=cur.next;              //在一个位置对后两个点进行操作
               ListNode temp1=cur.next.next;
               temp.next=temp1.next;
               cur.next=temp1;
               temp1.next=temp;  
               cur=cur.next.next;   //每次向后移两位
         }
         return dump.next;
    }
}

递归解法：

class Solution {
    public ListNode swapPairs(ListNode head) {
         if(head==null||head.next==null){
             return head;
         }           //递归终止条件，我觉得可以判断比如空链表或者一个点的情况，也可以根据递归进行推导，这里head==null就返回null，first.next=null后面接了一个null，只有一个点就后面接一个点
         ListNode first=head;
         ListNode second=head.next;
         ListNode temp=head.next.next;   //second指向first后面就断掉了需要先记录好
         second.next=first;
         first.next=swapPairs(temp);
         return second;
    }
}

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

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

示例 1：

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

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

提示：

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

**进阶：**你能尝试使用一趟扫描实现吗？

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
       ListNode dump=new ListNode(0);   //虚拟头节点的作用主要是比如要删除第一个点时方便进行操作
       dump.next=head;
       ListNode fast=dump;
       ListNode slow=dump;        //经典快慢指针，快指针先走，之后快慢指针一起走，找一个情况分析一些就能想明白
       while(n-->0){
           fast=fast.next;
       }
       while(fast.next!=null){
           fast=fast.next;
           slow=slow.next;
       }
       slow.next=slow.next.next;
     return dump.next;

    }
}

203. 移除链表元素

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

示例 1：

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

示例 2：

输入：head = [], val = 1
输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

提示：

列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dump=new ListNode(0);
        dump.next=head;
        ListNode cur=dump;
        while(cur.next!=null){            //这里需要注意删除了一个点后，cur不应该向后移动，因为需要判断下一个点是否也要被删除只有当下一个不会被删除时cur才会向后移一位，第一次做的时候写错了
            if(cur.next.val==val){
                cur.next=cur.next.next;
            }
            else{
            cur=cur.next;
            }
        }
        return dump.next;
    }
}

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

提示：

所有val值都在 [1, 1000] 之内。
操作次数将在 [1, 1000] 之内。
请不要使用内置的 LinkedList 库。

class MyLinkedList {       //不使用内置的linkedlist自己定义listnode结构实现链表
     ListNode dump;
     int size;           //需要定义size方便操作
     class ListNode{
         ListNode next;
         int val;
         public ListNode(int val){
             this.val=val;
         }
         
     }
    public MyLinkedList() {
        dump=new ListNode(0);
        size=0;
    }
    
    public int get(int index) {    //都需要对特殊情况进行判断
        if(index<0||index>size-1){
            return -1;
        } ListNode cur=dump;
        while(index-->=0){
            cur=cur.next;
        }
         return cur.val;
     

    }
    
    public void addAtHead(int val) {
         size++;
         ListNode cur=new ListNode(val);
         cur.next=dump.next; 
          dump.next=cur;
    }
    
    public void addAtTail(int val) {
        ListNode cur=dump;
        while(cur.next!=null){
            cur=cur.next;
        }
        ListNode node=new ListNode(val);
        cur.next=node;
        size++;
    }
    
    public void addAtIndex(int index, int val) {
         if(index>size){
             return;
         }
         if(index<0){            //一般都会复用代码
             addAtHead(val);
             return;
         }
         if(index==size){
             addAtTail(val);
             return;
         }
         ListNode cur=dump;
         while(index-->0){
           cur=cur.next;
         }
         ListNode node=new ListNode(val);
         node.next=cur.next;
         cur.next=node;
         size++;
    }
    
    public void deleteAtIndex(int index) {
          if(index<0||index>size-1){
              return;
          }
          ListNode cur=dump;
          while(index-->0){
            cur=cur.next;
          }
          cur.next=cur.next.next;
          size--;
    }
}

206. 反转链表

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

示例 1：

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

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

迭代

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre=null;         //一个pre一个cur
        ListNode cur=head;              //pre从null开始cur从head开始迭代
        while(cur!=null){
            ListNode temp=cur.next;    
            cur.next=pre;      //cur指向pre
            pre=cur;           //两个都向后移动
            cur=temp;
        }
        return pre;       //最后cur为null返回pre
    }
}

递归

第一种两个参数

class Solution {
    public ListNode reverseList(ListNode head) {    //这种和迭代很像，维护两个参数
       return reverse(null,head);
    }
    public ListNode reverse(ListNode pre,ListNode cur){
        if(cur==null){              //终止条件和迭代一样
            return pre;
        }
        ListNode temp=cur.next;       //每次进行同样的操作
        cur.next=pre;
        return reverse(cur,temp);         //通过递归的参数维护迭代的两个点
    }
}

第二种一个参数

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null){  //终止条件应该是head.next=null还需要考虑head=null的情况
            return head;
        }
       ListNode last=reverseList(head.next);      //明确递归函数的定义返回的是翻转后链表的头节点
       head.next.next=head;           //这里因为第一个点还连着翻转的链表的尾节点进行操作
       head.next=null;          
       return last;
    }

}

面试题 02.07. 链表相交

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

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

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

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

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：

listA 中节点数目为 m
listB 中节点数目为 n
0 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode a=headA;
        ListNode b=headB;
      while(a!=b){                     //a走到空去b上走，b走到空去a上走
          a=(a!=null?a.next:headB);      //最后要么相等要么都走到最后都为空
          b=(b!=null?b.next:headA);
      }
      return a;
    }
}