不同排序算法的简单实现-python版

1. 冒泡排序
   相邻两个元素比较，较大的的置后，每次比较位置不对都要互换;
   设置flag，如果某一轮的flag没变则已经是有序数组，跳出;
   相同元素的位置不会改变，所以稳定。

def bubble_sort(a):
    for i in range(len(a)):
        flag = 1
        for j in range(0, len(a)-i-1):
            if a[j]>a[j+1]:
                flag = 0
                a[j], a[j+1] = a[j+1], a[j]
        if flag:
            break
    return a

2. 选择排序
   每次比较后选出的元素都是数组后面部分最小的元素(即后部分的首元素一直与后面元素比较记录较小元素的 位置，最后互换)；
   每轮比较最多只换一次位置；
   相等元素位置可能互换，造成排序的不稳定，比如：[5,8,5,2,9]两个五的顺序会打乱。

def selection_sort(a):
    for i in range(len(a)):
        tmp = i 
        for j in range(i, len(a)):
            if a[j]<a[tmp]:
                tmp = j
        if tmp!=i:
            a[i], a[tmp] = a[tmp], a[i]
    return a 

3. 插入排序
   逐个与数组前面排好序的元素比较后互换；
   可见相等元素比较时，原来靠后的还是拍在后边，所以插入排序是稳定的。
   下面是两种不同的实现方法：

def insertion_sort(a):
    for i in range(1, len(a)):
        for j in range(0, i):
            if a[i]<a[j]:
                a[i], a[j] = a[j], a[i]
    return a


def insertion_sort2(a):
    for i in range(1, len(a)):
        tmp = a[i]
        for j in range(0, i):
            if a[i]<a[j]:
                del a[i] #先删除后排序
                a.insert(j, tmp)
                break
    return a

4. 快速排序
   快排以基数为基准进行交换使排序成为不稳定的。

#递归版
def quick_sort(a, left, right):
    if not a or left<0 or right<=0 or left>=right:#left>=right:只有一个数的时候没必要再分割比较
        return
    i = left
    j = right
    mid = a[left]
    while(i!=j):
        while(i<j and a[j]>mid):#右边先动，保证相遇时的数比基数小
            j -= 1
        while(i<j and a[i]<=mid):
            i += 1
        if (i<j):
            a[i], a[j] = a[j], a[i]
    a[left], a[i] = a[i], a[left]
    quick_sort(a, left, i-1)
    quick_sort(a, i+1, right)
    return a

#非递归版
def quick_sort(a, left, right):
    if not a or left<0 or right<=0 or left>=right:
        return a 
    temp = []
    temp.append(right)
    temp.append(left)
    while(temp):
        i = temp.pop()
        j = temp.pop()
        if(i<j):
            mid = a[i]
            left = i 
            right = j
            while(left!=right):
                while(left<right and a[right]>mid):
                    right -= 1
                while(left<right and a[left]<=mid):
                    left += 1
                if (left<right):
                    a[right], a[left] = a[left], a[right]
            a[i], a[right] = a[right], a[i]            
            if(right>i):
                temp.append(right-1)
                temp.append(i)
            if(j>right):
                temp.append(j)
                temp.append(right+1)
    return a

5. 归并排序
   归并算法需要两两比较，不存在跳跃，因此归并排序是一种稳定的排序算法。

#递归版
def merge_sort(a):
    if len(a)<=1:
        return a 
    mid = len(a)//2
    left = merge_sort(a[:mid])
    right = merge_sort(a[mid:])
    temp = []
    i=j=0
    while (i<len(left) and j<len(right)):
        if left[i]<right[j]:
            temp.append(left[i])
            i += 1
        else:
            temp.append(right[j])
            j += 1
    if i<len(left):
        temp += left[i:]
    elif j<len(right):
        temp += right[j:]
    return temp
 
#非递归版（效率比较低）
def merge_sort(a):
    for i in [2**j for j in range(len(a)) if 2**j<=len(a)]: #步长以2的指数增长
        print(i)
        index = 0
        while(index+2*i<=len(a)): 
            index += 2*i    
            merge(a, index-2*i, index-i, index) 
        if index+i<len(a): #对剩余部分排序
            merge(a, index, index+i, len(a))
    return a 

def merge(a, left, mid, right):
    i = left
    j = mid
    temp = []
    while(i<mid and j<right):
        if a[i]<a[j]:
            temp.append(a[i])
            i += 1
        else:
            temp.append(a[j])
            j += 1
    if i<mid:
        temp += a[i:mid]
    elif j<right:
        temp += a[j:right]
    for j,i in enumerate(range(left, right)): #只能先保存后一个个替换
        a[i] = temp[j]
    return

6. 二叉树排序
   先利用待排序数组构建二叉搜索树，再利用中序遍历对数据进行排序

class Node():
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Tree():
    def __init__(self):
        self.root = None

    def sort_tree(self, x):
        node = Node(x)
        if not self.root:
            self.root = node
            return
        p = self.root
        while True:
            if x<=p.val:
                if not p.left:
                    p.left = node 
                    return 
                p = p.left
            elif x>p.val:
                if not p.right:
                    p.right = node 
                    return
                p = p.right
                
    def inorder(self, root):
        if not root:
            return []
        left = self.inorder(root.left)
        res = [root.val]
        right = self.inorder(root.right)
        return left+res+right