python之排序

# 冒泡排序:就是从零位开始，临位比较，较大的放后面
# 第一轮，把最大的排出来了。第二轮，把第二大的排出来了，.......a
a = [3,5,1,0,4,9,2,-1]
for j in range(1,len(a)):
    for i in range(0,len(a)-j):
        if a[i] > a[i+1]:
            a[i],a[i+1]= a[i+1],a[i]

print(a)


# 选择排序：从头至尾扫描序列，找出最小的一个元素，和第一个元素交换，接着从剩下的元素中继续这种选择和交换方式，最终得到一个有序序列。
# 选择排序是一种不稳定的算法，[5 8 5 2 9]，中两个相等元素5的顺序乱了，而冒泡排序就不会乱，因此冒泡排序稳定
a = [3,5,1,0,4,9,2,-1]
for i in range(0,len(a)-1):
    for j in range(i+1,len(a)):
        if a[i]>a[j]:
            a[i],a[j] = a[j],a[i]

print(a)

# 插入排序：对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入
# 插入排序需要注意的是：每一个元素跟前一个比较后,如果小于前面的元素,前面的元素加1，前面元素的位置由该元素占据（因此要把当前元素拿出来作为cur）
a = [3,5,1,0,4,9,2,-1]

for i in range(1,len(a)):
    cur = a[i]
    for j in range(i-1,-1,-1):
        if cur>a[j]:
            break
        else:
            a[j+1]= a[j]
            a[j]=cur


print(a)

# 堆排序： 优先队列排序
def heapify(arr,n,i):
    largest = i
    l = 2*i + 1
    r = 2*i + 2
    if l<n and arr[i] < arr[l]:
        largest = l
    if r<n and arr[r] > arr[largest]:
        largest = r
    if largest != i:
        arr[i],arr[largest] = arr[largest], arr[i]
        heapify(arr,n,i)
def heapsort(arr):
    n = len(arr)
    # 要从后往前遍历，不能从前往后遍历，
    # 因为，从前往后遍历，会导致这么一种情况：第一次与第二层下沉好了后，第二层都小于第一层，但是当第二层下沉时候，从第三层上浮到第二层的就
    # 可能比第一层大。
    # 而从后面遍历，就不会出现这种问题
    for i in range(n,-1,-1):
        heapify(arr,n,i)

    for i in range(n-1,0,-1):
        arr[i],arr[0]=arr[0],arr[i]
        heapify(arr,i,0)

a = [3,5,1,0,4,9,2,-1]
heapsort(a)
print(a)

# 希尔排序
a = [3,1,5,4,2,0]
h = len(a)/2

for i in range(0,h):
    if a[i]>a[h+i]:
        a[i],a[h+i] = a[h+i],a[i]
print a

def chr(a):
    for i in range(1,len(a)):
        cur = a[i]
        for j in range(i,-1,-1):
            if cur < a[j]:
                a[j+1] = a[j]
                a[j] = cur
            else:
                pass
    return a

c= chr(a)
print c