【无标题】

1 冒泡排序

j=0. 就是将一排最大的数一次比较，如果大就往后走，直到走到倒数第一个n-2（但是写代码要写到n-1）便能得出顺序
第二次走的话，j =1，要走到n-3（代码是n-1-1）

#第一次 i 0到n-2(倒数第二个）因为走到倒数第二个直接可以与倒数第一个分出谁大小 range(0,n-1)取到的是n-2这个数 j =0
#第二次 i 0到n-3（倒数第三个） range（0，n-1-1） j=1
#第三次 i 0到n-4（倒数第四个） range（0，n-1-2） J=2
时间复杂度是O(N2)
优化：
就是如果一个序列本身就是按照顺序排列，那么只需走一回就能分辨那就是O(N),
#j = n, i range(0,n-1-j)

1.1 代码块

def bubble_sort(alist):
n = len(list)
for j in range(n-1) #控制下面的循环多少次，走一次找到一个，走两次找到两个，剩下的最后一个自己出现。只需n-1个数 0-n-2
count = 0
for i in range(0, n-1-j) #产生n-1次比较
#班长从头走到尾
if alist[i] > alist[i+1]:
alist[i], alist[i+1] = alist[i+1], alist[i]
count +=1
if 0 == count:
return
if name == “main”:
li = [54, 26,93,17,31,44,55,20]
print(li)
bubble_sort(li)
print(li)

2 选择排序

  就是将一个数拿出来然后与后面的每个数进行比较，若是找到比较小的就交换位置，然后放在一个位置上，接着从后面的数中相同步骤找到最小的放在第二个位置上
  选择排序 先做好内层的代码排序，然后看这样的排序需要执行多少次，然后再写外部的循环，找出j与i的联系

2.1 代码块

#alist =[17,20, 93,54,77,31,44,55,226]
0 1 2 3 4 5 6 7 8
#j=0
#min=0 0+1
#alist[0],alist[3] =alist[3],alist[0]

#j=1
#min=1 1+1
#alist[1],alist[8] =alist[8],alist[1]

#j =2
#min 2 2+1
#选择排序 先做好内层的代码排序，然后看这样的排序需要执行多少次，然后再写外部的循环，找出j与i的联系
def select_sort(alist):
n=len(alist)
#j = [0,1,2,3…n-2] 每次当j确定，就去找其后面的一些元素i来比较，所以i从他后面一个元素来开始
for j in range(0,n-1): #j:0到n-2 实际只到n-1这个数
min_index = j
for i in range(1,n):#最后一个元素是n-1，但是要产生n-1个所以要到n
if alist[min_index]> alist[i]:#找出一个最小的，然后与后面的进行比较，找到真正的索引最小的，然后进行交换，这个循环是很多次执行
min_index = i
alist[j],alist[min_index] = alist[min_index],alist[j]

if name == “main”:
li = [54, 26,93,17,31,44,55,20]
print(li)
select_sort(li)
print(li)

2.2 时间复杂度和稳定性

内层是n次，外层也是n，所以是O(N2),最优化也是O(N2)
稳定：不稳定，因为若是升序排列，例如 [23,12, 23,(66,1), 1,2,4, (66,2),34,55]排序完，将(66,1)放在最后，然后剩下的排序， (66,2),排在倒数第二个 [23,12, 23, 1,2,4,34,55， (66,2)，(66,1)] 这样很奇怪，本事一样的却颠倒了位置，而冒泡则不会，比较稳定

3 插入算法

分为两部分，前面一部分是排好序的，后面的一部分没有排序，固定第一个，将后面无序的数一个接一个拿出，与前面的有序数比较，再插入插入该有位置序列中，跟选择排序不一样，选择排序是找出后面最小的放在前面的末尾，是操作后面，而插入算法是操作前面

3.1代码块

