几种排序算法

冒泡排序

# 思想就是相邻两数比较交换顺序,每一轮排序可以选出最大或最小值
list = [26, 4, 2, 52, 34, 234, 35, 23]
# print(list[0])
x = 0
y = 1
z = len(list)
while z >= 1:
    for i in range(1, z):  # 这样一趟排序可以把列表的最小值排出，排length - 1趟就可以排完
        if list[x] < list[y]:
            temp = list[x]
            list[x] = list[y]
            list[y] = temp
        else:
            pass
        x += 1
        y += 1
        i += 1
    # 每完成一次快速排序就重置xy的值
    x = 0
    y = 1
    z -= 1

print(list)

 选择排序

# 选择排序
# 思想就是每次选出组内的最值，放到最后或者最前面，排序长度依次减少
list = [26, 4, 2, 52, 34, 234, 35, 23]
n = 0
# min = list[n]         #这里选择变量代替列表元素就不行，因为交换值的时候修改的是变量值，而不是列表元素
while n < len(list):
    for i in range(n+1,len(list)):
        if list[i] < list[n]:
            temp = list[n]
            list[n] = list[i]
            list[i] = temp
    n += 1


print(list)

插入排序

# 插入排序   这个时间复杂度不确定，会根据原始的顺序程度来决定，最差情况是n^2
# 思想就是把还没有排序的元素插入到已经拍好序的列表中 把列表排序想象为新列表元素由少到多的插入，关键就是key和i下标的移动，
test = [26, 4, 2, 52, 34, 234, 35, 23]

list = []
for i in range(0, len(test)):
    list.append(test[i])
    key = list[i]
    if i > 0:           #如果列表只有一个元素，那他肯定是有序的，从第二个元素开始插入
        while list[i] < list[i - 1]:
            list[i] = list[i - 1]
            i -= 1
            list[i] = key
            if i == 0:
                break

print(list)

 快速排序

# 快速排序 思想就是分治法，把大于的放一边，小于的放一边，然后递归的对大的列表、小的列表进行快速排序

# 快排的工作过程分为三步：
# 选择基准值pivot，将列表划分为两个子列表：小于基准值和大于基准值。
# 然后对着两个列表进行快速排序
# 合并结果

def quicksort(arr):
    if len(arr) < 2:
        return arr
    else:
        pivot_index = 0
        pivot = arr[pivot_index]
        pivot_less = [i for i in arr[pivot_index + 1:] if i <= pivot]
        pivot_more = [i for i in arr[pivot_index + 1:] if i > pivot]
        return quicksort(pivot_less) + [pivot] + quicksort(pivot_more)  # 递归的对子列进行快速排序


def testquicksort():
    import random
    seq = list(range(10))

    random.shuffle(seq)  # 对列表进行随机排序
    print(seq)
    sortseq = quicksort(seq)
    print(sortseq)


testquicksort()

看一个排序是否稳定主要是看他排序完成后，值相同的元素是否可能交换顺序。

选择排序，希尔排序，快速排序，是不稳定的