java单链表排序归并排序_单链表排序--归并排序

#include

#include

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;

}