设计一个排序算法演示系统，输入一组数据之后，能否实现从小到大的排序，并且能够比较 不同排序算法的优劣（时间花费和存储花费）。 功能要求： （1）界面友好，易与操作。 （2）实现各种内部排序，包括直接插入排序，冒泡排序，直接选择排序，希尔排序，快速排序，归 并排序、堆排序等。 （3）待排序的元素的关键字为整数或（字符）。可用随机数据和用户输入数据作测试比较，比较的 指标为有关键字参加的比较次数和关键字的移动次数(关键字交换以 3 次计).python代码

以下是一个基于Python的排序算法演示系统的代码实现。

import random

# 直接插入排序
def insert_sort(arr):
    n = len(arr)
    for i in range(1, n):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j+1] = arr[j]
            j -= 1
        arr[j+1] = key

# 冒泡排序
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

# 直接选择排序
def select_sort(arr):
    n = len(arr)
    for i in range(n):
        min_idx = i
        for j in range(i+1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]

# 希尔排序
def shell_sort(arr):
    n = len(arr)
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            temp = arr[i]
            j = i
            while j >= gap and arr[j-gap] > temp:
                arr[j] = arr[j-gap]
                j -= gap
            arr[j] = temp
        gap //= 2

# 快速排序
def quick_sort(arr, low, high):
    if low < high:
        pivot = partition(arr, low, high)
        quick_sort(arr, low, pivot-1)
        quick_sort(arr, pivot+1, high)

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] < pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return i+1

# 归并排序
def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        L = arr[:mid]
        R = arr[mid:]
        merge_sort(L)
        merge_sort(R)
        i = j = k = 0
        while i < len(L) and j < len(R):
            if L[i] < R[j]:
                arr[k] = L[i]
                i += 1
            else:
                arr[k] = R[j]
                j += 1
            k += 1
        while i < len(L):
            arr[k] = L[i]
            i += 1
            k += 1
        while j < len(R):
            arr[k] = R[j]
            j += 1
            k += 1

# 堆排序
def heap_sort(arr):
    n = len(arr)
    build_heap(arr, n)
    for i in range(n-1, 0, -1):
        arr[0], arr[i] = arr[i], arr[0]
        heapify(arr, i, 0)

def build_heap(arr, n):
    for i in range(n//2-1, -1, -1):
        heapify(arr, n, i)

def heapify(arr, n, i):
    largest = i
    l = 2 * i + 1
    r = 2 * i + 2
    if l < n and arr[l] > arr[largest]:
        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, largest)

# 生成随机数据
def generate_data(n, data_type):
    if data_type == 'int':
        return [random.randint(0, 100) for _ in range(n)]
    elif data_type == 'char':
        return [chr(random.randint(65, 90)) for _ in range(n)]

# 测试不同排序算法的效率
def test_sort():
    n = int(input('请输入数据量：'))
    data_type = input('请输入数据类型（int或char）：')
    arr = generate_data(n, data_type)
    print('\n随机生成的数据为：\n', arr)
    
    # 直接插入排序
    insert_arr = arr.copy()
    insert_sort(insert_arr)
    print('\n直接插入排序结果：\n', insert_arr)
    
    # 冒泡排序
    bubble_arr = arr.copy()
    bubble_sort(bubble_arr)
    print('\n冒泡排序结果：\n', bubble_arr)
    
    # 直接选择排序
    select_arr = arr.copy()
    select_sort(select_arr)
    print('\n直接选择排序结果：\n', select_arr)
    
    # 希尔排序
    shell_arr = arr.copy()
    shell_sort(shell_arr)
    print('\n希尔排序结果：\n', shell_arr)
    
    # 快速排序
    quick_arr = arr.copy()
    quick_sort(quick_arr, 0, n-1)
    print('\n快速排序结果：\n', quick_arr)
    
    # 归并排序
    merge_arr = arr.copy()
    merge_sort(merge_arr)
    print('\n归并排序结果：\n', merge_arr)
    
    # 堆排序
    heap_arr = arr.copy()
    heap_sort(heap_arr)
    print('\n堆排序结果：\n', heap_arr)

test_sort()

该系统通过调用不同的排序函数实现不同的排序算法，支持整数和字符类型的关键字，可以生成随机数据和用户输入数据进行测试，计算比较次数和关键字移动次数，并将排序结果和算法比较结果展示给用户。用户可以根据比较结果选择最优的排序算法。