【经典算法】LeetCode 148. 排序链表(Java/C/Python3实现含注释说明,中等)

于 2024-04-25 00:13:48 发布
阅读量984 收藏 15
点赞数 39
分类专栏： LeetCode 文章标签： 算法 leetcode 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84427485/article/details/138173230
版权

题目描述

  • 标签(题目类型)：链表、排序

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

示例 1：
在这里插入图片描述

输入：head = [4,2,1,3]
输出：[1,2,3,4]
示例 2：
在这里插入图片描述

输入：head = [-1,5,3,4,0]
输出：[-1,0,3,4,5]
示例 3：

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

提示：

链表中节点的数目在范围 [0, 5 * 104] 内
-105 <= Node.val <= 105

进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？

原题：148. 排序链表

思路及实现

方式一：归并排序（续）

C语言版本（续）

// 释放链表内存
void freeList(struct ListNode* head) {
    struct ListNode *cur = head;
    while (cur != NULL) {
        struct ListNode *temp = cur;
        cur = cur->next;
        free(temp);
    }
}

struct ListNode* sortList(struct ListNode* head) {
    // ... 省略之前的代码 ...
    
    // 释放dummy节点内存
    free(dummy);
    
    return result;
}

说明：

  • freeList 函数用于释放链表占用的内存。
  • 在 sortList 函数最后，释放了 dummy 节点占用的内存，并返回排序后的链表头节点 result。
Python3版本
# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def sortList(self, head: ListNode) -> ListNode:
        if not head or not head.next:
            return head
        
        # 使用快慢指针找到链表中间节点
        slow, fast = head, head
        while fast.next and fast.next.next:
            slow = slow.next
            fast = fast.next.next
        
        # 分割链表
        mid = slow.next
        slow.next = None
        
        # 递归对左右两部分链表排序
        left = self.sortList(head)
        right = self.sortList(mid)
        
        # 合并两个已排序链表
        return self.merge(left, right)
    
    def merge(self, l1: ListNode, l2: ListNode) -> ListNode:
        dummy = ListNode(0)
        cur = dummy
        
        while l1 and l2:
            if l1.val < l2.val:
                cur.next = l1
                l1 = l1.next
            else:
                cur.next = l2
                l2 = l2.next
            cur = cur.next
        
        # 处理剩余节点
        cur.next = l1 if l1 is not None else l2
        
        return dummy.next

说明：

  • Python版本的实现与Java版本类似，但语法有所不同。
  • Python中的链表节点定义使用了类，并且链表操作更为简洁。
Golang版本
package main

import "fmt"

type ListNode struct {
    Val  int
    Next *ListNode
}

func sortList(head *ListNode) *ListNode {
    if head == nil || head.Next == nil {
        return head
    }
    
    slow, fast := head, head
    for fast.Next != nil && fast.Next.Next != nil {
        slow = slow.Next
        fast = fast.Next.Next
    }
    
    mid := slow.Next
    slow.Next = nil
    
    left := sortList(head)
    right := sortList(mid)
    
    return merge(left, right)
}

func merge(l1, l2 *ListNode) *ListNode {
    dummy := &ListNode{}
    cur := dummy
    
    for l1 != nil && l2 != nil {
        if l1.Val < l2.Val {
            cur.Next = l1
            l1 = l1.Next
        } else {
            cur.Next = l2
            l2 = l2.Next
        }
        cur = cur.Next
    }
    
    cur.Next = l1
    if l1 == nil {
        cur.Next = l2
    }
    
    return dummy.Next
}

