python学习笔记17 排序算法

记录一下

import math
import random


#排序，全部以由小到大为例
#冒泡法,两两比较，位置互换，适用所有范围，稳定

def maopao(arr):
    x=0
    for i in range(1,len(arr)):
        for j in range(0,len(arr)-i):
            if arr[j]>arr[j+1]:
                arr[j],arr[j+1]=arr[j+1],arr[j]
        x+=1
        #print(arr,x)

a=[1,5,7,3,2,8,9,111,-1,-3,-12,0.5,-0.9,0.4,-1.5]
maopao(a)

#基数排序，适用整数，先按个位重排，这样放到位数里面就是由小到大，然后再按照位数重排，稳定

def jishu(arr):
    x=0
    #分正负
    z,f=[],[]
    for i in arr:
        if i >=0:
            z.append(i)
        if i <0:
            f.append(i)
    #取最高位数
    zbit=len(str(max(z)))
    fbit=len(str(min(f)))-1
    #正数排个位数
    zbitorder=[]
    zorder=[]
    for j in range(0, 10):
        for i in z:
            if str(i)[-1:] == str(j):
                zbitorder.append(i)
                x+=1
    #再按位数排序
    for i in range(1, zbit + 1):
        for j in zbitorder:
            if pow(10, i - 1) <= j < pow(10, i):
                zorder.append(j)
                x+=1
    #负数同理
    fbitorder=[]
    forder=[]
    for j in range(9,-1,-1):
        for i in f:
            if str(i)[-1:]==str(j):
                fbitorder.append(i)
               #print(fbitorder)
    for i in range(fbit,0,-1):
        for j in fbitorder:
            if -pow(10,i-1)>=j>-pow(10,i):
                forder.append(j)
                #print(forder)
                x+=1
    #合并
    order=forder+zorder
    #print(order,x)

a=[9,10,10,77,128,1,5,123,6666,-5,-99,-14]
jishu(a)

#选择排序，全适用，选最小的放左边，稳定
#方法1
def xuanzhe(arr):
    order=[]
    for i in range(len(arr)):
        order.append(min(arr))
        arr.remove(min(arr))
    #print(order)
#方法2
def xuanzhe2(arr):
    for i in range(len(arr) - 1):
        # 记录最小数的索引
        minIndex = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[minIndex]:
                minIndex = j
        # i 不是最小数时，将 i 和最小数进行交换
        if i != minIndex:
            arr[i], arr[minIndex] = arr[minIndex], arr[i]
    #print(arr)

a=[-9,5,34,235,1,2,3,0]
xuanzhe2(a)

#插入排序，比较大小，变换位置，稳定
#方法一
def charu(arr):
    for i in range(len(arr)-1):
        cindex=-1
        for j in range(i+1,i,-1):
            if arr[j]<arr[i]:
                cindex=j
        if cindex !=-1:
            arr[cindex],arr[i]=arr[i][cindex]
    #print(arr)
a=[-9,5,34,235,1,1,1,2,3,0]
charu(a)
#方法二
def insertionSort(arr):
    for i in range(len(arr)):
        preIndex = i-1
        current = arr[i]
        while preIndex >= 0 and arr[preIndex] > current:
            arr[preIndex+1] = arr[preIndex]
            preIndex-=1
        arr[preIndex+1] = current
    #print(arr)
a=[-9,5,34,235,1,1,1,2,3,0]
insertionSort(a)

#希尔排序，插入排序进阶版，就是先分成子序列插入再缩小分组间隔到1进行排序
def shellSort(arr):
    import math
    gap=1
    while(gap < len(arr)/3):
        gap = gap*3+1
    while gap > 0:
        for i in range(gap,len(arr)):
            temp = arr[i]
            j = i-gap
            while j >=0 and arr[j] > temp:
                arr[j+gap]=arr[j]
                j-=gap
            arr[j+gap] = temp
        gap = math.floor(gap/3)
    #print(arr)
a=[-9,5,34,235,1,1,1,2,3,0]
shellSort(a)

#插入广告，递归和迭代
#递归
def n(n):
    all=1
    while n > 1:
        all=all*n
        n=n-1
    #print(all)
n(5)
#迭代 不知道对不对
def m(n):
    all=1
    for i in range(1,n+1):
        def x(y,n):
            y=y*n
            return y
        all=x(all,i)
    #print(all)
m(5)
#并归排序，分组排序再合并。
#1.申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
#2.设定两个指针，最初位置分别为两个已经排序序列的起始位置；
#3.比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
#4.重复步骤 3 直到某一指针达到序列尾；
#5.将另一序列剩下的所有元素直接复制到合并序列尾。
def mergeSort(arr):
    import math
    if(len(arr)<2):
        return arr
    middle = math.floor(len(arr)/2)
    left, right = arr[0:middle], arr[middle:]
    return merge(mergeSort(left), mergeSort(right))

def merge(left,right):
    result = []
    while left and right:
        if left[0] <= right[0]:
            result.append(left.pop(0))
        else:
            result.append(right.pop(0));
    while left:
        result.append(left.pop(0))
    while right:
        result.append(right.pop(0));
    return result
a=[-9,5,34,235,1,1,1,2,3,0]
#print(mergeSort(a))

#快速排序,从小开始递归形式的冒泡法。
#1.从数列中挑出一个元素，称为 "基准"（pivot）;
#2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
#3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
#下面的代码拓展了一下，设定了排序的左右边界。
def quickSort(arr, left=None, right=None):
    left = 0 if not isinstance(left,(int, float)) else left
    right = len(arr)-1 if not isinstance(right,(int, float)) else right
    if left < right:
        partitionIndex = partition(arr, left, right)
        quickSort(arr, left, partitionIndex-1)
        quickSort(arr, partitionIndex+1, right)
    return arr

def partition(arr, left, right):
    pivot = left
    index = pivot+1
    i = index
    while  i <= right:
        if arr[i] < arr[pivot]:
            swap(arr, i, index)
            index+=1
        i+=1
    swap(arr,pivot,index-1)
    return index-1

def swap(arr, i, j):
    arr[i], arr[j] = arr[j], arr[i]

a=[-9,5,34,235,1,1,1,2,3,0]
print(quickSort(a))
a=[-9,5,34,235,1,1,1,2,3,0]
print(quickSort(a,2,7))