常见排序算法

1.冒泡排序

def bubble_sort(alist):
        """冒泡排序"""
        n = len(alist)
        for j in range(0,n-1):
                # 走多少次
            count = 0 # 交换次数计数
            for i in range(0, n-1-j):
                # 从头走到尾，最后一个不用遍历到，到倒数第二个停止
                if alist[i]>alist[i+1]:
                    alist[i],alist[i+1]=alist[i+1],alist[i]
                    count += 1
            if count == 0:
                break
                # 没有交换说明已经排好顺序，直接退出循环
    
if __name__ == '__main__':
        li = [54,26,84,24,15]
        bubble_sort(li)
        print(li)

2.二叉树的前中后序遍历

class Node(object):
    """节点类"""
    def __init__(self, elem=-1, lchild=None, rchild=None):
        self.elem = elem
        self.lchild = lchild
        self.rchild = rchild

class Tree(object):
    """树类"""

    def __init__(self, root=None):
        self.root = root

    def add(self, elem):
        """为树添加节点"""
        node = Node(elem)
        # 如果树是空的，则对根节点赋值
        if self.root == None:
            self.root = node
        else:
            queue = []
            queue.append(self.root)
            # 对已有的节点进行层次遍历
            while queue:
                # 弹出队列的第一个元素
                cur = queue.pop(0)
                if cur.lchild == None:
                    cur.lchild = node
                    return
                elif cur.rchild == None:
                    cur.rchild = node
                    return
                else:
                    # 如果左右子树都不为空，加入队列继续判断
                    queue.append(cur.lchild)
                    queue.append(cur.rchild)

    def breadth_travel(self):
        """广度遍历利用队列实现树的层次遍历"""
        if self.root == None:
            return
        queue = []
        queue.append(self.root)
        while queue:
            node = queue.pop(0)
            print(node.elem,end='')
            if node.lchild != None:
                queue.append(node.lchild)
            if node.rchild != None:
                queue.append(node.rchild)

    # 深度遍历：前序 中序 后序
    def preorder(self,node):
        # 前序 根node 左 右
        if node is None:
            return
        print(node.elem,end='')
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    def inorder(self,node):
        if node is None:
            return
        self.inorder(node.lchild)
        print(node.elem,end='')
        self.inorder(node.rchild)

    def postorder(self,node):
        if node is None:
            return
        self.postorder(node.lchild)
        self.postorder(node.rchild)
        print(node.elem,end='')



if __name__ == '__main__':
    tree = Tree()
    tree.add(0)
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.add(6)
    tree.add(7)
    tree.add(8)
    tree.add(9)
    # tree.breadth_travel()
    # print(' ')
    tree.preorder(tree.root)
    print(' ')
    # tree.inorder(tree.root)
    # print(' ')
    # tree.postorder(tree.root)

3.二分查找

def binary_search(alist,item):
    '''二分查找:递归,每次传入新列表'''
    n = len(alist)
    if n > 0:# 递归终止条件
        mid = n//2
        if alist[mid] == item:
            return True
        elif item<alist[mid]:
            return binary_search(alist[:mid],item)
        else:
            return binary_search(alist[mid+1:],item)
    return False

def binary_search_2(alist,item):
    """二分查找：非递归，在原列表上操作，利用索引"""
    n = len(alist)
    first = 0
    last = n-1
    while first <= last:
        mid = (first+last)//2
        if alist[mid] == item:
            return True
        elif item<alist[mid]:
            last=mid-1
        else:
            first=mid+1
    return False


if __name__ == '__main__':
    li = [17,20,26,31,44,54,55,77,95]
    print(binary_search_2(li,55))
    print(binary_search_2(li,57))

4.快速排序

def quick_sort(alist,first,last):
    """快排1"""
    if first >= last:
        return
    mid_value = alist[first] # 第一个值设为第一个值
    low = first
    high = last
    while low<high:  #退出时 low=high
        # high左移，把相等的情况都放在一边处理
        while low<high and alist[high]>=mid_value:
            high -= 1
        alist[low]=alist[high]
        # low+=1
        # low右移
        while low<high and alist[low]<mid_value:
            low+=1
        alist[high]=alist[low]
        high -= 1
    alist[low]=mid_value
    # 分层两个序列alist[:low-1] alist[low+1:]
    # 调用函数自身，要对整个列表操作
    # low左边
    quick_sort(alist,first=first,last=low-1)  # 这里low-1等于函数里的last ,与下面输入的last不同
    # low右边
    quick_sort(alist,first=low+1,last=last) # 这里的low+1等于函数里的first
if __name__ == '__main__':
    li = [54,26,93,17,77,31,44,55]
    quick_sort(li,0,len(li)-1)
    print(li)

5.插入排序

def insert_sort(alist):
    n=len(alist)
    # 从右边无序序列中取多少个执行,除过第一个不执行
    for j in range(1,n): #n
        # i代表内层循环起始值
        # 假设第一个元素有序，从第二个元素开始
        i = j # 从右边无序序列中取第一个元素 i位置的元素插入到前面正确位置。
        while i>0 : # n
            if alist[i]<alist[i-1]:
                alist[i],alist[i-1]=alist[i-1],alist[i]
                i  -= 1
            else:#  加上else是优化。。。。。最优：假设本来就有序，内层复杂度为1，外层为n
                break

if __name__ == '__main__':
    li = [54,26,93,17,77,31,44,55,20]
    print(li)
    insert_sort(li)
    print(li)

6.选择排序

def select_sort(alist):
    n = len(alist)
    for j in range(n-1):
        # j:0~n-2
        min_list=j  #索引
        for i in range(j+1,n): # n 是长度
            if alist[min_list] > alist[i]:
                min_list=i
        alist[j],alist[min_list] = alist[min_list],alist[j]

if __name__ == '__main__':
    li = [54,26,84,24,15]
    select_sort(li)
    print(li)

7.时间装饰器

import time
def time_deco(func):
    def wrapper(*args,**kwargs):
        start_time = time.time()
        func(*args,**kwargs)
        time_end=time.time()
        print('运行时间为：',time_end-start_time)
    return wrapper

8.希尔排序

def shell_sort(alist):
    """希尔排序"""
    n = len(alist)
    gap = n//2 # 步长

    while gap>0:
        # Gap变化到0时退出
        for j in range(gap,n):
            i=j
            while i>0:
                # 与插入算法的区别是gap步长不是1
                if alist[i]<alist[i-gap]:
                    alist[i],alist[i-gap]=alist[i-gap],alist[i]
                    i -= gap
                else:
                    break
        gap //=2  # 步长减半，直到最后一次gap=1,