单链表排序--归并排序

#include <iostream>
#include <cstdlib>
using namespace std;
struct ListNode //默认为public
{
    int data;
    ListNode* next;
    ListNode(int x, ListNode* nextNode):data(x), next(nextNode){}
};

ListNode* mergeData(ListNode* first, ListNode* second)
{
    if(first == nullptr) return second;
    if(second == nullptr) return first;
    //合并两个链表,按从小到大的顺序
    ListNode* new_head = new (nothrow) ListNode(0, nullptr); //分配失败返回空指针
    if(new_head == nullptr) exit(0);
    ListNode* ptr = new_head;
    while(first != nullptr && second != nullptr)
    {
        if(first->data < second->data)
        {
            ptr->next = first;
            first = first->next;
        }
        else
        {
            ptr->next = second;
            second = second->next;
        }
        ptr = ptr->next;
    }
    //合并剩余部分(对于数组进行归并排序,这部分可通过设置哨兵来省略)
    if(first != nullptr) ptr->next = first;
    if(second != nullptr) ptr->next = second;
    return new_head->next;
}

//返回为结点指针类型,需要链表头节点
ListNode* mergeSort(ListNode* head)
{
    //递归调用,首先找到分裂点,对于链表可以使用快慢指针方法
    if(head == nullptr || head->next == nullptr) return head;
    ListNode* fast = head->next;
    ListNode* slow = head;
    while(fast != nullptr && fast->next != nullptr)
    {
        slow = slow->next;
        fast = fast->next->next;
    }
    //此时slow即为中间点,依次对slow之前的元素和之后的元素递归调用归并排序,然后进行合并
    ListNode* se = slow->next;
    slow->next = nullptr;
    ListNode* first = mergeSort(head);
    ListNode* second = mergeSort(se);
    return mergeData(first, second);
}

void printList(ListNode* head)
{
    if(head == nullptr) return;
    cout << head->data << " ";
    printList(head->next);
}

int main()
{
    ListNode* head =
        new ListNode(10, new ListNode(9, new ListNode(8, new ListNode(7, new ListNode(6, new ListNode(5, nullptr))))));
    printList(head);
    cout << endl;
    ListNode* new_head = mergeSort(head);
    printList(new_head);
    return 0;
}

  

时间: 2024-10-26 23:51:13

单链表排序--归并排序的相关文章

【LeetCode】 sort list 单链表的归并排序

题目:Sort a linked list in O(n log n) time using constant space complexity. 思路:要求时间复杂度O(nlogn) 知识点:归并排序,链表找到中点的方法 存在的缺点:边界条件多考虑!!! /** * LeetCode Sort List Sort a linked list in O(n log n) time using constant space complexity. * 题目:将一个单链表进行排序,时间复杂度要求为o

148. Sort List (java 给单链表排序)

题目:Sort a linked list in O(n log n) time using constant space complexity. 分析:给单链表排序,要求时间复杂度是O(nlogn),空间复杂度是O(1).时间复杂度为O(nlogn)的排序算法有快速排序和归并排序, 但是,对于单链表来说,进行元素之间的交换比较复杂,但是连接两个有序链表相对简单,因此这里采用归并排序的思路. 编码: public ListNode sortList(ListNode head) { if(hea

单链表排序(插入与归并)

struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; /* * 单链表的插入排序, 插入排序是一种稳定排序 */ class Solution7 { public: ListNode* insertionSortList(ListNode* head) { if(head == NULL || head->next == NULL) return head; ListNode *

笔试,面试,C/C++,数据结构单链表排序(改进冒泡排序)

void BubbleSortNode(SListNode *&pHead)//单链表排序 {  assert(pHead);  SListNode *tail = NULL;  int Bool = 0;  //若没有进行交换提前返回  while (tail!=pHead->next)  {   Bool = 0;   SListNode *tmp = pHead;   SListNode *tmpnext = tmp->next;   while (tmp->next !=

将单链表排序的两种方法

对单链表排序,通常有两种方法.(PS:考察一个程序员的C语言编程功底,通常看他是否能娴熟的操作链表就知道了.) 方法1:将每一个结点保存到额外的数组中,对数组进行排序,然后根据有序的数组重新构建链表. 方法2:直接对链表进行插入排序,但是实现起来比较复杂一些. 显然,方法1最为简单,因为将链式存储L先转化为顺序存储a[],对顺序存储a[]排序,就避免了较为复杂的链接指针操作.一旦对顺序存储a[]排好序后,根据a[]重新构建一个链表是易如反掌的事情. 1. 单链表的定义如下 typedef str

12.单链表排序

12.单链表排序 思路: 参见基本函数13://冒泡排序链表,具体的做法是“狸猫换太子”,即只交换节点中的值,对链表结构不做改动. void sortList(Node*& Head); //链表排序 //排序的方法是不破坏结构,有“狸猫换太子”的意思,只进行value的交换,不破坏链表结构 void sortList(Node*& Head) {   int count=numOfNodes(Head);   if(count==0||count==1)   {    return ;

单链表的归并排序

#include<iostream> #include<time.h> using namespace std; //链表的归并排序 struct listnode{ int value; listnode* next; listnode(int value):value(value),next(NULL){} }; listnode* find_mid(listnode* head){ if(head==NULL)return NULL; listnode* fast=head;

奇数结点升序偶数结点降序的单链表排序(Python实现)

题目 一个链表,奇数结点升序,偶数结点降序,要求变成一个全升序的链表. 例如:1->8->2->7->3->6->4->5,变为1->2->3->4->5->6->7->8 解析 按照以下步骤处理: 按照奇偶位拆分为两个链表 反转偶数结点构成的链表 合并两个递增链表 Python实现 # -*- coding:utf-8 -*- class Node(object): def __init__(self, val=None

单链表排序——快速排序实现

利用快速排序,同向一前一后两个指针 #ifndef LIST_H_ #define LIST_H_ #include <iostream> #include <utility> class List { private: struct ListNode { int _value; ListNode* _next; }; public: List(): _head(nullptr) {} ~List() { while (nullptr != _head) { auto tmp =