LeetCode：链表总结

已于 2022-09-01 17:36:39 修改
阅读量518 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 leetcode
于 2022-01-03 19:45:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sfklyqh/article/details/122290320
版权

反转链表

1.1 从前往后遍历

public ListNode reverseList(ListNode head) {
    ListNode cur = head;
    ListNode next = null;
    ListNode pre = null;
    while(cur!=null){
        //cur不为空才求它的next
        next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
    //返回时候cur为null，表头为pre
    return pre;
}

1.2 递归

public ListNode reverseList(ListNode head) {
    if(head==null||head.next==null)
        return head;
    //保存新的头节点
    ListNode newHead = reverseList(head.next);
    //后面的节点的next等于当前的节点
    head.next.next = head;
    //当前节点的next等于null，和上一步的这两步的操作并没有影响前一个节点的next指向当前head
    head.next = null;
    return newHead;
}

1.3 从尾到头输出链表

剑指offer06：输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
        ListNode newhead = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return newhead;
    }
}

1.3 两两交换节点

public ListNode swapPairs(ListNode head) {
    if(head==null||head.next==null)
        return head;
    //保存后面的结果
    ListNode back = swapPairs(head.next.next);
    //交换当前这两个
    ListNode next = head.next;
    head.next = back;
    next.next =head;
    //返回新的头
    return next;
}

1.3 K个一组反转链表

递归方法：和上一题类似

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode tail = head;
        int count = k-1;
        while(count>0&&tail!=null){
            tail = tail.next;
            count--;
        }
        //找到第K个元素，不足K个返回头节点，不用翻转
        if(tail==null)
            return head;
        //下一组的开头
        ListNode back = tail.next;
        //递归反转后面
        ListNode backhead = reverseKGroup(back,k);
        //当前这K个元素一组进行翻转，从head到tail，断开tail后面
        tail.next = null;
        ListNode newhead = reverse(head);
        //head成为了尾巴
        head.next = backhead;
        return newhead;

    }


    public ListNode reverse(ListNode head){
        if(head==null||head.next==null)
            return head;
        ListNode back = head.next;
        ListNode newhead = reverse(back);
        back.next = head;
        head.next = null;
        return newhead;
    }
}

遍历方法： 

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode pre = dummy;
        ListNode tail = dummy;
        int count = 0;
        while(true){
            count =0;
            //找到第k个节点，作为结尾
            while(tail!=null&&count<k){
                tail=tail.next;
                count++;
            }
            if(tail==null)
                break;
            //这一轮反转后，变成结尾的节点，本来是第一个 将要成为最后一个，也就是下一轮的开头前一个
            ListNode nexthead = pre.next;
            //尾巴还没成为第一个的时候
            while (pre.next != tail) {
                //要插入到尾巴的节点
                ListNode cur = pre.next;
                pre.next = pre.next.next;
                cur.next = tail.next;
                tail.next = cur;

            }
            //结尾成为下一轮的开始
            pre = nexthead;
            tail = nexthead;        
        }
        return dummy.next;
    }
}

奇偶链表

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

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

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

public ListNode oddEvenList(ListNode head) {
    if(head==null||head.next==null)
        return head;
    ListNode oddhead = head;
    ListNode evenhead = head.next;
    ListNode oddcur = head;
    ListNode evencur = evenhead;
    //这个条件使evencur一定能跳到下一个偶数节点
    //evencur一直到倒数一个非空或者空才停止（由链表总个奇偶决定），因为这个条件
    while(evencur!=null&&evencur.next!=null){
        //奇数的next等于偶数的next
        oddcur.next=evencur.next;
        //奇数的遍历节点往下跳，跳到下一个奇数
        oddcur = oddcur.next;
        //偶数的next等于奇数的next
        evencur.next =oddcur.next;
        evencur = evencur.next;
    }
    //偶数节点的最后一个都是null，奇数不是
    oddcur.next = evenhead;
    return oddhead;

}

