148:Sort List【链表】【排序】

题目链接:https://leetcode.com/problems/sort-list/

/*题意:对链表进行排序*/

/**
 *思路:归并排序
 *      分治:将链表分成两段:用slow和fast指针,slow每次只走一步,fast每次
 *      走两步。当fast为空时,slow所在位置就是链表中间。
 *      合并:两个简单的链表的合并
 */
class Solution {
public:
    void show(ListNode *head) {
        while(head != NULL) {
            cout << head->val << " ";
            head = head->next;
        }
        cout << endl;
    }
    ListNode *Merge(ListNode *headA, ListNode *headB) {
        ListNode *root = new ListNode(0);
        ListNode *p = root;
        while(headA && headB) {
            if(headA->val <= headB->val) {
                p->next = headA;
                headA = headA->next;
            }
            else {
                p->next = headB;
                headB = headB->next;
            }
            p = p->next;
        }
        while(headA) {
            p->next = headA;
            p = p->next;
            headA = headA->next;
        }
        while(headB) {
            p->next = headB;
            p = p->next;
            headB = headB->next;
        }
        ListNode *res = root->next;
        delete root;
        return res;

    }
    ListNode *MergeSort(ListNode *head) {
        //只有一个结点
        if(head == NULL || head->next == NULL) return head;
        ListNode *slow = head;            //慢指针
        ListNode *fast = head->next->next;//快指针
        while(fast != NULL && fast->next != NULL) {
            slow = slow->next;
            fast = fast->next->next;
        }
        ListNode *headA = head;
        ListNode *headB = slow->next;
        slow->next = NULL;      //将链表断开
        headA = MergeSort(headA);
        headB = MergeSort(headB);
        return Merge(headA, headB);
    }
    ListNode* sortList(ListNode* head) {
        if(head == NULL || head->next == NULL)
            return head;
        return MergeSort(head);
    }
};

  

时间: 2024-08-13 08:39:17

148:Sort List【链表】【排序】的相关文章

[LeetCode] 148. Sort List 链表排序

Sort a linked list in O(n log n) time using constant space complexity. Example 1: Input: 4->2->1->3 Output: 1->2->3->4 Example 2: Input: -1->5->3->4->0 Output: -1->0->3->4->5 解法:归并排序.由于有时间和空间复杂度的要求.把链表从中间分开,递归下去,都

[LeetCode] Sort List 链表排序

Sort a linked list in O(n log n) time using constant space complexity. 常见排序方法有很多,插入排序,选择排序,堆排序,快速排序,冒泡排序,归并排序,桶排序等等..它们的时间复杂度不尽相同,而这里题目限定了时间必须为O(nlgn),符合要求只有快速排序,归并排序,堆排序,而根据单链表的特点,最适于用归并排序.代码如下: /** * Definition for singly-linked list. * struct List

148 Sort List 链表上的归并排序和快速排序

在使用O(n log n) 时间复杂度和常数级空间复杂度下,对链表进行排序. 详见:https://leetcode.com/problems/sort-list/description/ 方法一:归并排序 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class

[LintCode] Sort List 链表排序

Sort a linked list in O(n log n) time using constant space complexity. Have you met this question in a real interview? Yes Example Given 1->3->2->null, sort it to 1->2->3->null. Challenge Solve it by merge sort & quick sort separatel

[LeetCode]148. Sort List链表归并排序

要求时间复杂度O(nlogn),空间复杂度O(1),采用归并排序 传统的归并排序空间复杂度是O(n),原因是要用一个数组表示合并后的数组,但是这里用链表表示有序链表合并后的链表,由于链表空间复杂度是O(1),所以可以. 链表问题经常出现TLE问题或者MLE问题,这时候要检查链表拼接过程或者循环过程,看有没有死循环 public ListNode sortList(ListNode head) { if (head==null||head.next==null) return head; //利用

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

Sort List &amp;&amp; Insertion Sort List (链表排序总结)

Sort List Sort a linked list in O(n log n) time using constant space complexity. Have you been asked this question in an interview?                   Yes               说明:归并排序: 时间 O(nlogn),空间 O(1). 每次将链表一分为二, 然后再合并.快排(用两个指针) /** * Definition for sing

将单链表排序的两种方法

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

单向链表排序

一.冒泡排序简述 1.概念 冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法. 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越大的元素会经由交换慢慢"浮"到数列的顶端. 2.实例分析 以数组为例进行说明: 数组a[4] = {4,3,2,1} 从前向后依次比较两个元素的大小,如果顺序错误就交换它们.经过这样一轮,最大的元素就被

No.148 Sort List

No.148 Sort List Sort a linked list in O(n log n) time using constant space complexity. 分析: 常量空间且O(nlogn)时间复杂度,单链表适合用归并排序,双向链表适合用快速排序 有一个问题是:若算上栈空间,空间复杂度也为O(nogn) 还是对排序算法不够熟练!! 1 struct ListNode 2 { 3 int val; 4 ListNode *next; 5 ListNode(int x):val(