链表排序

最新推荐文章于 2024-09-04 21:41:05 发布
最新推荐文章于 2024-09-04 21:41:05 发布
阅读量4.7k 收藏 20
点赞数 4
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39942341/article/details/110916879
版权

下面的排序只针对无头结点的单链表，当然有头节点稍微改改就可以了

选择排序

选择排序就是每次选一个最小的，放到前面

为了方便操作，创造一个头结点

/**
 * Definition of singly-linked-list:
 * class ListNode {
 * public:
 *     int val;
 *     ListNode *next;
 *     ListNode(int val) {
 *        this->val = val;
 *        this->next = NULL;
 *     }
 * }
 */
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        //空链表或者只有一个节点
        if(head==nullptr||head->next==nullptr)return head;
        ListNode* temp=new ListNode(0);
        temp->next=head;
        for(ListNode* r=temp;r->next->next!=nullptr;r=r->next){
            ListNode* p,*q;
            //p用来存储最小的节点的前驱
            for(p=r,q=r->next;q->next!=nullptr;q=q->next){
                if(q->next->val<p->next->val){
                    p=q;
                }
            }
            q=p->next;//指向最小
            p->next=q->next;//断链
            
            //拼接
            q->next=r->next;
            r->next=q;
        }
        head=temp->next;
        delete temp;
        return head;
    }
};

插入排序

也创建一个头结点方便操作

插入排序由于链表不能往前迭代，所以只能在有序的部分遍历，找插入位置

所以这个不是真正意义上的插入排序

/**
 * Definition of singly-linked-list:
 * class ListNode {
 * public:
 *     int val;
 *     ListNode *next;
 *     ListNode(int val) {
 *        this->val = val;
 *        this->next = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param head: The first node of linked list.
     * @return: The head of linked list.
     */
    ListNode * insertionSortList(ListNode * head) {
        // write your code here
        //空链表或者只有一个节点
        if(head==nullptr||head->next==nullptr)return head;
        ListNode* temp=new ListNode(1);
        temp->next=head;
        //temp的链表现在是有序的那部分
        ListNode* p=head->next,*q,*r;
        head->next=nullptr;
        while(p){
            q=temp;
            //找插入位置
            while(q->next&&q->next->val<=p->val){
                q=q->next;
            }
            r=p->next;
            p->next=q->next;
            q->next=p;
            p=r;
        }
        return temp->next;
    }
};

快速排序

由于不能往前迭代，所以只能换种方法

p指向小于哨兵的最后一个，q是用来迭代的，如果q当前的值小于哨兵，就把他和p后面的交换，大概感觉就是下面这张图

 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    void helper(ListNode* head,ListNode* tail){
        if(head==tail||head->next==tail)return;
        int val=head->val;
        ListNode* p=head;
        for(ListNode* q=head->next;q!=tail;q=q->next){
            if(q->val<val){
                p=p->next;
                if(p!=q){
                    swap(p->val,q->val);
                }
            }
        }
        swap(head->val,p->val);
        helper(head,p);
        helper(p->next,tail);
    }
    ListNode* sortList(ListNode* head) {
        if(head==nullptr||head->next==nullptr)return head;
        helper(head,nullptr);
        return head;
    }
};

归并排序

在链表排序中，归并应该算最快的

用快慢指针找中间，然后左边归并，右边归并，然后合并，都是基本操作

唯一要注意的是如果是空链表或者是只有一个节点，要直接返回，不然会死循环

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* merge(ListNode* p,ListNode* q){
        if(q==nullptr)return p;
        else if(p==nullptr)return q;
        ListNode* r,*tail=nullptr;
        while(p!=nullptr&&q!=nullptr){
            if(p->val<=q->val){
                if(tail!=nullptr){
                    tail->next=p;
                    tail=p;
                }
                else{
                    r=tail=p;
                }
                p=p->next;
            }
            else{
                if(tail!=nullptr){
                    tail->next=q;
                    tail=q;
                }
                else{
                    r=tail=q;
                }
                q=q->next;
            }
        }
        if(p==nullptr)p=q;
        tail->next=p;
        return r;
    }
    ListNode* sortList(ListNode* head) {
        if(head==nullptr||head->next==nullptr)return head;
        ListNode* slow=head,*fast=head;
        while(fast->next!=nullptr&&fast->next->next!=nullptr){
            slow=slow->next;
            fast=fast->next->next;
        }
        fast=slow->next;
        slow->next=nullptr;
        head=sortList(head);
        fast=sortList(fast);
        return merge(head,fast);
    }
};

总结

效率上，归并应该是最快的

在leetcode上，只有归并能过

https://leetcode.com/problems/sort-list/submissions/

下面这个是lintcode链表插入排序，用插入和选择都能过