链表中间节点

    public ListNode findMid(ListNode l1){
        ListNode dummy = new ListNode();
        dummy.next = l1;
        ListNode fast=dummy,slow =dummy;
        while(fast!=null&&fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
        }
        //如果是奇数个，找的是中间节点，如果是偶数个，找的是前半部分的最后一个节点
        return slow;
    }

合并有序链表

4.1 合并两个有序链表

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    ListNode dummy = new ListNode();
    ListNode cur = dummy;
    while(l1!=null&&l2!=null){
        if(l1.val<l2.val){
            cur.next =l1;
            l1=l1.next;
        }
        else{
            cur.next = l2;
            l2=l2.next;
        }
        cur = cur.next;
    }
    cur.next = l1==null?l2:l1;
    return dummy.next;
}

4.2 合并K个有序链表

先划分，再合并

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        return merge(lists,0,lists.length-1);
    }
    //归并
    public ListNode merge(ListNode[] lists,int low ,int high){
        if(low==high)
            return lists[low];
        if(low>high)
            return null;
        int mid = (low+high)/2;
        //再划分左右两部分
        ListNode left = merge(lists,low,mid);
        ListNode right = merge(lists,mid+1,high);
        //合并左右两部分
        return mergeTwoList(left,right);
    }

    //合并两个链表
    public ListNode mergeTwoList(ListNode head1,ListNode head2){
        ListNode dummy = new ListNode();
        ListNode cur = dummy;
        while(head1!=null&&head2!=null){
            if(head1.val<head2.val){
                cur.next =head1;
                head1 = head1.next;
            }             
            else{
                cur.next = head2;
                head2 = head2.next;
            }
            cur = cur.next;
        }
        cur.next = head1==null?head2:head1;
        return dummy.next;
    }

}

删除链表重复元素

5.1 保留

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

5.2 不保留

public ListNode deleteDuplicates(ListNode head) {
    if(head==null||head.next==null)
        return head;
    ListNode dummy = new ListNode();
    dummy.next = head;
    ListNode pre =dummy,cur=head,next = head;
    while(cur!=null){
        next = cur.next;
        if(next!=null&&cur.val==next.val){
            while(next!=null&&cur.val==next.val){
                next=next.next;
            }
            pre.next = next;
        }else{
            pre=pre.next;
        }
        cur = next;
    }
    return dummy.next;
}

链表排序

6.1 升序排序

148：升序排序链表，找中点+归并

