Leetcode刷题——链表类

最新推荐文章于 2022-07-25 14:53:04 发布
最新推荐文章于 2022-07-25 14:53:04 发布
阅读量323 收藏 1
点赞数
分类专栏： LeetCode刷题 文章标签： leetcode 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39181839/article/details/110876824
版权

Leetcode刷题——链表类

整理不易，希望对你有所帮助和启发，路过点个赞或者评论一下吧~
160，相交链表，easy

206，反转链表，easy

21，合并两个有序链表，easy

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

83-Ⅱ.删除排序链表中的重复元素，middle

19，删除链表的倒数第N个节点，middle

24，两两交换链表中的节点，middle

445，两数相加Ⅱ，middle

234，回文链表，easy

725，分隔链表，middle

328，奇偶链表，middle

160，相交链表，easy

输入两个链表，找出它们的第一个公共节点。

如下面的两个链表：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 方法：双指针。

  • 思路：定义节点pA指向headA，节点pB指向headB。

    • 如果两链表长度相同
      • 有交点，返回此交点
      • 没有交点，返回null
    • 如果两链表长度不同，先走完的指针指向另一个链表的头节点（如示例2的pB先走完，则指向headA），两指针再次出发，直到后走完的指针也走完了当前链表，使其指向另一链表（即pA走完，指向headB），两指针再次出发，直到找到交点或没有交点走完两链表。

  • 代码：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //双指针，pA与pB如果能相遇，说明两个链表长度相同且有交点；第一遍不能相遇，pA转移到pB,pB转移到pA
        //再次遍历，如果能相遇说明有交点

        ListNode pA = headA;
        ListNode pB = headB;
//判别两个链表是否为空
        if (pA == null || pB == null) {
            return null;
        }
//长度不同会有先走完链表的
        while(pA != null && pB != null){
            pA = pA.next;
            pB = pB.next;
        }
//A先走完,转向headB pB同理
        if(pA == null){
            pA = headB;
        }
        else {
            pB = headA;
        }
//再次同时走，A继续向前，B转为headA        
        while(pA != null && pB != null){
            pA = pA.next;
            pB = pB.next;
        }
        if(pA == null){
            pA = headB;
        }
        else {
            pB = headA;
        }
//pA在B链表，pB在A链表，同时向前找交点
        while(pA != pB){
            pA = pA.next;
            pB = pB.next;
        }
        return pA;
    }
}

简化：

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode pA = headA;
        ListNode pB = headB;
        while(pA != pB){
            pA = pA == null ? headB:pA.next;
            pB = pB == null ? headA:pB.next;
        }
        return pA;
    }
}
  • 注意点：边界条件的判断：两链表可能为空。
206，反转链表，easy

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

  • 方法一：递归。

    • 思路：先递归到底, 找到最后一个节点, 然后从最后一个节点开始, 把箭头方向掉转。
      在这里插入图片描述
      递归出口：链表为空或递归到链表的尾节点

在这里插入图片描述
递归体：假如归到节点2，
在这里插入图片描述

  • 代码：
class Solution {
   public ListNode reverseList(ListNode head) {
//方法一：递归
       //终止条件：链表为空或递归到链表的尾节点时
       if(head == null || head.next == null) return head;

       ListNode cur = reverseList(head.next);
       head.next.next = head;
       head.next = null;

       return cur;
   }
}

  • 方法二：迭代。

  • 思路：构建新链表，将原链表加入新链表，并调转顺序。
    在这里插入图片描述
    直到head = null

  • 代码：

class Solution {
    public ListNode reverseList(ListNode head) {
    	ListNode newHead = null; //null
        while(head != null){
            ListNode temp = head.next;//保存后面用的新链表 2—>3->4->null
            head.next = newHead;      //null<-1
            newHead = head;           //更新结果链表 1为newHead
            head = temp;              //更新原链表 2—>3->4->null中的2为head
        }
        return newHead;
    }
}
21，合并两个有序链表，easy

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

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
  • 方法一：迭代。
    • 思路：建立新节点（值为0），再定义一个临时节点temp存储链表。比较 l1.val 与 l2.val 。如果 l1.val < l2.val，temp的下个节点设为l1，并将l1 向右移；如果 l1.val >= l2.val，对 l2 进行上述操作。如果一个链表全部存完为空，将另一个链表剩余节点加入temp.next。最后返回newHead.next。
    • 代码：