#alist =[93, 54,17,20 ,77,31,44,55,226]
#插入排序
def insert_sort(alist):
n = len(alist)
#从右边的无序序列中取出多少个元素执行这样的过程
for j in range(1, n):#第一个元素已经确定，从第二个元素开始取
# j = [1,2,3,n-1]
#i 代表内层循环起始值
i=j#而内层的元素也是从第二个开始
#执行从右边的无序序列中取出第一个元素，即i位置的元素，然后将其插到前面的正确位置上
while i > 0: #位置到开头的时候就不继续
if alist[i]<alist[i-1]:
alist[i],alist[i-1] = alist[i-1],alist[i]
i -=1 #后面的一个数比较好了，那就再往前面走一个数再比较
else: #后面的数比前面大，就不变退出就行
break
if name == “main”:
li = [54, 26,93,17,31,44,55,20]
print(li)
insert_sort(li)
print(li)

3.2时间复杂度和稳定性

最优：就是有序[17, 20, 26, 31, 44, 54, 55, 93]，每次取一个都比前面的大，直接else-break退出，内层虽然是循环体，但是都是执行一个语句就退出，每次，所以内层循环就将为1了。外层都要执行每一个，所以需要n-1个，总的就是O（N）
最坏的就是：O（N2）
是否稳定： [54, ,77,93,77,31,44,55,20]----[23,54, 77,77,31,44,55,20]，遇到77就不变了，原先的前面在前面，两者顺序没变

4 希尔排序

（ShellSort）是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DLShell于1959年提出而得名。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成组，算法便终止。

希尔排序过程
希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

4.1代码块

def shell_sort(alist):
#n=9
n = len(alist)
#gap =4
gap = n // 2

#gap变化到0之前，插入算法执行的次数
while gap > 0:
    #插入算法，与普通的插入算法的区别就是gap的步长
    for j in range(gap,n):# 向外扩了一层，内层的元素要做多少次，从中间算起，只需看后面的，这是针对gap不变的
        #j = [gap,gap+1,gap+2,gap+3..n-1]
        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//=2

if name == “main”:
li = [54, 26,93,17,31,44,55,20]
print(li)
shell_sort(li)
print(li)

4.2时间复杂度

最优时间复杂度：根据步长序列的不同而不同
最坏时间复杂度：O（N2）
稳定：不稳定

5 快速排序

将54把其他分成两个部分，左边比54小，右边比54大，

54作为中间值，然后此时他的位置空了，比较20与54，显然20小，就把他们交换位置

此时high空了，现在low就往前走，如果比54小就继续走,若遇到比54大的话就将值放在空的high位置上

将93移过去后，low空着了，然后开始看high，若55比54大，就往前一步，44比54小，就将44放在low位置上，看low移动

当low和high图标相遇就把mid=54放进来

5.1代码块

#快速排序
def quick_sort(alist, first,last):
if first >= last:#当只有一个元素
return
mid_value = alist[first]
low = first
high = last
while low < high:
#high左移
while low < high and alist[high] >= mid_value:
high -= 1
alist[low] = alist[high]
while low < high and alist[low] < mid_value:
low += 1
alist[high] = alist[low]
#循环退出时，low==high
alist[low] = mid_value

#以下就是递归嵌套，因为执行完一次，需要再将左右两边再次经过这样的排序，所以就再次引用之前的方法
#对low左边的列表执行快速排序
quick_sort(alist, first, low-1)
#对low右边的列表排序
quick_sort(alist, low+1, last)
if name == “main”:
li = [54, 26,93,17,31,44,55,20]
print(li)
quick_sort(li, 0, len(li)-1)
print(li)

5.2时间复杂度

因为要每次拆成一般半，所以要一直除以2，反过来就是2的多少次方为你，所以就是O(logn).ME
每次都是找n个，所以就是O(nlogn）

最坏的程度：就是O(n2），因为每次只分成一个加上后面的全部，一次找n，再分成n次。就是n2
稳定性：不稳定，因为每次调的时候都是会跳