3.25leetcode206. 反转链表160. 相交链表215. 数组中的第K个最大元素

本文链接：https://blog.csdn.net/weixin_51564269/article/details/123735726

第一次ac的代码（递归）：

class Solution:
    
    def reverseList(self, head: ListNode) -> ListNode:
        if head == None:return None
        if not head.next:return head
        rear = head
        while rear.next:
            rear = rear.next
        def f(node):
            if node.next.next is None:
                cur = node.next
                node.next=None
                cur.next=node
            else:
                f(node.next)
                cur = node.next
                node.next=None
                cur.next=node
        f(head)
        return rear

想到python交换变量可以用 x, y = y, x 试了一下好像并不可以这样换next，具体原因和为什么可以x, y = y, x 还没搞懂，看讲解挺复杂的。。

双指针简单很多：

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if not head: return head
        pre, cur = head, head.next
        while cur:
            tmp = cur.next
            cur.next = pre
            pre = cur
            cur = tmp
        head.next = None
        return pre

160. 相交链表

别整花活了

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        if not headA or not headB:
            return None
        a, b = headA, headB
        lena, lenb = 0,0
        while a:
            lena+=1
            a=a.next
        while b:
            lenb+=1
            b=b.next
        a, b = headA, headB
        if lena>lenb:
            a,b=b,a
            lena,lenb=lenb,lena
        for _ in range(lenb-lena):
            b=b.next
        if a==b:return a
        for _ in range(lena-1):
            a=a.next
            b=b.next
            if a==b:return a
            
        return None

快速排序：

void QuickSort(int R[], int lo, int hi){
    int i = lo, j = hi;
    int temp;
    if(i < j){
        temp = R[i];
        while (i != j)
        {
            while(j > i && R[j] >= temp)-- j;
            R[i] = R[j];
            while(i < j && R[i] <= temp)++ i;
            R[j] = R[i];
        }
        R[i] = temp;
        QuickSort(R, lo, i - 1);
        QuickSort(R, i + 1, hi);
    }
}

215. 数组中的第K个最大元素用快排很慢，明天看堆的解法

#快排
class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        def qsort(list,le,ri):
            if le<ri:
                cur = list[le]
                l,r=le,ri
                while le != ri:
                    while le<ri and list[ri]>=cur:
                        ri -= 1
                    list[le] = list[ri]
                    while le<ri and list[le]<=cur:
                        le += 1
                    list[ri] = list[le]
                list[le] = cur
                qsort(list,l,le)
                qsort(list,le+1,r)
        qsort(nums,0,len(nums)-1)
        return nums[len(nums)-k]