class Solution {
   public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
       //方法一、迭代。新建链表
       if(l1 == null) return l2;
       if(l2 == null) return l1;
       ListNode newHead = new ListNode(0);
       ListNode temp = newHead;
       //l1与l2都不为空，较小的加入新链表
       while(l1 != null && l2 != null){
           if(l1.val < l2.val){
               temp.next = l1;
               l1 = l1.next;
           }
           else if(l1.val >= l2.val){
               temp.next = l2;
               l2 = l2.next;
           }
           temp = temp.next;
           if(l1 == null){
               temp.next = l2;
           }
           if(l2 == null){
               temp.next = l1;
           }
       }
       return newHead.next;
   }
}
  • 方法二：递归。思路和上面一致。
  • 代码：
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
         if(l1 == null) return l2;
        if(l2 == null) return l1;

        ListNode newHead = new ListNode(0);
        if(l1.val < l2.val){
            newHead = l1;
            newHead.next = mergeTwoLists(l1.next,l2);
        }
        else if(l1.val >= l2.val){
            newHead = l2;
            newHead.next = mergeTwoLists(l1,l2.next);
        }
        return newHead;
    }
}
83，删除排序链表中的重复元素，easy

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

示例 1:

输入: 1->1->2
输出: 1->2

示例 2:

输入: 1->1->2->3->3
输出: 1->2->3
  • 方法一：直接法。

    • 思路：定义辅助单指针temp = head，比较temp与temp.next的值，如果相同，temp.next = temp.next.next，即在这里插入图片描述

      如果不同，temp = temp.next，指针右移。

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
     	ListNode temp = head;
        while(temp != null && temp.next != null){
            if(temp.val == temp.next.val){
                temp.next = temp.next.next;
            }
            else{
                temp = temp.next;
            }
        }
        return head;
    }
}

  • 方法二：双指针。

    • 思路：快慢指针。快指针用于探路，慢指针为结果链表指针。快指针如果与慢指针的值相等，快指针右移；不相等，保存到慢指针快指针再右移。
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null) return null;
        ListNode right = head.next;
        ListNode left = head;
        while(right != null){
            if(right.val != left.val){
                left.next = right;
                left = left.next;
            }
            else{
                right = right.next;
            }
        }
        //断开与后面重复元素的连接
        left.next = null;
        return head;
    }
}

  • 方法三：递归。

    • 思路：把链表看成 头节点->没有重复元素的排序链表，则比较头节点与子链表的头节点，如果相同，返回子链表的头节点；否则，返回head。
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
//递归出口 空链表和链表只有头节点
        if(head == null || head.next == null) return head;

        ListNode newHead = deleteDuplicates(head.next);
        head.next = newHead;

        return head.val == newHead.val ? newHead : head;
    }
}
83-Ⅱ.删除排序链表中的重复元素，middle

给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。

示例 1:

输入: 1->2->3->3->4->4->5
输出: 1->2->5

示例 2:

输入: 1->1->1->2->3
输出: 2->3
  • 方法一：递归。
    • 思路：和上面那道题思路类似，但要判断头节点与后面元素是否相同。如果相同，找到第一个不重复的元素开始递归；如果不同，与上面题类似。
    • 代码：
class Solution {
   public ListNode deleteDuplicates(ListNode head) {
//递归
       if(head == null || head.next == null) return head;
       //如果head与后面的节点重复，找到第一个不重复的节点，进行递归。
       if(head.val == head.next.val){
           while(head != null && head.next != null && head.val == head.next.val){
               head = head.next;
           }
           return deleteDuplicates(head.next);
       }
       else{
           ListNode newHead = deleteDuplicates(head.next);
           head.next = newHead;

           return head;
       }
   }
}

  • 方法二：双指针-快慢指针。

    • 思路：建立虚拟头节点dummy，双指针left指向dummy，right指向head，判断left.next 与 right.val是否相等。如果不相等，两指针右移；如果相等，right需要跳过所有重复数字，再令left的下一位为 right.next（第一个不重复的数字）。最后返回dummy之后的节点。
    • 代码：
