2021-05-14

一、英语

1、by way of：作为、以求……
2、take a musical turn：朝着……方向转变
3、musical：喜欢音乐的，有音乐天赋的
4、keep your breath to cool your porridge：少管闲事

二、算法题目

1、739：栈

class Solution:
    #用stack维护index的递减序列
    #比较的时候根据数据大小比较，但是储存的内容是index
    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        stack = []
        cur = 0
        n = len(temperatures)
        res = [1]*n
        for i in range(n):
            while stack:
                cur = stack[-1]
                if temperatures[i]<=temperatures[cur]:
                    break
                res[cur] = i-cur
                stack.pop()
            stack.append(i)
        #栈中剩下的是没有更高天气的
        for i in stack:
            res[i] = 0
        return res

2、23：链表，归并，堆排序

方法一：直接使用指针进行链表排序(C++)
时间复杂度：$O(k^{2}n)$
空间复杂度：$O(1)$

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
//合并两个列表
    ListNode* merge(ListNode* a,ListNode* b)
    {
        if((!a)||(!b))
        return a?a:b;
        ListNode head;
        ListNode* cur = &head;
        ListNode* aptr = a;
        ListNode* bptr = b;
        while(aptr && bptr)
        {
            if(aptr->val<=bptr->val)
            {
                cur->next = aptr;
                aptr = aptr->next;
            }
            else
            {
                cur->next = bptr;
                bptr = bptr->next;
            }
            cur = cur->next;
        }
        cur->next = aptr?aptr:bptr;
        return head.next;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        //直接原地调整
        //head指针指向合并之后的头部
        //cur指向当前的位置
        ListNode* ans = nullptr;
        int n = lists.size();
        for(int i = 0;i<n;++i)
        {
            ans = merge(ans,lists[i]);
        }
        return ans;
    }
};

方法二：归并排序
时间复杂度：$O(nklogk)$
空间复杂度：$O(logk)$
相较方法一，空间换了部分时间

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    #方法二：使用归并排序
    #归并排序首先下分下分，然后再向上合并
    #python对于list函数传参传的是引用
    def merge(self,l,r):
        if not l:
            return r
        if not r:
            return l
        #合并两个列表
        i,j = l,r
        tmp = ListNode()
        cur = tmp
        #tmp = []
        while i!=None and j!=None:
            if i.val<=j.val:
                cur.next = i
                i = i.next
            else:
                cur.next = j
                j = j.next
            cur = cur.next
        while i!=None:
            cur.next = i
            i = i.next
            cur = cur.next
        while j!=None:
            cur.next = j
            j = j.next
            cur = cur.next
        return tmp.next
    def mergesort(self,num,l,r):
        if l== r:
            return num[l]
        if l>r:
            return None
        mid = (int)((l+r)/2)
        #归并：先分
        l_num = self.mergesort(num,l,mid)
        r_num = self.mergesort(num,mid+1,r)
        #后合
        return self.merge(l_num,r_num)

        
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        n = len(lists)
        return self.mergesort(lists,0,n-1)

方法三：堆排序，将每个链表的最小的值加入堆中
时间复杂度：k个链表，那么堆中就有k个元素，删除和加入一个的复杂度为log(k)，一共进行nk次，所以时间复杂度为nklog(k)
空间复杂度：堆空间o(k)

ListNode* mergeKLists(vector<ListNode*>& lists) 
    {
        struct tmp
        {
            int val;
            ListNode* p;
            bool operator < (const tmp & other) const
            {
                return val>other.val;
            }
        };
        priority_queue<tmp> q;
        int n = lists.size();
        for(int i = 0;i<n;++i)
        if (lists[i])
        q.push({lists[i]->val,lists[i]});
        ListNode head;
        ListNode* cur = &head;
        while(!q.empty())
        {
            auto f = q.top();
            q.pop();
            cur->next = f.p;
            cur = cur->next;
            if(f.p->next)
            q.push({f.p->next->val,f.p->next});
        }
        return head.next;
    }

加油！