LeetCode链表(链表操作,反转链表,奇偶链表,排序链表)

文章目录

  • 前言
    • 1.链表定义
    • 2.链表操作
    • 3.技巧
  • 链表常见操作
    • 1.lc203 移除链表元素
    • 2.lc2 两数相加
    • 3.lc328 奇偶链表
  • 反转链表
    • 1.lc206 反转链表
    • 2.lc92 反转链表II
  • 链表排序
    • 1.lc147 对链表进行插入排序
    • 2.148. 排序链表
  • 链表双指针
    • 1.lc19 删除链表的倒数第 N 个结点
    • 2.lc21 合并两个有序链表
    • 3.lc24 两两交换链表中的节点
    • 4.lc234 回文链表

前言

本篇文章更注重于链表自身的特点(如果是关于双指针,链表数组字符串中都会出现,所以这里列举几题,更详细的见双指针)

1.链表定义

链表是一种通过指针串联在一起的线性结构。链表中的每个元素实际上是一个单独的对象,而所有对象都通过每个元素中的引用字段链接在一起。链表的入口节点称为链表的头结点也就是head。

(1)单链表

每一个节点由两部分组成,一个是数据域一个是指针域(存放指向下一个节点的指针),最后一个节点的指针域指向null(空指针的意思)。
LeetCode链表(链表操作,反转链表,奇偶链表,排序链表)_第1张图片
Java定义

// 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; }
 }

(2)双链表

每一个节点有两个指针域,一个指向下一个节点,一个指向上一个节点。

在这里插入图片描述

Java定义

// Definition for doubly-linked list.
class DoublyListNode {
    int val;
    DoublyListNode next, prev;
    DoublyListNode(int x) {val = x;}
}

(3)循环链表

链表首尾相连

LeetCode链表(链表操作,反转链表,奇偶链表,排序链表)_第2张图片

2.链表操作

(1)删除节点
LeetCode链表(链表操作,反转链表,奇偶链表,排序链表)_第3张图片

具体可以参见力扣:https://leetcode.cn/leetbook/read/linked-list/j47r3/

(2)添加节点
LeetCode链表(链表操作,反转链表,奇偶链表,排序链表)_第4张图片

(3)反转链表

LeetCode链表(链表操作,反转链表,奇偶链表,排序链表)_第5张图片

3.技巧

虚拟头节点+快慢指针!!!
循环过程一般采用while循环(因为链表获取不了索引,索引for不太方便)

链表常见操作

1.lc203 移除链表元素

力扣203链接

描述:

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

示例:

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

Solution:
(可以设置一个虚拟头节点,方便统一操作)

public ListNode removeElements(ListNode head, int val) {
       if(head==null)
       return head;

       ListNode dummy = new ListNode(-1,head);  // 设置虚拟头节点
       ListNode pre = dummy;  // 将虚拟头节点设置为前一节点
       ListNode cur = head;  // 将头节点设置为当前节点

       while(cur!=null)
       {
           if(cur.val==val)
               pre.next = cur.next;
           else
               pre = cur;  // 前一节点后移

           cur = cur.next;  // 无论找没找到当前节点后移
       }
       return dummy.next;
    }

2.lc2 两数相加

lc2链接

描述:

给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。请你将两个数相加,并以相同形式返回一个表示和的链表。

示例:

输入:l1 = [2,4,3], l2 = [5,6,4] ; 输出:[7,0,8]

Solution:
模拟过程,主要是要处理进位。另外的技巧就是可以给位数少的添加前导0

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 开辟一个虚拟头结点
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        int cnt=0; // 初始进位为0

        ListNode head = null;

        while(l1!=null || l2!=null)
        {
            // 添加前导0,使两者位数相同
            int n1 = l1 != null ? l1.val : 0;
            int n2 = l2 != null ? l2.val : 0;

            int sum = n1+n2+cnt;

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

            if(l1!=null)  l1 = l1.next;

            if(l2!=null)  l2 = l2.next;
        }
        if(cnt>0)   cur.next = new ListNode(cnt%10);

        return dummy.next;
    }

3.lc328 奇偶链表

lc328链接
描述:

给定单链表的头节点 head ,将所有索引为奇数的节点和索引为偶数的节点分别组合在一起,然后返回重新排序的列表。第一个节点的索引被认为是 奇数 , 第二个节点的索引为 偶数 ,以此类推

示例:

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

Solution:
模拟过程,将奇偶链表分开。基本功啊!