func main() {
    // 示例链表: 4 -> 2 -> 1 -> 3
    head := &ListNode{Val: 4}
    head.Next = &ListNode{Val: 2}
    head.Next.Next = &ListNode{Val: 1}
    head.Next.Next.Next = &ListNode{Val: 3}
    
    sortedHead := sort# 排序链表

* 标签(题目类型)：链表、排序

# 思路及实现

## 方式一：归并排序（续）

### C语言版本（续）

```c
// 释放链表内存
void freeList(struct ListNode* head) {
    struct ListNode *cur = head;
    while (cur != NULL) {
        struct ListNode *temp = cur;
        cur = cur->next;
        free(temp);
    }
}

struct ListNode* sortList(struct ListNode* head) {
    // ... 省略之前的代码 ...
    
    // 释放dummy节点内存
    free(dummy);
    
    return result;
}

说明：

  • freeList 函数用于释放链表占用的内存。
  • 在 sortList 函数最后，释放了 dummy 节点占用的内存，并返回排序后的链表头节点 result。
Python3版本
# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def sortList(self, head: ListNode) -> ListNode:
        if not head or not head.next:
            return head
        
        # 使用快慢指针找到链表中间节点
        slow, fast = head, head
        while fast.next and fast.next.next:
            slow = slow.next
            fast = fast.next.next
        
        # 分割链表
        mid = slow.next
        slow.next = None
        
        # 递归对左右两部分链表排序
        left = self.sortList(head)
        right = self.sortList(mid)
        
        # 合并两个已排序链表
        return self.merge(left, right)
    
    def merge(self, l1: ListNode, l2: ListNode) -> ListNode:
        dummy = ListNode(0)
        cur = dummy
        
        while l1 and l2:
            if l1.val < l2.val:
                cur.next = l1
                l1 = l1.next
            else:
                cur.next = l2
                l2 = l2.next
            cur = cur.next
        
        # 处理剩余节点
        cur.next = l1 if l1 is not None else l2
        
        return dummy.next

说明：

  • Python版本的实现与Java版本类似，但语法有所不同。
  • Python中的链表节点定义使用了类，并且链表操作更为简洁。
Golang版本
package main

import "fmt"

type ListNode struct {
    Val  int
    Next *ListNode
}

func sortList(head *ListNode) *ListNode {
    if head == nil || head.Next == nil {
        return head
    }
    
    slow, fast := head, head
    for fast.Next != nil && fast.Next.Next != nil {
        slow = slow.Next
        fast = fast.Next.Next
    }
    
    mid := slow.Next
    slow.Next = nil
    
    left := sortList(head)
    right := sortList(mid)
    
    return merge(left, right)
}

func merge(l1, l2 *ListNode) *ListNode {
    dummy := &ListNode{}
    cur := dummy
    
    for l1 != nil && l2 != nil {
        if l1.Val < l2.Val {
            cur.Next = l1
            l1 = l1.Next
        } else {
            cur.Next = l2
            l2 = l2.Next
        }
        cur = cur.Next
    }
    
    cur.Next = l1
    if l1 == nil {
        cur.Next = l2
    }
    
    return dummy.Next
}

func main() {
    // 示例链表: 4 -> 2 -> 1 -> 3
    head := &ListNode{Val: 4}
    head.Next = &ListNode{Val: 2}
    head.Next.Next = &ListNode{Val: 1}
    head.Next.Next.Next = &ListNode{Val: 3}
    
    sortedHead := List(head)
    
    // 打印排序后的链表
    current := sortedHead
    for current != nil {
        fmt.Print(current.Val, " ")
        current = current.Next
    }
}

说明：

  • Golang版本的实现也使用了归并排序的思想，并且遵循了与C语言和Python相似的结构。
  • sortList 函数对链表进行递归分割和排序，merge 函数合并两个已排序链表。
  • main 函数创建了一个示例链表，调用 sortList 函数进行排序，并打印排序后的结果。

方式二：插入排序

思路

除了归并排序外，也可以使用插入排序对链表进行排序。插入排序的基本思想是将链表视作一个数组，依次遍历链表节点，将每个节点插入到已排序部分的正确位置。

由于链表的插入操作涉及到修改节点的 next 指针，插入排序对于链表来说是一种可行的排序方法。但需要注意的是，插入排序在处理大规模数据时性能可能不如归并排序。

以下是使用插入排序对链表进行排序的示例代码（这里以Python为例）：

代码实现

Java版本

class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

public class Solution {
    public ListNode insertionSortList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        
        ListNode dummy = new ListNode(0); // 哑节点
        dummy.next = head;
        ListNode cur = head.next;
        
        while (cur != null) {
            if (cur.val < head.val) {
                // 如果当前节点值小于头节点值，则需要将其插入到哑节点之后
                ListNode temp = cur.next;
                cur.next = dummy.next;
                dummy.next = cur;
                cur = temp;
            } else {
                // 否则在已排序的链表中查找插入位置
                ListNode pre = head;
                while (pre.next != cur && pre.next.val < cur.val) {
                    pre = pre.next;
                }
                // 插入节点
                ListNode temp = cur.next;
                cur.next = pre.next;
                pre.next = cur;
                cur = temp;
            }
        }
        
        return dummy.next;
    }
}
C版本
#include <stdlib.h>

typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

ListNode* insertionSortList(ListNode* head) {
    if (!head || !head->next) {
        return head;
    }
    
    ListNode dummy = {0, head}; // 哑节点
    ListNode *cur = head->next;
    
    while (cur) {
        if (cur->val < head->val) {
            // 如果当前节点值小于头节点值，则需要将其插入到哑节点之后
            ListNode *temp = cur->next;
            cur->next = dummy.next;
            dummy.next = cur;
            cur = temp;
        } else {
            // 否则在已排序的链表中查找插入位置
            ListNode *pre = head;
            while (pre->next != cur && pre->next->val < cur->val) {
                pre = pre->next;
            }
            // 插入节点
            ListNode *temp = cur->next;
            cur->next = pre->next;
            pre->next = cur;
            cur = temp;
        }
    }
    
    return dummy.next;
}
Python3版本
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class Solution:
    def insertionSortList(self, head: ListNode) -> ListNode:
        # 创建一个哑节点作为已排序部分的起始点
        dummy = ListNode(0)
        cur = head
        
        while cur:
            # 创建一个临时节点来保存当前节点
            temp = cur
            cur = cur.next
            
            # 插入操作
            pre = dummy
            while pre.next and pre.next.val < temp.val:
                pre = pre.next
            
            temp.next = pre.next
            pre.next = temp
        
        return dummy.next

说明：

  • insertionSortList 函数实现了插入排序算法，其中 dummy 节点用于简化插入操作。
  • 遍历链表中的每个节点，依次将它们插入到已排序部分的正确位置。
  • 插入操作通过比较 temp 节点的值和已排序部分节点的值来找到插入点，并修改相应的 next 指针。
    当然可以，以下是使用Java、C和Go语言实现链表插入排序算法的示例代码：
Go版本
package main

import "fmt"

type ListNode struct {
    Val  int
    Next *ListNode
}

func insertionSortList(head *ListNode) *ListNode {
    if head == nil || head.Next == nil {
        return head
    }
    
    dummy := &ListNode{Val: 0, Next: head} // 哑节点
    cur := head.Next
    
    for cur != nil {
        if cur.Val < head.Val {
            // 如果当前节点值小于头节点值，则需要将其插入到哑节点之后
            nextNode := cur.Next
            cur.Next = dummy.Next
            dummy.Next = cur
            cur = nextNode
        } else {
            // 否则在已排序的链表中查找插入位置
            pre := head
            for pre.Next != cur && pre.Next.Val < cur.Val {
                pre = pre.Next
            }
            // 插入节点
            nextNode := cur.Next
            cur.Next = pre.Next
            pre.Next = cur
            cur = nextNode
        }
    }
    
    return dummy.Next
}

func main() {
    // 示例链表构建与排序
    // ...
    // 打印排序后的链表
    // ...
}

在以上三个版本的插入排序实现中，我们都使用了哑节点（dummy node）来简化插入操作。哑节点是一个特殊的节点，它的值不重要，主要用于作为已排序部分的起始点，这样我们可以避免处理边界情况，如当需要插入的节点是头节点时。

注意，这些插入排序的链表实现时间复杂度为O(n^2)，对于大规模数据来说可能不够高效。在实际应用中，如果链表

复杂度分析

  • 归并排序的时间复杂度为 O(n log n)，空间复杂度为 O(log n)（递归栈空间），其中 n 是链表长度。
  • 插入排序的时间复杂度为 O(n^2)，空间复杂度为 O(1)（不考虑递归栈空间）。

在实际应用中，如果链表长度很大，通常推荐使用归并排序。如果链表长度较小，或者对空间复杂度有严格要求，可以考虑使用插入排序。

总结

方式优点缺点时间复杂度空间复杂度
插入排序链表实现简单直观时间复杂度较高，为O(n^2)O(n^2)O(1)
归并排序链表时间复杂度较低，为O(n log n)需要额外空间进行递归或合并操作O(n log n)O(n) 或 O(log n)（原地归并）

注意：这里的空间复杂度是相对于链表本身大小n而言的。插入排序是原地排序，不需要额外空间（除了常数级别的空间），所以空间复杂度为O(1)。归并排序通常需要递归调用栈空间，或者额外的数组空间用于合并操作，因此空间复杂度为O(n)或O(log n)（如果采用原地归并技术）。

相似题目

相似题目难度链接
合并两个有序链表中等力扣：合并两个有序链表
删除链表的倒数第N个节点中等力扣：删除链表的倒数第N个节点
旋转链表中等力扣：旋转链表
链表中的节点每k个一组翻转困难力扣：链表中的节点每k个一组翻转

这些题目涵盖了链表操作的多个方面，从简单的合并、删除操作到复杂的翻转和排序算法，对于理解和掌握链表数据结构非常有帮助。通过解决这些题目，可以加深对链表操作的理解，并提升算法设计和实现的能力。

天天学长爱编程
关注
  • 39
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java排序链表
LX__dream的博客
05-28 2930
剑指offer 148.排序链表 解题思路: 由时间复杂度O(nlogn)知道我们可以使用归并排序 归并排序经常会出现在合并两个有序链表这样类似的题中 定义fast指针和slow指针, 利用fast和slow将链表从中点分为两个链表 ① 对应操作: slow = slow.next; fast = fast.next.next; 此时slow指针刚好停在链表的中点 ② 将链表从中间断开的操作: slow.next = null; ③ 此时左右两个断开的链表的第一个节点分别为head和tmp 对.
java-链表排序
qq_40603125的博客
04-28 595
/ 自定义一个链表// 直接将表一的头结点作为新链表的头结点，表一的尾节点指向表二的头结点= null) {// 对新链表进行排序//定义一个内部类E data;// 添加一个元素return;// 尾插法= null) {// 如果链表为空或者只有一个元素，直接返回//定义一个新的list 存放数据= null) {//对list进行排序return 0;});//将排序后的数据重新放入链表= null) {
链表排序算法java实现（链表的快速排序、插入排序、归并排序）
热门推荐
我的博客
10-02 1万+
难易程度：★★ 重要性：★★★ 链表的排序相对数组的排序更为复杂些，也是考察求职者是否真正理解了排序算法（而不是“死记硬背”） 链表的插入排序 public class LinkedInsertSort { static class ListNode { int val; ListNode next; Lis...
链表知识详解及java代码示例
m0_68871967的博客
05-23 967
这篇教学文章主要介绍了链表的基本原理和定义，以及如何使用 Java 实现链表。链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和指向下一个节点的指针。相比于数组，链表具有动态扩展和删除节点的优势，但是访问节点的效率较低。在文章中，我们还介绍了链表的几种常见操作，包括插入节点、删除节点、查找节点等。并且均给出java示例代码。
algorithm-learning:leetcode刷题（Java，Python）和算法书籍
03-18
《algorithm-learning: leetcode刷题（Java，Python）和算法书籍》这个压缩包文件主要包含的是关于算法学习的资源，特别是针对LeetCode平台上的题目进行的编程实践，涉及的编程语言主要是Java和Python。LeetCode是一...
python-leetcode面试题解之第25题K个一组翻转链表-python题解.zip
03-12
在Python编程领域，LeetCode是一个非常重要的在线平台，它提供了大量的编程题目，旨在帮助程序员提升算法能力和准备求职面试。本话题聚焦于LeetCode面试题中的第25题——"K个一组翻转链表"。这是一道典型的链表操作...
leetcode题库-LeetCode_Python:LeetCode算法题Python实现
06-29
而 `LeetCode_Python` 则是这个庞大题库的一个Python实现版本，为Python爱好者提供了一个学习和实践算法的好机会。 Python，作为一种简洁易读、功能强大的编程语言，被广泛应用于各种领域，包括数据分析、Web开发、...
Python & JAVA Solutions for Leetcode.zip
02-28
JAVA Solutions for LeetCode.zip"包含了针对LeetCode题目的Python与JAVA解题方案，是学习和实践算法的好资料。以下将对这两个编程语言在LeetCode中的应用进行详细阐述。 首先，Python以其简洁易读的语法深受...
LeetCode-solution15.zip_idea leetcode_leetcode_leetcode python
09-20
通过深入学习这个压缩包中的Python解题实例，我们可以掌握LeetCode上的解题流程，熟悉各种算法的Python实现，提升自己的编程和算法能力。同时，不断练习和挑战新题目，有助于巩固知识，提高解决实际问题的能力。无论...
Algorithm_Templates：Python3中的算法模板和leetcode示例，您也可以学习许多python技巧
01-30
补充说明它是用Python3编写的，但是很容易扩展到其他语言，例如Java和C ++ 。 只需替换python语法糖和高级技巧，也许不够简洁。 由于时间和能力的限制，这里仅介绍常见的数据结构和算法。 几乎适合面试，但不足以...
python-leetcode面试题解之第31题下一个排列-python题解.zip
03-12
只有一项：python_leetcode面试题解之第31题下一个排列_python题解，这应该是一个包含具体代码实现的文件，可能有详细的注释和解释，用于说明如何找到一个数组的下一个排列。在LeetCode的第31题中，通常要求找到一个...
leetcode卡-Leetcode-May-Monthly-Challenge-2020:https://leetcode.com/expl
07-06
在这个"Leetcode-May-Monthly-Challenge-2020-master"压缩包中，你可以找到所有五月挑战的题目源代码，这些代码可能是Python、Java、C++或其他编程语言实现的解决方案。通过研究这些代码，你可以学习不同的解题策略...
python-leetcode面试题解之第252题会议室.zip
最新发布
06-19
标题中的“python-leetcode面试题解之第252题会议室”表明这是一份关于Python编程语言在LeetCode平台上解题的资料，具体是针对面试题252号——会议室预订的问题。LeetCode是一个在线平台，它提供了各种编程题目，...
python-leetcode面试题解之第69题x的平方根.zip
04-11
在本压缩包中，我们关注的是一个Python编程与算法相关的学习资源，具体是LeetCode面试题的第69题——求解整数x的平方根。LeetCode是一个广受欢迎的在线平台，它提供了各种编程挑战，尤其是对于准备求职面试的程序员...
链表排序(Java)
freeline的博客
07-21 1853
这是自己的第一篇博客，话说学习是50%的学习，另外50%是解释，以后会分享自己遇到的一些问题，欢迎各位大佬指教。 第一篇 对象数组排序的问题处理。 ..
Java数据结构中链表分割及链表排序使用快速排序、归并排序、集合排序、迭代、递归，刷题的重点总结
xyk：的博客
02-20 2012
Java数据结构中链表分割及链表排序使用快速排序、归并排序、集合排序、迭代、递归，刷题的重点总结
Java-排序链表问题
m0_63593758的博客
02-25 946
（3）递归分割时，输入当前链表左端点head和中心结点slow的下一个结点tmp（因为链表是从slow切断的）。1.分割cut环节：找到当前链表中点，并从中点将链表断开（以便在下次递归cut时，链表片段拥有正确的边界）；（1）我们使用fast,slow快慢双指针法，奇数个结点找到中点，偶数个结点找到中心左边的结点。给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表。（2）找到结点slow后，执行slow.next=None将链表切断。(4)cut 递归终止条件：当head.next。
Java 对链表进行插入排序
weixin_53545457的博客
01-15 429
对链表进行插入排序中等给定单个链表的头head，使用插入排序对链表进行排序，并返回排序后链表的头。插入排序算法的步骤:插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。重复直到所有输入数据插入完为止。下面是插入排序算法的一个图形示例。部分排序的列表(黑色)最初只包含列表中的第一个元素。每次迭代时，从输入数据中删除一个元素(红色)，并就地插入已排序的列表中。
几种链表排序算法的JAVA实现
weixin_43872339的博客
12-28 2628
插入排序 首先解释一下一个概念叫做：前继节点，即我们要的节点的前一个节点。我当时写这个算法的时候一直在犹豫的一点在于我怎么保存下个节点的状态，因为在单向链表中的必须要保存下个节点的状态才能对当前节点进行操作，而另外一点是我应该怎么样利用当前的值和前一个值比较。这是我在做这个题的时候最大的麻烦。参考别人的思路。 插入排序的主要的思想在于： 利用一个前继节点的概念去寻找当前值比前一个值大的节点...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值