LeetCode--Sort

最新推荐文章于 2024-07-26 01:21:03 发布

lawen-y

最新推荐文章于 2024-07-26 01:21:03 发布

阅读量389

点赞数

分类专栏： leetcode sort 文章标签： leetcode sort

本文链接：https://blog.csdn.net/peaktravel/article/details/73917964

版权

leetcode 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

sort

1 篇文章 0 订阅

订阅专栏

148. Sort List

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

解析：

（1）方法一：快速排序。链表排序不同于数组，数组可以通过下标直接操作。但是思想可借鉴，下面借鉴快排的思想。将链表的头节点作为基准，将链表分为左右两条，左边链表的所有节点都小于基准，右边的所有节点都大于基准。然后再对两条链表进行排序。时间复杂度为O(nlogn)。
（2）方法二：合并排序。

C++代码实现：
方法一：(LeetCode : 13/15 passed，超时)

struct ListNode {
      int val;
      ListNode *next;
      ListNode(int x) : val(x), next(NULL) {}
 };
class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if(head==NULL || head->next==NULL)
            return head;
        int count = 0;          //节点数量
        ListNode* p = head;
        while(p) {
            count++;
            p = p->next;
        }
        return quickSort(head,count);
    }
private:
    ListNode* quickSort(ListNode*& head,int count) {
        if(count>1) {
            int left = count;
            ListNode* base = partition(head,left);
            quickSort(head,left);
            if(base!=head){
                 ListNode* leftEnd = head;
                while(leftEnd->next!=base) {
                    leftEnd = leftEnd->next;
                }
                leftEnd->next = base;

            }

            if(base!=NULL && base->next!=NULL){
                ListNode*temp = quickSort(base->next,count-left-1);
                base->next = temp;
            }
        }
        return head;
    }

    ListNode* partition(ListNode*& head,int& count) { //count代表head指向的链的节点数量
        if(head==NULL || count<=1)
            return head;

        ListNode sNode(0), bNode(0);
        ListNode* p1 = &sNode,*p2 = &bNode;
        int key = head->val;
        ListNode* base = head;              //以第一个节点为基准，将链表分为两条
        int k = 0;
        while(k<count && head) {
            if(head->val < key)
                p1 = p1->next = head;
            else
                p2 = p2->next = head;
            head = head->next;
            k++;
        }
        if(!head)
            p2->next = NULL;
        else
            p2->next = head;
        p1->next = bNode.next;
        head = sNode.next;

        p1 = head;
        count = 0;
        while(p1!=base && p1!=NULL){
            count++;
            p1 = p1->next;
        }
        return base;
    }
};

179. Largest Number

Given a list of non negative integers, arrange them such that they form the largest number.
For example, given [3, 30, 34, 5, 9], the largest formed number is 9534330.
Note: The result may be very large, so you need to return a string instead of an integer.

C++代码实现：

class Solution {
public:
    string largestNumber(vector<int>& nums) {
        vector<string> datas;
        for(int a :nums)
            datas.push_back(to_string(a));

        sort(datas.begin(),datas.end(),[](string sa,string sb){
            return (sa+sb)>(sb+sa);
        });

        string result;
        for(string s : datas)
            result = result + s;

        return result[0]=='0' ? "0" : result;
    }
};