class Solution {
   public ListNode deleteDuplicates(ListNode head) {
//双指针，建立虚拟头节点
       if(head == null || head.next == null) return head;

       ListNode dummy = new ListNode(-1);
       dummy.next = head;
       ListNode left = dummy;
       ListNode right = head;
       while(right != null && right.next != null){
           if(left.next.val != right.next.val){
               left = left.next;
               right = right.next;
           }
           else{
               while(right != null && right.next != null && left.next.val == right.next.val){
                   right = right.next;//right右移直到right.next不是重复数字
               }
               left.next = right.next;//left下一位是去掉重复数字之后的数字
               right = right.next;//继续右移
           }
       }
       return dummy.next;
   }
}
19，删除链表的倒数第N个节点，middle

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

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.
  • 方法一：先求出链表长度，就可以找到要删除节点的前一个节点，再使他指向后一个节点即可。
    • 代码：
class Solution {
//先得到长度，再单指针跳过倒数第n个元素 
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if(head == null || head.next == null) return null;
        ListNode temp = head;

        int length = getLength(head);
        if(length == n) return head.next;

        for(int i = 0; i < length - n - 1; i++){
            temp = temp.next;
        }
        temp.next = temp.next.next;
        return head;
    }
    public int getLength(ListNode head){
        int length = 1;
        while(head.next != null){
            length++;
            head = head.next;
        }
        return length;
    }
}

  • 方法二：双指针-快慢指针。

    • 思路：令快指针先走 n 步，慢指针再与快指针同时出发，直到快指针走到链表尾部，此时慢指针走到要删除节点的前一个节点，跳过即可。有些类似第160题.相交链表
    • 代码：
class Solution {
   public ListNode removeNthFromEnd(ListNode head, int n) {
       public ListNode removeNthFromEnd(ListNode head, int n) {
       ListNode fast = head;
       ListNode slow = head;
       //快指针先走n步
       for(int i = 0; i < n; i++){
           fast = fast.next;
       }
       //如果此时fast为空，说明删除的是头节点
       if(fast == null){
           return head.next;
       }
       //fast走到头，此时slow走到要删除节点的前一个
       while(fast.next != null){
           fast = fast.next;
           slow = slow.next;
       }
       slow.next = slow.next.next;
       return head;
   }
}
24，两两交换链表中的节点，middle

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1：

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

示例 2：

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

示例 3：

输入：head = [1]
输出：[1]
  • 方法一：递归。
    • 思路：两个相邻节点看为一组，组间节点交换（递归实现），再调整组间顺序。
    • 代码：
class Solution {
    public ListNode swapPairs(ListNode head) {
        if(head == null || head.next == null) return head;
        //两个相邻节点为一组，使后一个节点的指针指向前一个，组间指向也需要调整
        //先保存节点2
        ListNode temp = head.next;
        //头节点下一个节点为递归的结果（1->4->3）
        head.next = swapPairs(head.next.next);
        //2->1->4->3
        temp.next = head;

        return temp;
    }
}

  • 方法二：迭代。

    • 思路：定义一个虚拟头节点dummy，三个指针：left、right用于进行交换，temp用于连接两次迭代之间的节点。
    • 代码：
class Solution {
    public ListNode swapPairs(ListNode head) {
    //迭代
        if(head == null || head.next == null) return head;
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode left = dummy;
        ListNode right = dummy; 
        ListNode temp = dummy;
        while(right != null && right.next != null && right.next.next != null){
            //分别向前走一步、两步
            left = left.next; // 1
            right = right.next.next; //2

            //使下次循环的1指向4
            temp.next = right;
            left.next = right.next;
            right.next = left;
            //2->1->3->4
        
            //再使temp、right都指向1.下次迭代时left为3，right为4
            temp = left;
            right = left;
        }
        return dummy.next;
    }
}
445，两数相加Ⅱ，middle

给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

进阶：

如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。

示例：

输入：(7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
输出： 7 -> 8 -> 0 -> 7
  • 题目说明：题目中说明最高位位于链表头部，即 7243 + 564 = 7807，最后输出的即7 -> 8 -> 0 -> 7。
  • 方法一：借助栈。
    • 思路：逆序先想到栈来存储链表节点的值，相加后再弹出，存储到一个新的链表。注意要记录进位，加到下一位。
    • 图解：
      在这里插入图片描述
    • 代码：
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
//法一：栈+取和的个位
        Stack<Integer> stack1 = new Stack<>();
        Stack<Integer> stack2 = new Stack<>();
        while(l1 != null){
            stack1.push(l1.val);
            l1 = l1.next;
        }
        while(l2 != null){
            stack2.push(l2.val);
            l2 = l2.next;
        }
        
        int carry = 0;//相加的进位
        ListNode head = null;
        //有非空栈或carry > 0就进行相加操作
        while(!stack1.isEmpty() || !stack2.isEmpty() || carry > 0){ 
            
            int sum = carry;//两数的和
            sum += stack1.isEmpty() ? 0 : stack1.pop();
            sum += stack2.isEmpty() ? 0 : stack2.pop();

            ListNode node = new ListNode(sum % 10);
            node.next = head;
            head = node;

            carry = sum / 10;
        }
        return head;
    }
}

