各种排序的算法python实现

class Solution(object):
    def bubblesort(self, nums):
        """
        每次循环判断前后两个数大小, 大的往后走, 一次循环下来最大的到最尾部
        第二次循环只需要前n-1个数进行即可
        """
        for i in range(len(nums)):
            flag = True
            for j in range(len(nums)-1-i):
                if nums[j] > nums[j+1]:
                    flag = False
                    nums[j], nums[j+1] = nums[j+1], nums[j]
            if flag:
                break
        return nums
    def fastsort(self, nums):
        def partition(nums, start, end):
            pivot = nums[start]
            i = start
            j = end
            while i < j:
                # 从右向左找比pivot小的数
                while i < j and nums[j] >= pivot:
                    j = j - 1
                # 从左向右找比pivot大的数
                while i < j and nums[i] <= pivot:
                    i = i + 1
                if i < j:
                    nums[j], nums[i] = nums[i], nums[j]
            nums[start], nums[i] = nums[i], nums[start]
            return i
        def recur(nums, start, end):
            if start >= end:
                return
            par_index = partition(nums, start, end)
            recur(nums, start, par_index - 1)
            recur(nums, par_index + 1, end)
            return nums
        start = 0
        end = len(nums) - 1
        return recur(nums, start, end)

    def selectsort(self, nums):
        """
        每次选择出来最小的和i交换
        """
        for i in range(len(nums)-1):
            min_index = i
            for j in range(i+1, len(nums)):
                if nums[j] < nums[min_index]:
                    min_index = j
            if min_index != i:
                nums[i], nums[min_index] = nums[min_index], nums[i]
        return nums

    def insertsort(self, nums):
        for i in range(1, len(nums)):
            key = nums[i]
            j = i - 1
            while j >= 0 and nums[j] > key:
                nums[j+1] = nums[j]
                j = j - 1
            nums[j+1] = key
        return nums

    def mergesort(self, nums):
        def merge(left, right):
            res = []
            i = 0
            j = 0
            while i <= len(left) - 1 and j <= len(right) - 1:
                if left[i] < right[j]:
                    res.append(left[i])
                    i = i+1
                else:
                    res.append(right[j])
                    j = j+1
            if i <= len(left) - 1:
                res = res + left[i:]
            if j <= len(right) - 1:
                res = res + right[j:]
            return res

        if len(nums) == 1:
            return nums
        mid = len(nums) // 2
        left = self.mergesort(nums[0:mid])
        right = self.mergesort(nums[mid:])
        return merge(left, right)

    # https://www.cnblogs.com/chengxiao/p/6129630.html
    def heapsort(self, nums):
        def heapadjust(nums, start, end):
            parent = start
            child = 2 * parent + 1
            while child <= end:
                if child + 1 <= end and nums[child+1] > nums[child]:
                    child = child + 1
                if nums[parent] > nums[child]:
                    return
                else:
                    nums[parent], nums[child] = nums[child], nums[parent]
                    parent = child
                    child = 2 * parent + 1
        start = len(nums) // 2 - 1
        end = len(nums) - 1
        for i in range(start, -1, -1):
            heapadjust(nums, i, end)
        for i in range(len(nums)-1, 0, -1):
            nums[0], nums[i] = nums[i], nums[0]
            heapadjust(nums, 0, i-1)
        return nums
nums = [3,1,2,6,5]
Test = Solution()
print(Test.bubblesort(nums))
nums = [3,1,2,6,5]
print(Test.mergesort(nums))
print("a", nums)
nums = [3,1,2,6,5]
print(Test.selectsort(nums))
nums = [3,1,2,6,5]
print(Test.insertsort(nums))
nums = [3,1,2,6,5]
print(Test.fastsort(nums))
nums = [3,1,2,6,5]
print(Test.heapsort(nums))