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 148. Sort List--O(nlogn)时间复杂度和常数空间复杂度给链表排序

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

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

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

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

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

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

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

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

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))

时间复杂度为O(nlogn)的经典排序算法的实现,包括归并排序、快速排序、堆排序以及希尔排序

数据结构之排序算法之O(nlogn)

上一次写了冒泡,选择,和插入排序。 这一次写一下堆排序、归并、快速排序。 堆排序 堆排序,主要是利用完全二叉树在数组中的存储方式(层序遍历),i 位置的节点的儿子是 2i 和 2i+1 。 最...

快速排序[平均时间复杂度O(NlogN)]

基本思想: 假设我们现在对“6 1 2 7 9 3 4 5 10 8”这10个数进行排序。首先在这个序列中随便找一个数作为基准数。为了方便,就让第一个数6作为基准数。分别从初始序列“6 1 2 7 9...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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