排序

冒泡排序

#冒泡排序：两个元素一一比对，大的往后走
def sort(alist):
    length = len(alist)
    for j in range(length-1):
        #找出列表中的最大值,一一比对，需要比对列表长度-1次
        for i in range(length-1-j):
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]
a = [3,8,5,7,6]
sort(a)
print(a)

选择排序

选择排序改进了冒泡排序，每次遍历列表只做一次交换。为了做到这一点，一个选择排序在他遍历时寻找最大的值，并在完成遍历后，将其放置在正确的位置

对于冒泡排序来讲选择排序由于交换数量的减少，选择排序通常在基准研究中执行得更快。

#选择排序：减少冒泡排序元素交换赋值的次数。以此找出列表中的最大值，然后让其存放在列表的尾部
def sort(alist):
    length = len(alist)
    for j in range(length-1,0,-1):
        #假设0对应的是最大元素下标
        max_index = 0
        #找出最大元素下标，然后将最大值放置列表尾部
        for i in range(1,j+1):
            if alist[i] > alist[max_index]:
                max_index = i
        alist[max_index],alist[j] = alist[j],alist[max_index]
    
a = [3,8,5,7,6]
sort(a)
print(a)

插入排序

插入排序的主要思想是每次取一个列表元素与列表中已经排序好的列表段进行比较，然后插入从而得到新的排序好的列表段，最终获得排序好的列表。比如，待排序列表为[49,38,65,97,76,13,27,49]，则比较的步骤和得到的新列表如下：(带有背景颜色的列表段是已经排序好的，红色背景标记的是执行插入并且进行过交换的元素）

#插入排序：将列表元素以此插入到一个有序列表中
#3是有序（升序）序列，将8插入到有序序列中
#1-->[3,  8,5,7,6]
i = 1
if alist[i] < alist[i-1]:
    alist[i],alist[i-1] = alist[i-1],alist[i]
    
#2-->[3,8,  5,7,6]
i = 2
if alist[i] < alist[i-1]:
    alist[i],alist[i-1] = alist[i-1],alist[i]
    i -= 1 #goto if

#3-->
i = 2
while i>0:
    if alist[i] < alist[i-1]:
        alist[i],alist[i-1] = alist[i-1],alist[i]
        i -= 1 #goto if
#4-->[3,5,8,  7,6]
for j in range(1,length):
    i = j
    while i > 0:
        if alist[i] < alist[i-1]:
            alist[i],alist[i-1] = alist[i-1],alist[i]
            i -= 1
        else:
            break

#finally:
def sort(alist):
    for j in range(1,len(alist)):
        i = j
        while i > 0:
            if alist[i] < alist[i-1]:
                alist[i],alist[i-1] = alist[i-1],alist[i]
                i -= 1
            else:
                break
a = [3,8,5,7,6]
sort(a)
print(a)

西尔排序

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本,该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量（gap）”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率比直接插入排序有较大提高。

#希尔排序：缩小增量排序。初始化一个增量值（len(alist)//2）,然后使用增量将源数据分成n分（每份间隔为gap）。依次将每一份数据进行插入排序，然后逐渐缩小增量之
[8,9,1,7,6,4,5,2,3] ==> gap=5 

#插入排序的核心
#i的前一个元素是i-1,但是在希尔中一组数据之间的间隔是gap
gap = len(alist)//2

i = 1
if alist[i] < alist[i-1]:
    alist[i],alist[i-1] = alist[i-1],alist[i]
    i -= 1
else:
    break

----------------------------------------------------------------------------------------

#插入排序的核心
#i的前一个元素是i-1,但是在希尔中一组数据之间的间隔是gap
gap = len(alist)//2
i = 1
while i > 0:
    if alist[i] < alist[i-gap]:
        alist[i],alist[i-gap] = alist[i-gap],alist[i]
        i -= gap
    else:
        break
#下一步是的gap缩减

----------------------------------------------------------------------------------------

i = 1
#i的前一个元素是i-1,但是在希尔中一组数据之间的间隔是gap
gap = len(alist)//2

while i > 0:
    if alist[i] < alist[i-gap]:
        alist[i],alist[i-gap] = alist[i-gap],alist[i]
        i -= gap
    else:
        break

----------------------------------------------------------------------------------------

#i的前一个元素是i-1,但是在希尔中一组数据之间的间隔是gap
gap = len(alist)//2

while gap >= 1:
    for j range(gap,len(alist)):
        i = j
        while i > 0:
            if alist[i] < alist[i-gap]:
                alist[i],alist[i-gap] = alist[i-gap],alist[i]
                i -= gap
            else:
                break
    #下一步是的gap缩减
    gap = gap // 2

#finally
def sort(alist):
    gap = len(alist)//2
    while gap >= 1:
        for j in range(gap,len(alist)):
            i = j
            while i > 0:
                if alist[i] < alist[i-gap]:
                    alist[i],alist[i-gap] = alist[i-gap],alist[i]
                    i -= 1
                else:
                    break
        gap = gap // 2
a = [8,9,1,7,6,4,5,2,3]
sort(a)
print(a)

快速排序

• 将列表中第一个元素设定为基准数字，赋值给mid变量，然后将整个列表中比基准小的数值放在基准的左侧，比基准到的数字放在基准右侧。然后将基准数字左右两侧的序列在根据此方法进行排放。
• 定义两个指针，low指向最左侧，high指向最右侧
• 然后对最右侧指针进行向左移动，移动法则是，如果指针指向的数值比基准小，则将指针指向的数字移动到基准数字原始的位置，否则继续移动指针。
• 如果最右侧指针指向的数值移动到基准位置时，开始移动最左侧指针，将其向右移动，如果该指针指向的数值大于基准则将该数值移动到最右侧指针指向的位置，然后停止移动。
• 如果左右侧指针重复则，将基准放入左右指针重复的位置，则基准左侧为比其小的数值，右侧为比其大的数值。

#快速排序
low = 0
high = len(alist)-1
mid = alist[low]
#从右往左判断
if alist[high] >= mid:
    high -= 1
else:
    alist[low] = alist[high]

----------------------------------------------------------------------------------------

#快速排序
low = 0
high = len(alist)-1
mid = alist[low]
#从右往左判断
while low < high:
    if alist[high] >= mid:
        high -= 1
    else:
        alist[low] = alist[high]
        break
while low < high:
    if alist[low] < mid:
        low += 1
    else:
        alist[high] = alist[low]
        break

----------------------------------------------------------------------------------------

#快速排序
low = 0
high = len(alist)-1
mid = alist[low]
while low < high:
    #从右往左判断
    while low < high:
        if alist[high] >= mid:
            high -= 1
        else:
            alist[low] = alist[high]
            break
    while low < high:
        if alist[low] < mid:
            low += 1
        else:
            alist[high] = alist[low]
            break
alist[low] = mid

#快速排序
def sort(alist,start,end):
    low = start
    high = end
    mid = alist[low]
    while low < high:
        #从右往左判断
        while low < high:
            if alist[high] >= mid:
                high -= 1
            else:
                alist[low] = alist[high]
                break
        while low < high:
            if alist[low] < mid:
                low += 1
            else:
                alist[high] = alist[low]
                break
    alist[low] = mid
    sort(alist,start,low-1)
    sort(alist,low+1,end)
l = [3,8,5,7,6]
quiteSort(l,0,len(l)-1)
print(l)