leetcode链表O(nlogn)排序

原创 2016年08月31日 15:25:26

这个题主要考察的是排序思想的应用,虽然可能大部分都知道数组上的排序,但是如果用到链表上,

可能有些人可能就会有人一时想不起来,这道题要求O(nlogn)的算法,所以考虑快排,归并,堆排,

堆排个人认为不怎么好写,这里不做考虑,主要讲一下快排,归并,以及一种直接调用库函数的写法。

首先讲一下最简单的使用库函数的方法,可以说是个投机取巧的方法,直接看代码:

class Solution {
public:
    ListNode *sortList(ListNode *head) {
        if(head==NULL){
            return NULL;
        }
       	vector<int> v;
        for(ListNode* p=head;p;p=p->next){
            v.push_back(p->val);
        }
        sort(v.begin(),v.end());
        int i=0;
        for(ListNode* p=head;p;p=p->next){
            p->val=v[i++];
        }
        return head;
    }
   
};
然后是快排的写法,用了快排的思想,以及交换值:

class Solution {
public:
    ListNode *sortList(ListNode *head) {
        if(head==NULL){
            return NULL;
        }
        sortList(head,NULL);
        return head;
    }
    void sortList(ListNode *head,ListNode *tail){
        if(head==tail)
            return;
        ListNode *mid=partition(head,tail);
        sortList(head,mid);
        sortList(mid->next,tail);
    }
    ListNode* partition(ListNode *node,ListNode *tail){
        ListNode *cur=node;
        ListNode *next=node->next;
        while(next!=tail){
            if(next->val<node->val){
                cur=cur->next;
                swap(cur->val,next->val);
            }
            next=next->next;
        }
        swap(cur->val,node->val);
        return cur;
    }
};

归并的话,主要是归并的思想加上设置一快一慢俩个指针找到链表的中点。

class Solution {
public:
    ListNode *sortList(ListNode *head) {
        if(head==NULL||head->next==NULL){
            return head;
        }
       ListNode *fast=head->next,*slow=head;
       while(fast!=NULL&&fast->next!=NULL){
           fast=fast->next->next;
           slow=slow->next;
       }
        ListNode* head2=slow->next;
        slow->next=NULL;
        ListNode *p1=sortList(head);
        ListNode *p2=sortList(head2);
        ListNode *p=merge(p1,p2);
       	return p;
    }
   	ListNode* merge(ListNode* p1,ListNode* p2){
        if(p1==NULL) return p2;
        if(p2==NULL) return p1;
        ListNode* phead;
        if(p1->val<p2->val){
           	phead=p1;
            phead->next=merge(p1->next,p2);
        }
        else{
            phead=p2;
            phead->next=merge(p1,p2->next);
        }
        return phead;
    }
};


版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

单链表排序(快速排序、归并排序)

本题目来源于LeetCode,具体如下: Sort a linked list in O(n log n) time using constant space complexity. 题目要求...

实现时间复杂度为O(nlogn)的链表排序算法

简介链表排序是一道常见的关于链表的算法题,往往我们会使用冒泡排序或者选择排序这两种算法来解决这个问题。但是它们的时间复杂度是O(n²),效率不高。所以今天我们要实现时间复杂度O(nlogn)的算法就不...
  • MBuger
  • MBuger
  • 2017年04月20日 15:15
  • 735

leetcode之时间复杂度为O(nlogn)的链表排序

3. Sort List Sort a linked list in O(n log n) time using constant space complexity.

LeetCode 148. Sort List--O(nlogn)时间复杂度和常数空间复杂度给链表排序

Sort a linked list in O(n log n) time using constant space complexity. package com.main; class Lis...

O(nlogn)时间复杂度 链表排序

可以使用归并排序 int counter = 0;// statistic struct list_node { int val; struct list_node* next; lis...

对链表排序,时间开销O(nlogn), 空间开销O(1)

Sort a linked list in O(n log n) time using constant space complexity.

LeetCode 最长递增子序列的O(nlogn)详解

#include #include #include #include using namespace std; //求DP vector getLIS(vector &num){ vec...

leetcode 300.Longest Increasing Subsequence(最长递增子序列) O(nlogn)算法

leetcode 300.Longest Increasing Subsequence(最长递增子序列) ,网上多是动态规划,复杂度为O(n^2)算法;本文设计一个O(nlogn)算法,即维护最小的最...

改进版快速排序(平均复杂度O(NlogN))

#includeusing namespace std; #define MAXSIZE 21 typedef int SqList[MAXSIZE]; #define ElementTy...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:leetcode链表O(nlogn)排序
举报原因:
原因补充:

(最多只允许输入30个字)