排序

各种排序算法的可视化网站
重点掌握插入排序，归并排序，快速排序，堆排序

1.排序数组

题目：给你一个整数数组 nums，请你将该数组升序排列。
示例 1：
输入：nums = [5,2,3,1]
输出：[1,2,3,5]

思路：下面采用几种常见的排序算法
假设数组长度为n：
选择排序：从头遍历数组n次，每次都选择最大/小的数存放在数组的起始位置，然后再从剩下的数中连续找次大/小的数。平均时间复杂度：O(n2)
冒泡排序：从后往前，比较相邻两个数据，交换位置，大的数沉底，小的冒起来；【优化：设置标志位flag，如果发生了交换flag设置为true；如果没有交换就设置为false】。平均时间复杂度：O(n2)
插入排序：将当前的数与前面的数比较，也就是第i个数插入[0, i]之间使之有序，前面的数都是排序好的。平均时间复杂度：O(n2)
归并排序：采用分而治之的思想，不断分成两个有序数组再合并。平均时间复杂度：O(N*logN)
快速排序

在排序时不改变其序列，则称所用的方法是稳定的。
稳定排序算法有：插入排序，基数排序，归并排序，冒泡排序，计数排序。
不稳定排序算法有：快速排序，希尔排序，简单选择排序，堆排序。

def sortArray(self, nums: List[int]) -> List[int]:  
		#选择排序
       length = len(nums)
        for i in range(length):
            for j in range(i,length):
                if nums[i] > nums[j]:
                    nums[i],nums[j]=nums[j],nums[i]
        return nums

def pubble(self,  nums: List[int]) -> List[int]:  
		#冒泡排序
        n = len(nums)
        for i in range(n):
            flag = False
            for j in range(n-1, i,-1):
                if nums[j] < nums[j-1]:
                    tmp = nums[j]
                    nums[j] = nums[j-1]
                    nums[j-1] = tmp
                    flag = True
            if flag == False:
                break
        return nums
def Selectionsort(self， nums: List[int]) -> List[int]:
		#插入排序
        length = len(nums)
        for i in range(length):
            for j in range(i):
                if nums[i]<nums[j]: # j 从头开始遍历
                    nums[i],nums[j] = nums[j],nums[i]
        return nums


def sortArray(self, nums: List[int]) -> List[int]:
		#归并排序
        n = len(nums)
        if n<=1:
           return nums
        mid = n//2
        left = self.sortArray(nums[:mid])
        right = self.sortArray(nums[mid:])
        return self.merge(left,right)
    
    def merge(self,left,right):
        i = 0
        j = 0
        res = []
        while i <len(left) and j <len(right):
            if left[i] <right[j]:
                res.append(left[i])
                i+=1
            else:
                res.append(right[j])
                j+=1
        res+=left[i:]
        res+=right[j:]
        return res

2. 对链表进行插入排序（medium）

题目：
插入排序算法：插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。
每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。
重复直到所有输入数据插入完为止。
示例 1：
输入: 4->2->1->3
输出: 1->2->3->4

思路：采用双指针pre 和 tail分别指向新的链表头部和尾部，设置一个伪头部dummy，当前节点数值小于前一节点数值时，从头开始遍历，直到找到插入的位置，找到之后就跟插入节点一样的做法

def insertionSortList(self, head: ListNode) -> ListNode:
        dummy = ListNode(float('-inf'))
        pre = dummy
        tail = dummy
        node = head
        while node:
            if node.val > tail.val:
                tail.next = node
                tail=node
                node= node.next
            else:										   #当前节点数值比上一节点数值小
                tmp  = node.next
                tail.next = tmp
                while pre.next and pre.next.val <node.val: #跳出循环找到插入位置
                    pre =pre.next
                node.next = pre.next
                pre.next = node
                pre = dummy
                node = tmp
        return  dummy.next