Python-0（常用排序算法）

试用新学的python实现下几个常用的排序算法，算法具体思路参考 这里，下面就不具体描述了

测试部分代码先贴上

arr = []
for i in range(50):
    arr.append(random.randint(500))
    pass
print(arr)
# popSort(arr)
# insert(arr)
# select(arr)
# shell(arr)
# quick(arr)
# merge(arr)
# heap(arr)
radix(arr)
print(arr)

冒泡排序

def popSort(arr):
    for i in range(arr.__len__() - 1):
        if arr[i] > arr[i + 1]:
            arr[i], arr[i + 1] = arr[i + 1], arr[i]
            pass
    pass

插入排序

def insert(arr):
    for i in range(1, arr.__len__()):
        temp = i
        while arr[temp] < arr[temp - 1] and temp > 0:
            arr[temp], arr[temp - 1] = arr[temp - 1], arr[temp]
            temp = temp - 1
            pass
        pass
    pass

选择排序

def select(arr):
    for i in range(0, arr.__len__() - 1):
        index = i
        for j in range(i + 1, arr.__len__()):
            if arr[j] < arr[index]:
                index = j
                pass
            pass
        arr[i], arr[index] = arr[index], arr[i]
        pass
    pass

希尔排序

def shell(arr):
    step = arr.__len__() // 2
    while step >= 1:
        for i in range(step, arr.__len__()):
            j = i
            while j - step >= 0:
                if arr[j] < arr[j - step]:
                    arr[j], arr[j - step] = arr[j - step], arr[j]
                    pass
                else:
                    break
                j = j - step
                pass
            pass
        step = step // 2
        pass
    pass

快速排序

def quick(arr):
    quickSort(arr, 0, arr.__len__() - 1)
    pass
    
# 类似于java的重载，外部调用上面一个方法更加方便
def quickSort(arr, start, end):
    if start < end:
        left = start + 1
        right = end
        while left < right:
            while arr[right] >= arr[start] and right > start:
                right = right - 1
                pass
            while arr[left] <= arr[start] and left < right:
                left = left + 1
                pass
            if left < right:
                arr[left], arr[right] = arr[right], arr[left]
                pass
            pass
        # 防止当前分组只有2个元素时，start位置和right位置直接互换
        if arr[start] > arr[right]: 
            arr[start], arr[right] = arr[right], arr[start]
        quickSort(arr, start, right - 1)
        quickSort(arr, right + 1, end)
        pass
    pass

归并排序

def merge(arr):
    mergeSort(arr, 0, arr.__len__() - 1)
    pass
    
# 伪“重载” 
def mergeSort(arr, start, end):
    if start < end:
        mergeSort(arr, start, (start + end) // 2)
        mergeSort(arr, (start + end) // 2 + 1, end)
        pass
    temp = []
    index1 = start
    index2 = (start + end) // 2 + 1
    while index1 <= (start + end) // 2 and index2 <= end:
        if arr[index1] < arr[index2]:
            temp.append(arr[index1])
            index1 = index1 + 1
            pass
        else:
            temp.append(arr[index2])
            index2 = index2 + 1
            pass
        pass
    if index1 > (start + end) // 2 and index2 <= end:
        for i in range(index2, end + 1):
            temp.append(arr[i])
            pass
        pass
    else:
        for i in range(index1, (start + end) // 2 + 1):
            temp.append(arr[i])
            pass
    arr[start:end + 1] = temp
    pass

堆排序

def heap(arr):
    maxSize = arr.__len__() - 1
    while maxSize > 1:
        i = (maxSize - 1) // 2
        while i >= 0:
            adjust(arr, i, maxSize)
            i = i - 1
            pass
        arr[0], arr[maxSize] = arr[maxSize], arr[0]
        maxSize = maxSize - 1
        pass
    # 这里就不考虑只有一个元素的情况了
    if arr[0] > arr[1]:
        arr[0], arr[1] = arr[1], arr[0]
    pass
    
# 将数组调整为大顶堆
def adjust(arr, i, maxSize):
    temp = arr[i]
    j = i * 2 + 1
    while j <= maxSize:
        if j + 1 <= maxSize and arr[j] < arr[j + 1]:
            j = j + 1
            pass
        if arr[j] > arr[i]:
            arr[i] = arr[j]
            i = j
            pass
        else:
            break
        j = j * 2 + 1
        pass
    arr[i] = temp
    pass

基数排序

def radix(arr):
    bucket = []
    for i in range(10):
        bucket.append(Queue())
        pass
    # range()左闭右开，所有一定要+1
    for i in range(1, getMaxTime(arr)+1):
        for j in arr:
            num = j % 10 ** i // 10 ** (i - 1)
            bucket[num].push(j)
            pass
        index = 0
        for k in bucket:
            while k.hasNext():
                arr[index] = k.pop()
                index = index + 1
                pass
            pass
        pass
    pass
    
# 获取数组中的最大位数，确定循环次数
def getMaxTime(arr):
    max = arr[0]
    for i in range(1, arr.__len__()):
        if arr[i] > max:
            max = arr[i]
            pass
        pass
    size = 0
    while 10 ** size <= max:
        size = size + 1
        pass
    return size
    pass
    
# 没想到Python中用什么来实现队列，简单实现一个队列
class Queue:
    top = None

    def push(self, data):
        if self.top == None:
            self.top = Node(data)
            pass
        else:
            index = self.top
            while index.next != None:
                index = index.next
                pass
            index.next = Node(data)
            pass
        pass

    def pop(self):
        if self.top == None:
            return Node
        else:
            temp = self.top.data
            self.top = self.top.next
            return temp
        pass

    def hasNext(self):
        return self.top != None
    
# 队列节点类
class Node:
    data = 0
    next = None

    def __init__(self, data):
        self.data = data
        pass
    pass