链表的排序(归并排序+快慢指针)

链表的排序有很多方式,这里记录一下归并排序,关键点2个: 归并排序的过程和快慢指针法找中间结点,直接上代码。

class Solution {
public:
         ListNode* sortList(ListNode* head) {
                if (!head || !head->next) return head;
                ListNode* slow = head, * fast = head->next;
                while (fast && fast->next) {
                        slow = slow->next;
                        fast = fast->next->next;
                }
                ListNode* left = sortList(slow->next); // slow 为中间结点了
                slow->next = NULL;
                ListNode* right = sortList(head);
                return merge(left, right);
         }
         ListNode* merge(ListNode* left, ListNode* right) {
                ListNode* dummy = new ListNode(0);
                ListNode* p = dummy;
                while (left && right) {
                        if (left->val < right->val) {
                               p->next = left;
                               left = left->next;
                        }
                        else {
                               p->next = right;
                               right = right->next;
                        }
                        p = p->next;
                }
                if (left) p->next = left;
                if (right) p->next = right;
                return dummy->next;
         }
};

  

原文地址:https://www.cnblogs.com/E-Dreamer-Blogs/p/12642805.html

时间: 2024-10-09 00:57:41

链表的排序(归并排序+快慢指针)的相关文章

快慢指针原理--快速找到未知长度单链表的中间节点

package com.java.dataStruct; //节点类 public class Node<E> { E item; Node next; public Node(){ } public Node(E element){ this.item = element; } public Node(E element, Node next){ this.item = element; this.next = next; } } Node p1,r1; Node L1 = new Node

sort-list——链表、快慢指针找中间、归并排序

Sort a linked list in O(n log n) time using constant space complexity. 链表,快慢指针找中点,归并排序. 注意判断条件fast->next!=NULL&&fast->next->next!=NULL,若为fast!=NULL&&fast->next!=NULL则会出现内存溢出 1 /** 2 * Definition for singly-linked list. 3 * stru

单链表排序--归并排序

#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(fi

求单链表的中间节点,用快慢指针

? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 Node* findMid(Node* &head) {     if(head == NULL||head->next == NULL)         return head;          Node* p = head;     Node* q = head;     while(q->next->next&&(q = q->next))     {         p = p-

reorder-list——链表、快慢指针、逆转链表、链表合并

Given a singly linked list L: L0→L1→-→Ln-1→Ln,reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→- You must do this in-place without altering the nodes' values. For example,Given{1,2,3,4}, reorder it to{1,4,2,3}. 由于链表尾端不干净,导致fast->next!=NULL&&fast->next-&

单链表的排序 快速排序 归并排序 quicksort mergesort

原理都很简单,关键是某些边界能否正确写对: #include<iostream> #include<stdio.h> using namespace std; class Node { public: int val; Node* next; Node(int val = 0):val(val),next(NULL){ } }; Node* quicksort(Node* head, Node* tail) { Node *res1 = NULL, *res2 = NULL; No

快慢指针,怎样快速获取链表的中间元素

有一个链表,怎样快速获取中间节点的元素. 方法1 遍历一下链表,确认长度,获取中间的节点元素,时间复杂度O(N) 方法2 设置两个指针,一个遍历p->nexr  一个 p->next->next,快慢指针的思想  时间复杂度为O(n/2) 代码: 1 //腾讯面试题,获取一个单链表的中间位置 2 Status GetMidNode(LinkList L,ElemType *e) 3 { 4 LinklList search,mid; 5 mid =search=L; 6 while (s

利用快慢指针快速得到链表中间节点

//利用快慢指针快速得到链表中间节点 int getMiddleNodeValue(LIST * l) { NODE * search, * middle; search = l->head; middle = l->head; while (NULL != search->next) { if (NULL != search->next->next) { search = search->next -> next; middle = middle->nex

一文学会链表快慢指针解题技巧

前言 上文 我们详细地学习了链表的基本概念,优缺点,也带大家一步步由浅入深地学习了链表的翻转技巧,这一篇我们来看看链表的另一个解题技巧:快慢指针. 快慢指针在面试中出现的概率也很大,也是务必要掌握的一个要点,本文总结了市面上常见的快慢指针解题技巧,相信看完后此类问题能手到擒来.本文将详细讲述如何用快慢指针解决以下两大类问题 寻找/删除第 K 个结点 有关链表环问题的相关解法 寻找/删除第 K 个结点 小试牛刀之一 LeetCode 876:给定一个带有头结点 head 的非空单链表,返回链表的中