public ListNode oddEvenList(ListNode head) {
        if(head==null || head.next==null) return head;

        ListNode tmp = head.next;
        
        ListNode odd = head;
        ListNode even = tmp;
        
        while(even!=null && even.next!=null) 
        {
            odd.next = even.next;
            
            odd = odd.next;

            even.next = odd.next;

            even = even.next;

        }
        odd.next = tmp;

        return head;
    }

反转链表

1.lc206 反转链表

lc206 链接

描述:

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

示例:

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

Solution1:迭代法
双指针!
LeetCode链表(链表操作,反转链表,奇偶链表,排序链表)_第6张图片

public ListNode reverseList(ListNode head) {
        if(head==null)
        return head;
        
        ListNode pre = null;
        ListNode cur = head;
        
        while(cur!=null)
        {
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }

Solution2:递归

2.lc92 反转链表II

lc92 链接

描述:

给你单链表的头指针 head 和两个整数 left 和 right ,其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点,返回 反转后的链表

示例:

输入:head = [1,2,3,4,5], left = 2, right = 4 输出:[1,4,3,2,5]

Solution1:迭代法
挺烧脑的,需要好好模拟一下,简单说就是一种穿针引线的方法

LeetCode链表(链表操作,反转链表,奇偶链表,排序链表)_第7张图片

public ListNode reverseBetween(ListNode head, int left, int right) {
           ListNode dummy = new ListNode(-1,head); // 虚拟头节点

           ListNode pre = dummy;
  
           for(int i=1;i<left;i++)
           {
               pre = pre.next;
           }
           ListNode cur = pre.next;

           for(int i=left;i<right;i++)
           {
               ListNode nextNode = cur.next;
               cur.next = nextNode.next;
               nextNode.next = pre.next;
               pre.next = nextNode;
           }
           return dummy.next;

    }

Solution2:递归法

链表排序

链表排序,参考十大排序算法,思想是一样的,但是因为是链表不是数组,所以细节上又要多注意些

1.lc147 对链表进行插入排序

描述:

给定单个链表的头 head ,使用 插入排序 对链表进行排序,并返回 排序后链表的头 。

示例:

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

Solution:
首先回顾一下插入排序

2.148. 排序链表

链表双指针

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

lc19 链接

快慢指针的典型应用!,在 双指针技巧 有介绍

2.lc21 合并两个有序链表

lc21 链接

描述:

将两个升序链表合并为一个新的 升序 链表并返回。

示例:

输入:l1 = [1,2,4], l2 = [1,3,4] 输出:[1,1,2,3,4,4]

Solution:
双指针的应用!

public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode dummy = new ListNode();
        ListNode p = dummy;
        ListNode p1 = list1;
        ListNode p2 = list2;

        while(p1!=null && p2!=null)
        {
            if(p1.val<p2.val)
            {
                p.next = p1;
                p1 = p1.next;
            }
            else
            {
                p.next = p2;
                p2 = p2.next;
            }
             p = p.next;
        }
        if(p1==null)
        {
            p.next = p2;
        }
        if(p2==null)
        {
            p.next=p1;
        }
        return dummy.next;
    }

3.lc24 两两交换链表中的节点

lc24 链接

描述:

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

示例:

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

Solution:

public ListNode swapPairs(ListNode head) {
        ListNode dumyhead = new ListNode(-1,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;  
    }

4.lc234 回文链表

lc234 链接

描述:

给你一个单链表的头节点 head ,请你判断该链表是否为回文链表。如果是,返回 true ;否则,返回 false

示例:

输入:head = [1,2,2,1] ;输出:true

Solution1:
先通过快慢指针找到链表中点,然后反转后半部分,最后与前半部分进行比较.

LeetCode链表(链表操作,反转链表,奇偶链表,排序链表)_第8张图片

public boolean isPalindrome(ListNode head) {
        // 1.找到链表中点

        // 快慢指针,让慢指针指向链表中点
        ListNode slow = head, fast = head;
        // 注意这里的判断条件
        while(fast!=null && fast.next!=null)
        {
            slow = slow.next;
            fast = fast.next.next;
        }
        // 奇数个数的链表慢指针再移一步
        if(fast!=null)
        {
            slow = slow.next;
        }

        // 2.开始反转后半部分链表
        ListNode cur = slow, pre=null;
        while(cur!=null)
        {
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        // 3.进行比较
        while(pre!=null)
        {
            if(head.val!=pre.val)
                return false;
            head = head.next;
            pre = pre.next;
        }
        return true;
    }

参考链接:
https://leetcode.cn/leetbook/read/linked-list/fpr8s/

你可能感兴趣的:(LeetCode刷题,链表,leetcode,数据结构,反转链表)