注意：while条件里添加carry > 0是为了

输入:(5) + (5)
输出: 1->0

也可以单独判断carry，如果stack1、stack2都为空了但还有进位，则创建新节点加入结果。

while(!stack1.isEmpty() || !stack2.isEmpty() ){ 
            
            int sum = carry;//两数的和
            sum += stack1.isEmpty() ? 0 : stack1.pop();
            sum += stack2.isEmpty() ? 0 : stack2.pop();

            ListNode node = new ListNode(sum % 10);
            node.next = head;
            head = node;

            carry = sum / 10;
        }
        if(carry > 0){
            ListNode node1 = new ListNode(carry);
            node1.next = head;
            head = node1;
            }
        return head;
}

  • 方法二：反转链表。

    • 思路：因为要从链尾开始相加，所以先反转链表，两个链表从头开始相加节点的值，再将新的链表反转，得到结果。
    • 代码：
 class Solution {
   public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
       //法二：反转链表 3->4->2->7 4->6->5  7 -> 0 -> 8 ->7反转输出结果
       if(l1 == null || l2 == null) return l1 == null ? l2 : l1;
       ListNode newl1 = reverse(l1);
       ListNode newl2 = reverse(l2);
      
       ListNode dummy = new ListNode(-1);
       ListNode cur = dummy;
       int carry = 0;//进位
       while(newl1 != null || newl2 != null || carry > 0){
           int sum = carry;
           sum += newl1 == null ? 0 : newl1.val;
           sum += newl2 == null ? 0 : newl2.val;

           ListNode node = new ListNode(sum % 10);
           cur.next = node;
           cur = node;

           carry = sum / 10;
           if(newl1 != null) newl1 = newl1.next;
           if(newl2 != null) newl2 = newl2.next;
       }
       ListNode res = reverse(dummy.next);
       return res;
   }
   public ListNode reverse(ListNode head){
       if(head == null || head.next == null) return head;
       ListNode node = reverse(head.next);
       head.next.next = head;
       head.next = null;
       return node;
   }
}

扩展：另一道类似题

image-20200805204018584.png

  • 题目说明：逆序存储，即链尾为高位，相加得到结果仍要逆序输出。
  • 代码：
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    if (l1 == null || l2 == null) return l1 == null ? l2 : l1;
        int carry = 0;//进位
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        while (l1 != null || l2 != null || carry > 0) {
            int sum = carry;
            sum += l1 == null ? 0 : l1.val;
            sum += l2 == null ? 0 : l2.val;
            ListNode node = new ListNode(sum % 10);
            cur.next = node;
            cur = node;
            carry = sum / 10;
            if(l1 != null) l1 = l1.next;
            if(l2 != null) l2 = l2.next;
        }
        return dummy.next;
    }
}
234，回文链表，easy

请判断一个链表是否为回文链表。

示例 1:

输入: 1->2
输出: false

示例 2:

输入: 1->2->2->1
输出: true
  • 方法一：借助栈。
    • 思路：将链表节点值放入栈并统计链表长度，循环 l/2 次（只需比较前一半节点值），如果链表的头部值与栈弹出的值不相等，返回false；否则节点右移，最终返回true。
    • 代码：
class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head == null) return true;
        Stack<Integer> stack = new Stack<>();
        ListNode temp = head;
        //将节点值放入栈
        int length = 0;
        while(temp != null){
            stack.push(temp.val);
            temp = temp.next;
            length++;
        }
        
        length /= 2;
        while(length-- > 0){
            if(stack.pop() != head.val){
               return false;
            }
            head = head.next;
        }
        return true;
    }
}
  • 方法二：将链表节点值转为集合存储，再使用双指针-头尾指针。
    • 代码：
