基础五大排序算法(冒泡+排序+插入+希尔+快速)简述

排序算法


一：冒泡排序
方法：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。
这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
时间复杂度--》最好情况:O(n) 正常情况：O(n**2) 最差情况:O(n**2)

def bubble_sort(li):
    for j in range(len(li) - 1):
        for i in range(len(li) - j - 1):
            if li[i] < li[i + 1]:
                li[i], li[i + 1] = li[i + 1], li[i]

# li = [1,5,8,9,4,6,3,2,7]
bubble_sort(li=[1, 5, 8, 9, 4, 6, 3, 2, 7])

#递归
def buble_sort(alist):

    for i in range(len(alist)-1):
        if alist[i]>alist[i+1]:
            alist[i],alist[i+1]=alist[i+1],alist[i]
            buble_sort(alist)

    return alist

 

二：选择排序

方法：
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。
'''

def SelectSort(li):
    for j in range(0,len(li)-1):
        max_index = 0 #最大值下标默认为0
        for i in range(1,len(li)-j):
            if li[max_index] < li[i]:
                max_index = i
            li[len(li)-1-j],li[max_index] = li[max_index],li[len(li)-1-j]

    return li


print(SelectSort([5,2,7,3,8,1,9,4]))

 

'''
三：插入排序
方法：
将第一待排序序列第一个元素看做一个有序序列，
把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列，
将扫描到的每个元素插入有序序列的适当位置。
（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
'''

def InsertSort(li):
    for i in range(1,len(li)):
        while i > 0:
            if li[i] < li[i-1]:
                li[i],li[i-1] = li[i-1],li[i]
                i -= 1
            else:
                break
    return li

 

'''
四：希尔排序
方法：
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，
待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。
gap：增量值或者拆分出来的组数
形状：逐渐变成有序序列
特性：是插入排序增量为gap的序列
'''

def ShellSort(li):
    gap = len(li)//2
    while gap >=1:
        for i in range(gap,len(li)):
            while i >0:
                if li[i] < li[i-gap]:
                    li[i],li[i-gap] = li[i-gap],li[i]
                    i-=gap
                else:
                    break
        gap //= 2
    return li

 

'''
五：快速排序

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

def sort(alist, start, end):
    low = start
    high = end
    # 递归结束的条件
    if low > high:
        return
    # 基准：最左侧的数值
    mid = alist[low]
    # low和high的关系只能是小于，当等于的时候就要填充mid了
    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

        # 当low和high重复的时候，将mid填充
        if low == high:
            alist[low] = mid  # or alist[high] = mid
            break
    # 执行左侧序列
    sort(alist, start, high - 1)
    # 执行右侧序列
    sort(alist, low + 1, end)

    return alist


alist = [6,1,2,7,9,3,4,5,10,8]
print(sort(alist,0,len(alist)-1))

 

排序二叉树
乱序数据的插入的时候，需要遵从一个准则：
    插入的第一个数值作为树的根节点
    后序插入的数值，如果比根节点小，插入根节点的左侧，否则插入到根节点的右侧
'''

class Node():
    def __init__(self,item):
        self.item = item
        self.left = None
        self.right = None

class SortTree():
    def __init__(self):
        self.root = None

    def add(self,item):
        node = Node(item)
        cur = self.root
        if self.root == None:
            self.root = node
            return
        while cur :
            if item > cur.item:#向右侧插入
                if cur.right == None:
                    cur.right = node
                    break
                else:
                    cur = cur.right #使节点偏移
            else:
                if cur.left == None:
                    cur.left = node
                    break
                else:
                    cur = cur.left

    def mid(self,root):#中序：左根右
        if root == None:
            return
        self.mid(root.left)
        print(root.item)
        self.mid(root.right)