class Solution {
    public ListNode sortList(ListNode head) {
        if(head==null||head.next==null)
            return head;
        ListNode midnode = findMid(head);
        ListNode right = midnode.next;
        midnode.next=null;
        //先划分完左右，再合并
        return merge(sortList(head),sortList(right));
    }
    public ListNode findMid(ListNode l1){
        ListNode dummy = new ListNode();
        dummy.next = l1;
        ListNode fast=dummy,slow =dummy;
        while(fast!=null&&fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
    public ListNode merge(ListNode l1,ListNode l2){
        ListNode dummy= new ListNode();
        ListNode cur =dummy;
        while(l1!=null&&l2!=null){
            if(l1.val<l2.val){
                cur.next = l1;
                l1=l1.next;
            }else{
                cur.next = l2;
                l2 = l2.next;
            }
            cur = cur.next;
        }
        cur.next = l1==null?l2:l1;
        return dummy.next;
    }
}

6.2 重排序链表

143：重排序链表，后半部分链表倒序之后，间隔插入到前半部

给定一个单链表 L 的头节点 head

单链表 L 表示为： L0 → L1 → … → Ln - 1 → Ln

请将其重新排列后变为： L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …

class Solution {
    public void reorderList(ListNode head) {
        ListNode mid = findMidNode(head);
        ListNode right = mid.next;
        mid.next = null;
        right = reverse(right);
        ListNode p = head;
        ListNode q = right;
        while(q!=null){
            ListNode next = q.next;
            q.next = p.next;
            p.next = q;
            p = p.next.next;
            q = next;
        }
        return ;
    }
    public ListNode findMidNode(ListNode head){
        ListNode dummy = new ListNode();
        dummy.next = head;
        ListNode fast = dummy;
        ListNode slow = dummy;
        while(fast!=null&&fast.next!=null){
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
    public ListNode reverse(ListNode head){
        if(head==null||head.next==null)
            return head;
        ListNode pre = null;
        ListNode cur = head;
        ListNode next = cur.next;
        while(cur!=null){
            next = cur.next;
            cur.next = pre;
            pre = cur;
            cur =next;
        }
        return pre;
    }
}

6.3 排序奇升偶降链表

给定一个奇数位升序，偶数位降序的链表，将其重新排序。

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

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

public class LinkedListTest {
    //返回分隔开的奇偶
    public ListNode[] oddEvenList(ListNode head){
        ListNode oddhead = head;
        ListNode evenhead = head.next;
        ListNode oddcur = oddhead;
        ListNode evencur = evenhead;
        //保证奇数有下一个，并且偶数有下一个,保证了偶数链表最后一定是null，但奇数就不一定的
        while(evencur!=null&&evencur.next!=null){
            oddcur.next = evencur.next;
            oddcur = oddcur.next;
            evencur.next = oddcur.next;
            evencur =evencur.next;
        }
        //注意断开奇数的结尾，否则形成环
        oddcur.next = null;
        return new ListNode[]{oddhead,evenhead};
    }
    //反转偶数部分
    public ListNode reverse(ListNode head){
        if(head.next==null)
            return head;
        ListNode next = head.next;
        ListNode newhead = reverse(next);
        next.next=head;
        head.next =null;
        return newhead;
    }
    //合并奇偶
    public ListNode mergeList(ListNode l1,ListNode l2){
        ListNode dummy = new ListNode();
        ListNode cur =dummy;
        while(l1!=null&&l2!=null){
            if(l1.val<=l2.val){
                cur.next =l1;
                l1 =l1.next;
            }else {
                cur.next =l2;
                l2 =l2.next;
            }
            cur = cur.next;
        }
        cur.next = l1==null?l2:l1;
        return dummy.next;
    }

    public ListNode sortOddEvenList(ListNode head){
        if(head==null||head.next==null)
            return head;
        ListNode[] oddeven = oddEvenList(head);
        ListNode oddhead =oddeven[0];
        ListNode evenhead = oddeven[1];
        evenhead = reverse(evenhead);
        return mergeList(oddhead, evenhead);
    }
}

回文链表

先存入数组，在判断是否回文

public boolean isPalindrome(ListNode head) {
    ArrayList<Integer> result = new ArrayList<>();
    while(head!=null){
        result.add(head.val);
        head = head.next;
    }
    int length = result.size();
    for(int i=0;i<length/2;i++){
        if(result.get(i)!=result.get(length-1-i))
            return false;
    }
    return true;
}

复制带随即指针的链表

构建源节点和新节点的哈希映射

class Solution {
    public Node copyRandomList(Node head) {
        HashMap<Node,Node> map = new HashMap<>();
        Node dummy = new Node(0);
        Node newcur = dummy;
        Node oldcur = head;
        while(oldcur!=null){
            int val = oldcur.val;
            newcur.next = new Node(val);
            map.put(oldcur,newcur.next);
            oldcur=oldcur.next;
            newcur =newcur.next;
        }
        oldcur = head;
        newcur = dummy.next;
        while(oldcur!=null){
            //当前节点的随机指针
            Node random = map.get(oldcur.random);
            if(random!=null){
                newcur.random = random;
            }
            oldcur = oldcur.next;
            newcur = newcur.next;
        }
        return dummy.next;
    }
}

丁真的小马
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
leecode328. 奇偶链表
liuhongtaowxp1的博客
05-25 280
给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。 第一个节点的索引被认为是 奇数 ， 第二个节点的索引为 偶数 ，以此类推。 请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。 你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。 示例 1: 输入: head = [1,2,3,4,5] 输出:[1,3,5,2,4] 示例 2: 输入: head = [2,1,3,5,6,4,7] 输出: [.
LeetCode--148. 排序链表（C++描述）
最新发布
YGQ_qq_1435471912
10-27 660
题目分析 : 首先套用给整数数组归并排序的模板，首先使用快慢指针找到链表中间节点，然后将链表断开，递归下去；划分到单个节点后，开始进行回退合并链表，通过设置伪头节点便于处理，最后返回.给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表。链表中节点的数目在范围 [0, 5 * 104] 内。输入：head = [-1,5,3,4,0]输入：head = [4,2,1,3]输出：[-1,0,3,4,5]输出：[1,2,3,4]输入：head = []
LeetCode排序链表C++解法（详解）
莫浅子的博客
09-19 404
这里面自己写的时候有个bug，就是 q->val =*it 和 q = q->next 的位置调换，倒置会出现q在最后指向的时候出现指向为空的情况。我以为链表的头结点不存值，所以没有先让头结点next了一下。这里面通过遍历链表，将所有值放到这个数组里面。3）在通过遍历将数组里面的值依次放到链表中。1）取出链表里面的元素放到数组里面。2）利用sort函数讲其排序。
【刷题】NC207 排序奇升偶降链表
Badme
08-24 191
【刷题】NC207 排序奇升偶降链表
奇数位升序偶数位降序的链表进行排序
qq_29494693的博客
03-07 1404
题目描述：一个链表，特点是奇数位升序偶数位降序，使得链表变成升序的。分析代码节点类:main方法:初始化方法：按照奇偶位拆分成两个链表:反转链表:合并两个有序链表(非递归)：合并两个有序链表(递归)： 分析 这道题可以分成三步： 首先根据奇数位和偶数位拆分成两个链表。 然后对偶数链表进行反转。 最后将两个有序链表进行合并（合并两种实现方式一种是递归另外一种是非递归）。 代码 节点类: class Node { int value; Node next; Node(int
leetcode：移除链表元素 python解法
12-21
在LeetCode上，有一道经典的链表操作问题——移除链表元素。这个问题要求我们从给定的单链表中删除所有值等于`val`的节点。本文将深入解析问题的解决方案，并提供一种使用Python实现的方法。 ### 1. 题目说明 题目...
Leetcode:LeetCode 刷题总结
05-11
LeetCode 是一个在线平台，它提供了大量的编程挑战和面试问题，旨在帮助程序员提升技能并准备技术面试。这个压缩包文件 "Leetcode-master" 很可能是包含了一位开发者在LeetCode上练习时整理的代码和解决方案，主要...
leetcode:leetcode刷题记录与总结
04-11
2. 链表：链表的插入、删除操作在LeetCode中常见，如两数之和、判断环等题目。 3. 栈和队列：栈的后进先出（LIFO）特性在回溯算法和括号匹配问题中常用；队列的先进先出（FIFO）则常见于广度优先搜索。 4. 树：...
丢失的最小正整数leetcode-LeetCode:力码
06-30
丢失的最小正整数leetcode LeetCode leetcode 题目(共 65 题) 1 两数之和 2 两数相加 3 无重复字符的最长子串 4 寻找两个正序数组的中位数 7 整数反转 9 回文数 13 罗马数字转整数 14 最长公共前缀 15 三数之和 16 ...
leetcode分类-leetcode:leetcode分类刷题总结
06-30
这个“leetcode分类-leetcode:leetcode分类刷题总结”很显然是一个关于LeetCode刷题经验的总结，可能包含了不同类型的题目分类、解题策略以及常见问题的解析。下面我们将深入探讨LeetCode的分类及其对编程技能的重要...
CodeTop - 排序奇升偶降链表
qq_42250642的博客
05-26 373
CodeTop - 排序奇升偶降链表 题目 代码 #include <iostream> #include <vector> using namespace std; /* 给定一个奇数位升序，偶数位降序的链表，将其重新排序（升序） 例：1->8->3->6->5->4->7->2->NULL 1->2->3->4->5->6->7->8->NULL 解法： 1）首先安装奇偶
字节跳动高频面试题之排序奇升偶降链表
codebloom的博客
06-04 333
对于这篇文章，添加了下我的做法 链接 问题描述： [1] 链表，奇数位置按序增长，偶数位置按序递减，如何能实现链表从小到大？（2020.10 字节跳动-后端） [2] 奇偶生序倒序链表的重新排序组合，例如：18365472（2020.08 字节跳动-后端） [3] 1->4->3->2->5 给定一个链表奇数部分递增，偶数部分递减，要求在O(n)时间复杂度内将链表变成递增，5分钟左右（2020.07 字节跳动-测试开发） [4] 奇数位升序偶数位降序的链表要求时间O(n)空间O(1)
字节高频题补充 排序奇升偶降链表
weixin_39248750的博客
03-10 415
题目：给定一个奇数位升序，偶数位降序的链表，将其重新排序。 输入: 1->8->3->6->5->4->7->2->NULL 输出: 1->2->3->4->5->6->7->8->NULL 思路： 首先，将链表拆分成两个，一个偶数降序链表，一个奇数升序链表。 其次，将降序的偶数链表逆序为升序。 最后，将两个链表合并。 三个步骤其实都有对应的题目。 public static ListNode
算法---补充题1. 排序奇升偶降链表
知北行的博客
06-21 373
1. 题目 题目参考: 字节跳动高频题——排序奇升偶降链表 给定一个奇数位升序，偶数位降序的链表，将其重新排序。 输入: 1->8->3->6->5->4->7->2->NULL 输出: 1->2->3->4->5->6->7->8->NULL 2. 题解 按照题意, 算法流程可分为三步 按奇偶位置拆分链表，得1->3->5->7->NULL和8->6->4->
单链表奇数升序偶数降序，将链表整体变成升序（C++实现）
qq_29485597的博客
07-25 1158
#include<iostream> using namespace std; //定义链表结构 struct linkList { int val; struct linkList* next; linkList(int x) :val(x), next(NULL){ } }; //链表合并排序 linkList* mergelist(linkList* ohead, linkList* jhead){ /*//定义头结点简单 linkList* new_head = new
面试题：有一个链表，奇数位升序偶数位降序，如何将链表变成升序
04-06 2044
一、概述 有一个链表，奇数位升序偶数位降序，如何将链表变成升序。 二、
用双向循环链表存储若干自然数。 比如： 链表中存储： 1 2 3 4 5 6 7 8 9…… 将其重排成： 1 3 5 7 9 ……8 6 4 2 （奇数升序偶数降序）
佳佳鸽的博客
02-18 2383
更多资料请点击：我的目录 本篇仅用于记录自己所学知识及应用，代码仍可优化，仅供参考，如果发现有错误的地方，尽管留言于我，谢谢! 运行结果： #include <stdio.h> #include <stdlib.h> struct node//设计节点 { int data; struct node *prev; struct node *next; }; st...
一个链表，奇数位升序偶数位降序，让链表变成升序的
jinyuehai的博客
10-18 718
题目描述：一个链表，奇数位升序偶数位降序，让链表变成升序的。 比如：1 8 3 6 5 4 7 2 9，最后输出1 2 3 4 5 6 7 8 9。 分析： 这道题可以分成三步： 首先根据奇数位和偶数位拆分成两个链表。 然后对偶数链表进行反转。 最后将两个有序链表进行合并。 ** * 输入: 1->8->3->6->5->4->7->2->NULL * 输出: 1->2->3->4->5->6->7->8->
奇数节点升序、偶数节点降序，得到整体升序的链表
haoranhaoshi的博客
06-15 255
奇数节点升序、偶数节点降序，得到整体升序的链表
算法面试通关：链表、队列、栈实战+LeetCode解题技巧
本文将聚焦于链表、队列、栈等数据结构，并通过实战题目LeetCode中的几个经典问题进行深入讲解和训练。 首先，链表是基础数据结构之一，例如LeetCode第141题环状链表。解决此问题有两种常见思路：一是使用哈希表...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值