class Solution {
    public boolean isPalindrome(ListNode head) {
        List<Integer> list = new ArrayList<>();
        while(head != null){
            list.add(head.val);
            head = head.next;
        }
        int left = 0;
        int right = list.size() - 1;
        while(left < right){
            if(!list.get(left).equals(list.get(right)))
                return false;
            else{
            left++;
            right--;
            }
        }
        return true;
    } 
}

  • 错误点：if(list.get(left) != list.get(right)) 错误

    • Integer是对象，比较两个对象相等要用equals
    • 使用 == 比较Integer类型时，默认缓存 -128 ~ 127，超过此范围会new新对象，两个对象地址不一样则返回false

  • 方法三：快慢指针。

    • 思路：找到中间节点，将后半段链表进行反转，再比较反转后的链表与原链表前半段的值。
    • 代码：
class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head == null) return true;
        ListNode middle = getMiddle(head);//链表中点，如果长度是偶数，返回第 l/2 - 1 个节点
        ListNode newHead = reverse(middle.next);//反转后半部分链表
        //比较前半部分和后半部分链表的节点值
        while(newHead != null){
            if(head.val != newHead.val){
                return false;
            }
            else{
                head = head.next;
                newHead = newHead.next;
            }
        }
        return true;
    } 
    public ListNode getMiddle(ListNode head){
        ListNode left = head;
        ListNode right = head;
        while(right.next != null && right.next.next != null){
            left = left.next;
            right = right.next.next;
        }
        return left;
    }
    //返回链表的中间节点
    public ListNode reverse(ListNode head){
        if(head == null || head.next == null) return head;
        ListNode temp = reverse(head.next);
        head.next.next = head;
        head.next = null;
        return temp;
    }
}
725，分隔链表，middle

给定一个头结点为 root 的链表, 编写一个函数以将链表分隔为 k 个连续的部分。

每部分的长度应该尽可能的相等: 任意两部分的长度差距不能超过 1，也就是说可能有些部分为 null。

这k个部分应该按照在链表中出现的顺序进行输出，并且排在前面的部分的长度应该大于或等于后面的长度。

返回一个符合上述规则的链表的列表。

举例： 1->2->3->4, k = 5 // 5 结果 [ [1], [2], [3], [4], null ]

示例 1：

输入: 
root = [1, 2, 3], k = 5
输出: [[1],[2],[3],[],[]]
解释:
输入输出各部分都应该是链表，而不是数组。
例如, 输入的结点 root 的 val= 1, root.next.val = 2, \root.next.next.val = 3, 且 root.next.next.next = null。
第一个输出 output[0] 是 output[0].val = 1, output[0].next = null。
最后一个元素 output[4] 为 null, 它代表了最后一个部分为空链表。

示例 2：

输入: 
root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
输出: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
解释:
输入被分成了几个连续的部分，并且每部分的长度相差不超过1.前面部分的长度大于等于后面部分的长度。

  • 方法一：拆分链表。

    • 思路：分类讨论。

      • 如果链表为空，返回 k 个空节点组成的节点数组。
      • 如果链表长度l <= k，前 l 个元素是单个节点，后 l - k 个元素为空。
      • 如果链表长度l > k，每部分至少有 l / k 个节点，前 l % k 部分节点数 + 1。再将原链表分部分存储在结果数组中，每部分为一个链表，部分之间要断开连接。

    • 代码：

class Solution {
    public ListNode[] splitListToParts(ListNode root, int k) {
        if(root == null) return new ListNode[k];
        ListNode[] res = new ListNode[k];
        int length = getLength(root);
        if(length <= k){
            for(int i = 0; i < length; ){
                ListNode temp = root.next;
                root.next = null;
                res[i++] = root;
                root = temp;
            }
            for(int i = length; i < k; i++){
                res[i] = null;
            }
        }
        else if(length > k){
        //length 比 k 大时 每部分存放 l/k 个节点 , 前 l%k 部分存放 l/k+1 个节点
        int n = length / k;
        int m = length % k;
        int[] counts = new int[k];//记录每部分存储元素个数，[4][3][3]
        for(int i = 0; i < k; i++){
            counts[i] = m-- > 0 ? n + 1: n;
        }
        ListNode cur = root;
        //将节点存储到数组中 counts[0]=4
        for(int i = 0; i < k; i++){
            res[i] = cur;
            //跳到每部分最末节点 1->2->3->4
            for(int j = 0; j < counts[i] - 1; j++){
                cur = cur.next;
            }
            //断开每部分之间的连接
            ListNode temp = cur.next;
            cur.next = null;
            cur = temp;
         }
        }
        return res;
    }
    public int getLength(ListNode node){
        int length = 0;
        while(node != null){
            length++;
            node = node.next;
        }
        return length;
    }
}
328，奇偶链表，middle

