链表排序

最新推荐文章于 2022-11-06 22:13:44 发布
最新推荐文章于 2022-11-06 22:13:44 发布
阅读量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
关注
  • 4
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
链表排序——归并排序、快速排序
HerofH_的博客
01-19 1671
目录 1 归并排序 1.1 实现思路 1.2 代码实现 2 快速排序 2.1 实现思路 2.2 代码实现 1 归并排序 归并排序基本原理https://blog.csdn.net/qq_28114615/article/details/86345717 1.1 实现思路        与数组归并排序相同，主要分为以下三个步骤：       ①找到链表中点。最常用的方法是双指针...
203. 移除链表元素 、707.设计链表
清榎的博客
03-08 130
203. 移除链表元素 题目描述：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 解答：对于非头节点和头节点分开进行考虑，头节点涉及到头指针的重新指向。删除时将上一节点指针指向此节点的下一个 即可。 代码实现： class Solution { public: ListNode* removeElements(ListNode* head, int val) { ListNode
哈希函数学习记录
weixin_51343665的博客
10-15 111
class MyHashSet { private: struct Node { int val; Node *next; Node(int val) : val(val), next(nullptr) {} }; public: /** Initialize your data structure here. */ MyHashSet() { bucket = vector<Node *>(key.
C++ 五大链表排序（冒泡、插入、选择、归并、快排）
weixin_44178960的博客
08-18 4942
C++ 五大链表排序（冒泡、插入、选择、归并、快排）
将单链表排序的两种方法
weixin_30701575的博客
04-26 1759
对单链表排序，通常有两种方法。（PS:考察一个程序员的C语言编程功底，通常看他是否能娴熟地操作链表就知道了。当然，实际C编程中我们并不需要去重新实现链表，无论是Linux还是Solaris, 都有双向循环链表的标准实现。） 方法1：将每一个结点的内存地址保存到额外的数组中(也就是将链式存储转化为顺序存储)，对数组进行排序，然后根据有序的数组重新构建链表。 方法2：直接对链表进行插...
lianbiao.rar_链表 排序
09-19
本资源“lianbiao.rar”似乎包含了关于链表排序的深入探讨，特别是通过不同的排序算法对链表进行操作并进行性能分析。让我们详细了解一下链表排序的相关知识。 首先，链表不同于数组，它不连续存储数据，而是通过...
C语言链表排序
10-08
链表排序是C语言编程中常见的一种数据结构操作，它涉及到链表的基本概念、操作以及排序算法的应用。链表不同于数组，它是一种动态的数据结构，元素可以在运行时添加或删除，而不必预先知道数据的总量。在本压缩包中...
用C语言实现链表排序.zip
05-05
在本项目中，我们讨论的是如何使用C语言来实现链表的排序，特别是采用选择排序算法进行排序。选择排序是一种简单直观的排序算法，它的基本思想是对待排序的序列进行多轮选择，每一轮选择出当前未排序部分的最小（或...
链表排序北邮数据结构实验
11-13
链表排序北邮数据结构实验报告 链表排序是数据结构中的一种基本操作，旨在对链表中的元素进行排序。该实验报告旨在使用链表实现各种排序算法，并进行比较。 一、实验要求 实验要求使用链表实现以下五种排序...
链表排序实现
11-10
//输入一个数列以0为结束标志，建立链式线性表，查找其中最大的数并输出删除释放节点，然后对剩余的进行排序，并输出释放节点。
data_sort.rar_VC 链表_链表排序
09-24
本项目"**data_sort.rar_VC 链表_链表排序**"聚焦于如何在VC++中创建单链表，对链表进行基本操作，如输入、搜索、插入元素，并实现链表排序。以下是对这些知识点的详细解释： 1. **链表的概念**： 链表是一种线性...
C语言链表排序操作
06-29
链表创建、排序操作
单向链表排序，排序完成后返回链表头
08-28
C/C++ 编写函数，通过输入单向链表的头指针，对链表的value进行排序，返回排序后单向链表的头指针
链表快速排序
01-06
能够将用户给定的值生成一个随机数组然后进行排序，递归实现
双链表实现链表排序，合并等操作
04-11
4. **链表排序**：可以使用归并排序（Merge Sort）算法对链表进行排序，它是一种分治策略，将链表分为两半，分别排序，然后合并。 ```cpp Node* mergeSort(Node* head) { if (head == nullptr || head->next == ...
链表各种排序
lbf12313579的博客
09-17 378
链表各种排序
链表怎么排序
m0_61196791的博客
11-06 1622
链表怎么排序
排序链表（递归）
小小书童的博客
05-26 2887
给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。 输入：head = [4,2,1,3] 输出：[1,2,3,4]
python 链表排序
最新发布
09-13
不过，希尔排序在链表排序中并不适合使用，而堆排序虽然可以用于链表排序，但不被建议使用。 具体实现链表排序的方法可以根据不同的排序算法进行选择。下面以归并排序为例，介绍一种Python实现链表排序的方法： 1. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Nightmare004

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

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

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

打赏作者

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

抵扣说明：

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

余额充值