https://www.lintcode.com/problem/insertion-sort-list/

下面这个是lintcode链表排序，快排和归并能过，目测选择和插入过不了

https://www.lintcode.com/problem/sort-list/description

下面这个是牛客网，虽然说是选择排序，但是只有归并能过

https://www.nowcoder.com/practice/f23604257af94d939848729b1a5cda08?tpId=188&&tqId=36717&rp=1&ru=/activity/oj&qru=/ta/job-code-high-week/question-ranking

 

C++完整版

#include<iostream>
#include<random>
#include<vector>
#include<algorithm>
using namespace std;
/**
 * 链表节点
 */
template<typename T>
class Node{
public:
    T data;
    Node<T>* next;
    Node():next(nullptr){}
    explicit Node(const T& data):data(data),next(nullptr){}
};
/**
 * 无头结点单链表
 */
template<typename T>
class LinkedList{
private:
    Node<T>* head;//链表
    /**
     * 两个链表归并
     * @param p 链表1
     * @param q 链表2
     * @return 归并后的链表
     */
    static Node<T>* merge(Node<T>* p,Node<T>* q){
        if(nullptr == p){
            return q;
        }
        else if(nullptr == q){
            return p;
        }
        Node<T>* r;//合并后的链表
        Node<T>* tail= nullptr;//合并后的链表的最后一个节点
        while(p!=nullptr&&q!=nullptr){
            if(p->data<=q->data){
                if (tail != nullptr) {
                    tail->next = p;
                    tail = p;
                }
                else {
                    r = tail = p;
                }
                p=p->next;
            }
            else{
                if (tail != nullptr) {
                    tail->next = q;
                    tail = q;
                }
                else {
                    r = tail = q;
                }
                q=q->next;
            }
        }
        if(p==nullptr){
            p=q;
        }
        tail->next=p;
        return r;
    }
    /**
     * 归并排序
     * @param head 链表
     * @return 排序后的链表
     */
    static Node<T>* mergeSort(Node<T>* head){
        //空链表或者只有一个元素
        if(head==nullptr||head->next==nullptr){
            return head;
        }
        //快慢指针，找中间节点
        Node<T>* fast=head,*slow=head;
        while(fast->next!=nullptr&&fast->next->next!=nullptr){
            slow=slow->next;
            fast=fast->next->next;
        }
        //右半边
        Node<T>* right=slow->next;
        //断链
        slow->next=nullptr;
        head=mergeSort(head);
        right=mergeSort(right);
        //归并
        return merge(head,right);
    }
    /**
     * 快排辅助函数
     * @param head 链表
     * @param tail 链表最后一个节点的下一个
     */
    static void quickSortHelper(Node<T>* head,Node<T>* tail){
        //空链表或者只有一个元素
        if(head==tail||head->next==tail){
            return;
        }
        Node<T>* p=head;//小于哨兵的节点的最后一个
        int val=head->data;//哨兵
        for(Node<T>* q=head->next;q!=tail;q=q->next){
            if(q->data<val){
                p=p->next;
                if(p!=q){
                    swap(p->data,q->data);
                }
            }
        }
        swap(head->data,p->data);
        quickSortHelper(head,p);
        quickSortHelper(p->next,tail);
    }
    /**
     * 快排
     * @param head 链表
     * @return 排序后的链表
     */
    static Node<T>* quickSort(Node<T>* head){
        //空链表或者只有一个元素
        if(head==nullptr||head->next==nullptr)return head;
        quickSortHelper(head,nullptr);
        return head;
    }
public:
    LinkedList():head(nullptr){}
    /**
     * 销毁链表
     */
    void destroy(){
        while(head!=nullptr){
            Node<T>* p=head->next;
            delete head;
            head=p;
        }
        head=nullptr;
    }
    ~LinkedList(){
        destroy();
    }
    void init(const vector<T>& init_data){
        destroy();
        Node<T>* tail= nullptr;
        for(const T& c:init_data){
            if(tail!=nullptr){
                tail->next=new Node<T>(c);
                tail=tail->next;
            }
            else{
                head=tail=new Node<T>(c);
            }
        }
    }
    explicit LinkedList(const vector<T>& init_data){
        head= nullptr;
        init(init_data);
    }
    /**
     * 判断链表是否有序
     * @return true是|false否
     */
    bool isSorted()const{
        if(head==nullptr||head->next==nullptr)return true;
        T pre=head->data;
        for(Node<T>* p=head->next;p!=nullptr;p=p->next){
            if(p->data<pre)return false;
            pre=p->data;
        }
        return true;
    }
    /**
     * 选择排序
     */
    void selectSort(){
        if(head==nullptr||head->next==nullptr){
            return;
        }
        auto temp=new Node<T>();
        temp->next=head;
        for(Node<T>* r=temp;r->next->next!=nullptr;r=r->next){
            Node<T>* p,*q;
            for(p=r,q=r->next;q->next!=nullptr;q=q->next){
                if(q->next->data<p->next->data){
                    p=q;
                }
            }
            q=p->next;
            p->next=q->next;
            q->next=r->next;
            r->next=q;
        }
        head=temp->next;
        delete temp;
    }
    /**
     * 插入排序
     */
    void insertSort(){
        if(head==nullptr||head->next==nullptr){
            return;
        }
        auto* temp=new Node<T>();//创建一个头结点
        temp->next=head;
        Node<T>* p=head->next;
        head->next=nullptr;
        while(p!=nullptr){
            Node<T>* q=temp;
            T val=p->data;
            while(q->next!=nullptr&&q->next->data<=val){
                q=q->next;
            }
            Node<T>* r=p->next;
            p->next=q->next;
            q->next=p;
            p=r;
        }
        head=temp->next;
        delete temp;
    }
    /**
     * 归并排序
     */
    void mergeSort(){
        head=mergeSort(head);
    }
    /**
     * 快速排序
     */
    void quickSort(){
        head=quickSort(head);
    }
    /**
     * 将链表转成vector
     * @return 转换后的vector
     */
    vector<T> getElements()const{
        vector<T> result;
        for(Node<T>* p=head;p!=nullptr;p=p->next){
            result.push_back(p->data);
        }
        return result;
    }
    friend ostream& operator<<(ostream& out,const LinkedList<T>& linkedList) {
        if(linkedList.head==nullptr){
            return out;
        }
        bool flag=false;
        for(Node<T>* p=linkedList.head;p!=nullptr;p=p->next){
            if(flag){
                out<<' ';
            }
            else{
                flag=true;
            }
            out<<p->data;
        }
        return out;
    }
};
bool isSame(vector<int>& a,vector<int>& b){
    if(a.size()!=b.size())return false;
    for(int i=0,size=a.size();i<size;++i){
        if(a[i]!=b[i])return false;
    }
    return true;
}
int main(){
    const int N=1000;
    random_device rd;
    vector<int> v;
    for(int i=0;i<N;++i){
        v.push_back(rd());
    }
    vector<int> temp=v;
    sort(v.begin(),v.end());
    vector<int> p;
    LinkedList<int> linkedList;
    bool flag=false;

    linkedList.init(temp);
    linkedList.selectSort();
    p=linkedList.getElements();
    if(!isSame(v,p)){
        cout<<"selectSort wrong"<<endl;
        flag=true;
    }

    linkedList.init(temp);
    linkedList.insertSort();
    p=linkedList.getElements();
    if(!isSame(v,p)){
        cout<<"insertSort wrong"<<endl;
        flag=true;
    }

    linkedList.init(temp);
    linkedList.mergeSort();
    p=linkedList.getElements();
    if(!isSame(v,p)){
        cout<<"mergeSort wrong"<<endl;
        flag=true;
    }

    linkedList.init(temp);
    linkedList.quickSort();
    p=linkedList.getElements();
    if(!isSame(v,p)){
        cout<<"quickSort wrong"<<endl;
        flag=true;
    }
    if(flag){
        for(int& c:temp){
            cout<<c<<' ';
        }
        cout<<endl;
    }
    else{
        cout<<"SUCCESS"<<endl;
    }

    return 0;
}

 