给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。

请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。

示例 1:

输入: 1->2->3->4->5->NULL
输出: 1->3->5->2->4->NULL

示例 2:

输入: 2->1->3->5->6->4->7->NULL 
输出: 2->3->6->7->1->5->4->NULL

说明:

应当保持奇数节点和偶数节点的相对顺序。
链表的第一个节点视为奇数节点，第二个节点视为偶数节点，以此类推。

  • 方法一：双指针，分离链表为奇链表、偶链表，再合并。
    • 代码：
class Solution {
    public ListNode oddEvenList(ListNode head) {
//双指针
        if(head == null) return head;
        
        ListNode odd = head;
        ListNode evenHead = head.next;
        ListNode even = evenHead;
        
        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;
    }
}
RuiW_97
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【OJ】 单链表OJ刷题
yangke369的博客
05-15 629
1、移除链表元素   删除链表中等于给定值 val 的所有节点。OJ链接   示例：   输入: 1->2->6->3->4->5->6, val = 6   输出: 1->2->3->4->5 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct L
Java条件表达式/LeetCode第160题相交链表
柠檬鱼的博客
12-24 474
条件表达式的一般使用形式为： 表达式 1?表达式 2:表达式 3 其中，“?”与 “:” 为条件运算符，须一起使用，是 Java 中唯一的三元运算符，需要三个操作数才能进行运算。 条件表达式的运算规则为： 如果表达式 1 的结果为真，则整个条件表达式的值为表达式 2 的值；否则，整个条件表达式的值为表达式 3 的值。 例如： pA = pA == null ? headB : pA.next; 如果pA为为空，则将B的头指针赋给pA，否则将pA的后继赋给pA。 这里，pA == null ? headB
删除链表全部重复结点
suming97的博客
07-25 468
删除重复结点的两种方法
两个链表的第一个公共节点
m0_50711251的博客
09-11 380
pA = pA == null ? headB : pA.next; 此代码的执行顺序是：pA =（ pA == null ? headB : pA.next;），本质是一个赋值语句 参考
链表p38 1-20
云淡风轻_的博客
09-05 365
1.设计一个递归算法，删除不带头结点的单链表中所有值为x的结点 终止条件：若表空，不做任何事 递归主体：值相等，1、删除结点，2、继续处理后续结点。值不等，1、递归处理子序列 void Delete_x(Linklist &l,int x){ if(l==NULL) return; //空表情况 if(l->data!=x){ //不等的情况 Dlete_x(l->next,x); return; } .
LeetCode刷题笔记——#2. 两数相加
01-20
两个链表长度不一定相等   这两个就是编程的时候要注意的。接下来依次看看不同的代码写法。   flag 作为进位位，用if对不同的可能性进行分类。 from typing import List ###### leetcode 代码主体 ###### class ...
leetcode:leetcode刷题
03-07
《LeetCode刷题指南——Java实现篇》 LeetCode，一个全球知名的在线编程挑战平台，为程序员提供了大量的算法题目，旨在提升编程技能、面试准备以及解决问题的能力。在Java领域，LeetCode上的题目覆盖了基础算法、...
leetcode:leetcode刷题笔记
04-06
《LeetCode刷题笔记——Python篇》 在编程学习与面试准备中，LeetCode是一个备受推崇的在线平台，它提供了大量的编程题目，旨在提升解决算法问题的能力。本笔记主要聚焦于使用Python语言在LeetCode上的刷题过程，...
LeetCode：LeetCode刷题笔记
02-21
《LeetCode刷题笔记——深度探索Java编程技巧》 在编程的世界里，LeetCode是一个备受推崇的在线平台，它提供了一系列的算法题目，旨在提升程序员的编程能力、算法理解和问题解决技巧。本压缩包文件围绕“LeetCode...
C++leetcode刷题c-c-master.zip
最新发布
03-18
本资料“C++leetcode刷题c-c-master.zip”正是围绕C++语言，针对LeetCode平台进行深入学习和实践的资源集合。 首先，让我们来了解一下C++。C++是一种静态类型的、编译式的、通用的、大小写敏感的、不仅支持过程化...
【Java】在一个有序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
qq_43669007的博客
06-21 1049
在一个有序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5 有两种方法：创建一个虚结点和不创建虚结点 方法1：创建一个虚结点 1.创建一个假结点fake，让它的下一个结点为head,设Node prev=fake；设p1=...
链表算法面试题---删除链表中的重复元素II
自律使我自由
03-23 249
给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中没有重复出现的数字。 举例： 原链表: 1->2->3->3->4->4->5 删除后: 1->2->5 解法1： 结合删除重复节点和删除指定节点的方式，可以先删除重复节点，并记录下来重复节点的值，然后再删除指定节点的值即可。 public class Code_06 { public static void main(String[] args) { Code_06 c
【每日leetcode】删除排序链表中的重复元素 II
summer2day的博客
10-07 269
给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。 示例 1: 输入: 1-&gt;2-&gt;3-&gt;3-&gt;4-&gt;4-&gt;5 输出: 1-&gt;2-&gt;5 示例 2: 输入: 1-&gt;1-&gt;1-&gt;2-&gt;3 输出: 2-&gt;3 ——————————————————————————————————————语言:c...
有序链表中重复数字的全部删除；交叉链表求交点；合并有序链表；
weixin_43767691的博客
10-14 212
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5 首先要想到所有的情况，然后再开始 ListNode* deleteDuplication(ListNode* pHead) { if (pHead == nullptr) ...
Leetcode_#83_从有序链表中删除重复节点
松生的博客
04-29 254
原题：#83_从有序链表中删除重复节点 解题思路：链表本身有序，所以若是有重复，那必是连在一起的 单指针（双指针类似）： 时间复杂度：O(n) 空间复杂度：O(1) public ListNode f (ListNode head) { if (head == null) return null; ListNode cur = head; w...
常见的链表面试问题详解(双指针思维)
oorik的博客
04-26 1584
面试的时候经常碰见诸如获取倒数第k个元素，获取中间位置的元素，判断链表是否存在环，判断环的长度等和长度与位置有关的问题。这些问题都可以通过灵活运用双指针来解决。 问题一:剑指Offer.链表中倒数第k个节点 问题描述: 输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。 例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。 思路解读： 设有
一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
zxjkl123的博客
11-10 747
一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 public ListNode deleteDuplication() { if (this.head == null) { return null; } ListNode cur = this.head; ListNode newHead = new ...
LeetCode每日一题：相交链表
Lin_Willen的博客
04-01 190
题目：编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8 输入解释：相交节点的值...
给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现的数字。Java双指针实现
我的梦境传说
06-25 1587
public class Solution1 { /** * 删除有序链表中重复的节点，只保留出现一次的节点 * @param head 链表 * @return 链表头 */ public static ListNode deleteDuplicates(ListNode head) { //链表的长度小于等于1，直接返回 if(head == null || head.next == null){ ...
leetcode刷题手册c++版
09-07
LeetCode刷题手册C版是一本针对程序员刷题的教材，旨在帮助他们提高编程能力、学习算法和数据结构。C语言作为一门广泛应用于系统编程和嵌入式开发的语言，在LeetCode刷题中也是非常重要的一种编程语言。 这本手册主要包括了LeetCode网站上的题目分类和解题思路。它以系统的方式组织了数百道LeetCode题目，并提供了针对每道题目的解题思路和详细的C语言代码实现。通过这本手册，程序员可以快速了解各种算法和数据结构的特点，掌握它们在解决实际问题中的应用。 LeetCode刷题手册C版的优势在于它提供了C语言的实现和相关的技巧。C语言是一种高效、灵活且广泛使用的编程语言，掌握C语言的编程技巧能够帮助程序员更好地理解算法和数据结构的原理，并设计出高质量的代码。此外，C语言也是很多面试中常见的编程语言，因此掌握LeetCode刷题手册C版可以帮助程序员在面试中更好地展示自己的技术能力。 总之，LeetCode刷题手册C版是一个针对C语言程序员的宝贵资源，它可以帮助程序员提升编程能力、学习算法和数据结构，并在面试中展现自己的优势。通过刷题手册C版的学习，程序员可以更好地理解LeetCode题目，提高解题效率，进一步提升自己的技术水平。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值