排序算法总结

冒泡排序

1.原理：比较相邻的两个元素大小，若前者大于后者则交换位置。
2.思路：数组a，长度为n
（1）比较第1轮：第一个元素a[1]和第二个元素a[2]相比，a[1]>a[2],则比较a[2]和a[3];否则交换a[1]和a[2],再比较a[2]和a[3];以此类推知道最后一个比较完成，此时a[n-1]处的元素为a中的最大值，不用参加下轮比较。
（2）比较第2轮：第一个元素a[1]和第二个元素a[2]相比，a[1]>a[2],则比较a[2]和a[3];否则交换a[1]和a[2],再比较a[2]和a[3];以此类推知道最后一个比较完成，此时a[n-2]处的元素为a中的最大值，不用参加下轮比较。
…以此类推直到所有的元素都被遍历
3.代码

def maopaoSort(arr):
    for i in range(len(arr)):
        for j in range(len(arr)-i-1):
            if arr[j] > arr[j+1]:
                temp = arr[j]
                arr[j] = arr[j+1]
                arr[j + 1] = temp
    return arr


a = maopaoSort([2, 34, 9, 7, 5, 1, 98, 6, 100])
print(a)

选择排序

1.原理：遍历待排序序列找到最小值，把最小值放入已排序的序列。
2.思路：数组a，长度为n
（1）比较第1轮：选择第一个元素为min，min=0，遍历待排序序列，与a[min]相比，若小于a[min]，将下标值给min，继续遍历，得到待排序序列最小值，把最小值放入已排序的序列。
（2）比较第2轮：第二个元素a[2]与a[min]相比，若小于a[min]，将下标值给min，继续遍历，得到待排序序列最小值，把最小值放入已排序的序列。
…以此类推直到所有的元素都被遍历
参考：选择排序思路
3.代码

def choose(arr):
    for i in range(0, len(arr)):
        min = i
        for j in range(i+1, len(arr)):
            if arr[min] > arr[j]:
                min = j
        temp = arr[i]
        arr[i] = arr[min]
        arr[min] = temp
    return arr


a = choose([1, 2, 34, 9, 7, 5])
print(a)

插入排序

1.原理：遍历待排序序列找到最小值，把最小值放入已排序的序列。
2.思路：
假设有一组无序序列 R0, R1, … , RN-1。
(1) 将序列中下标为 0 的元素视为元素个数为 1 的有序序列。
(2) 依次把 R1, R2, … , RN-1 插入到这个有序序列中。所以，我们需要一个外部循环，从下标 1 扫描到 N-1 。
(3)将 Ri 插入到前面有序的序列中。由前面所述，我们可知，插入Ri时，前 i-1 个数肯定已经是有序了。
所以我们需要将Ri 和R0 ~ Ri-1 进行比较，确定要插入的合适位置。这就需要一个内部循环，我们一般是从后往前比较，即从下标 i-1 开始向 0 进行扫描。
3.代码

def insertkSort(arr):
    for i in range(1, len(arr)):
        curr = arr[i]
        preindex = i-1
        while curr < arr[preindex]:
            arr[preindex + 1] = arr[preindex]
            preindex -= 1
        arr[preindex + 1] = curr
    return arr
a = insertSort([1, 2, 34, 9, 7, 5])
print(a)

归并排序

1.原理：
2.思路：
归并排序
3.代码

def merge(left, right):
    leftindex, rightindex = 0, 0
    arr = [0 for i in range(len(left)+len(right))]
    for i in range(0, len(arr)):
        if rightindex >= len(right):
            arr[i] = left[leftindex]
            leftindex += 1
        elif leftindex >= len(left):
            arr[i] = right[rightindex]
            rightindex += 1
        elif left[leftindex] > right[rightindex]:
            arr[i] = right[rightindex]
            rightindex += 1
        elif left[leftindex] < right[rightindex]:
            arr[i] = left[leftindex]
            leftindex += 1
    return arr


def merge_sort(arr):
    if len(arr) < 2:
        return arr

    mid = len(arr) // 2
    left = arr[0:mid]
    right = arr[mid:len(arr)]
    return merge(merge_sort(left), merge_sort(right))

快速排序

1.原理：
（1）.首先选取一个pvoit，将数组中比pvoit大的数放在后面，小的数放在pvoit后面
设计左右指针，分别从数组两边开始找到pvoit的索引值
（2）.递归排列左边的数组和右边的数组
2.思路：
快速排序
3.代码

def quick_merge(arr, low, high):
    leftindex, rightindex, privot = low, high, arr[low]
    while leftindex < rightindex:
        while arr[rightindex] > privot and leftindex < rightindex:
            rightindex -= 1
        arr[leftindex] = arr[rightindex]
        while arr[leftindex] < privot and leftindex < rightindex:
            leftindex += 1
        arr[rightindex] = arr[leftindex]
    arr[leftindex] = privot
    return leftindex


def swap(a, b):
    temp = a
    a = b
    b = temp


def quick_sort(arr, low, high):
    if low < high:
        priv = quick_merge(arr, low, high)
        quick_sort(arr, low, priv-1)
        quick_sort(arr, priv+1, high)


arr = [1, 6, 0, 2, 34, 9, 7, 5]
quick_sort(arr, 0, len(arr)-1)
for i in range(len(arr)):
    print("%d" % arr[i])