如何利用Python动态展示排序算法

#x为待排序列表，N=len(x)
#选择排序
for i in range(N):
    iMax = i
    for j in range(i, N):
        if(x[j]>x[iMax]):
            iMax = j
    x[iMax],x[i] = x[i],x[iMax]

#冒泡排序
tempN = N-1
for i in range(tempN):
    for j in range(0, tempN-i):
        if(x[j]>x[j+1]):
            x[j],x[j+1] = x[j+1],x[j]

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation 

start,end,N = 10,100,9
x = np.random.randint(start, end, size=N)
Index = np.arange(N)
xs = []
nowIndex = []

for i in range(N):
    iMax = i
    for j in range(i, N):
        xs.append(x*1)      #存储当前顺序，用于绘图
        nowIndex.append([i,j,iMax]) #存储当前的i,j,max位置，用于绘图
        if(x[j]>x[iMax]):
            iMax = j
            xs.append(x*1)
            nowIndex.append([i,j,iMax])
    x[iMax],x[i] = x[i],x[iMax]

fig, ax = plt.subplots()
colors = np.repeat('g',N)
colors[0] = 'b'
bar = ax.bar(Index,x,color=colors)

def animate(n):
    data = xs[n]
    colors = np.repeat('gray',N)
    colors[nowIndex[n]] = 'b','g','r'
    ax.clear()
    bar = ax.bar(Index, data, color=colors)
    return bar

ani = animation.FuncAnimation(fig, animate, 
    range(len(xs)), interval=500, repeat=False, blit=True)
plt.show()
ani.save("sort.gif")

for i in range(1,N):
    j = i-1
    temp = x[i]
    while(x[i]<x[j] and j>=0):
        x[j+1] = x[j]
        j -= 1
    x[j+1] = temp

def Merge(X, Y):
    nL,nR = len(X), len(Y)
    iterL,iterR = 0,0
    xNew = []
    for _ in range(nL+nR):
        if(iterL==nL): return xNew + Y[iterR:]
        if(iterR==nR): return xNew + X[iterL:]
        if(X[iterL]<Y[iterR]):
            xNew.append(X[iterL])
            iterL += 1
        else:
            xNew.append(Y[iterR])
            iterR += 1
    return xNew

def MergeSort(x):
    if len(x)==1:
        return x
    if len(x)==2:
        return x if x[0]<x[1] else [x[1],x[0]]
    nL = len(x)//2
    return Merge(MergeSort(x[:nL]),
                 MergeSort(x[nL:]))

def Merge(X, nL):
    nR = len(X)-nL
    XL,XR = X[:nL]*1,X[nL:]*1
    iterL,iterR = 0,0
    for i in range(nL+nR):
        if(iterL==nL): break
        if(iterR==nR): 
            X[i:] = XL[iterL:]
            return
        if(XL[iterL]<XR[iterR]):
            X[i] = XL[iterL]
            iterL += 1
        else:
            X[i] = XR[iterR]
            iterR += 1

def MergeSort(X):
    if len(X)<2:
        return
    nL = len(X)//2
    MergeSort(X[:nL])
    MergeSort(X[nL:])
    Merge(X,nL)

def shellSort(arr):
    n = len(arr)
    nSub = n//2
    while nSub>0:
        for i in range(nSub,n):
            temp = arr[i]
            j = i-nSub
            while j>=0 and temp<arr[j]:
                arr[j+nSub] = arr[j]
                j -= nSub
            arr[j+nSub] = temp
        nSub //= 2