Nightmare004
关注
专栏目录
单链表的排序
轩志
04-21 3095
链表的排序2015/4/17 星期五 下午 18:25:04 一、顺序表的排序对顺序表的排序其实就是对结构体中的关键字的排序。c语言版： 自定义结构体：typedef struct node { int age; int height; int width; }Node; 现在想根据其中的age排序，用c语言实现有两种： 1、自定义交换函数，然后用常用的交换排序的方法进行排
单向链表操作详解（二）[The End]
rerli的专栏
12-08 7629
/*接着讲（测试编译时，请把相应的函数及测试代码放到上一讲代码的相关地方）：排序（选择、插入、冒泡）插入（有序）*//*===============================================作者：rerli时间：2003-12-08目的：学习单向链表的创建、修改、删除、  插入（无序、有序）、输出、  排序（选择、插入、冒泡）、反序说明：编译没有任何
数据结构——单链表查询、逆序、排序
最新发布
xgshxjhs_的博客
09-04 721
4、插入排序（从未排序部分取出一个元素，插入到已排序部分的正确位置）
链表排序（冒泡、选择、插入、快排、归并、希尔、堆排序）
weixin_34315665的博客
04-15 775
这篇文章分析一下链表的各种排序方法。 以下排序算法的正确性都可以在LeetCode的链表排序这一题检测。本文用到的链表结构如下（排序算法都是传入链表头指针作为参数，返回排序后的头指针） struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; ...
数据结构--链表的排序详解
热门推荐
William
11-18 11万+
1、前言 前面两篇博客，我已经把线性表的两种基本的表示形式，做了一个基本的介绍和一些对比。但是，我突然发现在链表这里我缺少一个很重要的内容，那就是对我们的链表进行排序，其实，在连接两个链表的时候，就要求我们的那两个链表是有序的。2、链表排序—最简单、直接的方式（直接采用冒泡或者选择排序，而且不是交换结点，只交换数据域）//线性表的排序,采用冒泡排序,直接遍历链表 void Listsort(Nod
链表的排序
weixin_51476766的博客
09-11 1万+
148. 排序链表 你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。 进阶： 你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？ 示例 1： 输入：head = [4,2,1,3] 输出：[1,2,3,4] 示例 2： 输入：head = [-1,5,3,4,0] 输出：[-1,0,3,4,5] 示例 3： 输入：head = [] 输出：[] 链表排序的最佳方法：归并排序 1.找到中间节点 2.将中间节点断成左右两半，然后
用C语言实现链表排序.zip
05-05
在本项目中，我们讨论的是如何使用C语言来实现链表的排序，特别是采用选择排序算法进行排序。选择排序是一种简单直观的排序算法，它的基本思想是对待排序的序列进行多轮选择，每一轮选择出当前未排序部分的最小（或...
data_sort.rar_VC 链表_链表排序
09-24
本项目"**data_sort.rar_VC 链表_链表排序**"聚焦于如何在VC++中创建单链表，对链表进行基本操作，如输入、搜索、插入元素，并实现链表排序。以下是对这些知识点的详细解释： 1. **链表的概念**： 链表是一种线性...
lianbiao.rar_链表 排序
09-19
本资源“lianbiao.rar”似乎包含了关于链表排序的深入探讨，特别是通过不同的排序算法对链表进行操作并进行性能分析。让我们详细了解一下链表排序的相关知识。 首先，链表不同于数组，它不连续存储数据，而是通过...
链表排序北邮数据结构实验
11-13
链表排序北邮数据结构实验报告 链表排序是数据结构中的一种基本操作，旨在对链表中的元素进行排序。该实验报告旨在使用链表实现各种排序算法，并进行比较。 一、实验要求 实验要求使用链表实现以下五种排序...
C语言链表排序
10-08
链表排序是C语言编程中常见的一种数据结构操作，它涉及到链表的基本概念、操作以及排序算法的应用。链表不同于数组，它是一种动态的数据结构，元素可以在运行时添加或删除，而不必预先知道数据的总量。在本压缩包中...
链表排序——归并排序、快速排序
HerofH_的博客
01-19 1742
目录 1 归并排序 1.1 实现思路 1.2 代码实现 2 快速排序 2.1 实现思路 2.2 代码实现 1 归并排序 归并排序基本原理https://blog.csdn.net/qq_28114615/article/details/86345717 1.1 实现思路        与数组归并排序相同，主要分为以下三个步骤：       ①找到链表中点。最常用的方法是双指针...
对链表排序
pouloghost的专栏
09-02 3493
要开始找工作，又挨了顿骂，这事不爽，刷一个LeetCode开心一下。 对链表排序：https://oj.leetcode.com/problems/sort-list/ 看到链表排序，第一反应无外乎就是希尔排序、基数排序和桶排序。想了想最好写的是基数排序，源码如下： public class Main { public static void main(String[] ar
排序应用于链表
05-13 206
前面两篇主要扯了些排序的算法，这些算法写的过程中都是应用于数组实现的，那么如何应用于链表实现这些排序算法呢？ 先给出我对链表的结构体的定义以方便阅读算法代码： typedef struct node { struct node *next; int data; }CNode, *Linklist; ①冒泡排序 void bubblesort(L...
排序链表
zhaohong_bo的专栏
06-12 444
题目描述 在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。 示例 1: 输入: 4->2->1->3 输出: 1->2->3->4 示例 2: 输入: -1->5->3->4->0 输出: -1->0->3->4->5 解法 思路1，归并排序 public ListNode sortL...
Leetcode 147.对链表进行排序
kexinxin1的博客
12-29 355
对链表进行插入排序 对链表进行插入排序。 插入排序算法： 插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。 每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。 重复直到所有输入数据插入完为止。 示例 1： 输入: 4->2->1->3 输出: 1->2-...
链表排序算法实现
"这段代码实现了一个简单的链表排序程序，用于对用户输入的一组整数进行升序排列。程序首先创建一个链表，然后使用选择排序算法对链表进行排序，最后打印出排序后的结果。" 在给定的代码中，主要涉及了以下几个知识...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Nightmare004

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值