python--数据结构--简单快速排序、堆排序

# select_type_sort.py
from collections import deque
from typing import List


class Record:
    def __init__(self, key):
        self.key = key
        self.other_info = None


class Records:
    def __init__(self, record_list: List[Record]):
        self.record_list = deque([None])
        self.record_list.extend(record_list)
        self.record_len = len(self.record_list)-1
        self.other_info = None


def select_sort(records: Records):
    """
    简单选择排序

    与冒泡排序比较，避免了每趟找最值时进行多次交换

    :param records: 待排序的记录数组对象
    :return: 已排好序的记录数组对象
    """
    for i in range(records.record_len, 1, -1):
        k = i
        for j in range(1, i):
            if records.record_list[k].key < records.record_list[j].key:
                k = j
        if k != i:
            records.record_list[i], records.record_list[k] = records.record_list[k], records.record_list[i]
    return records


def sift(records: Records, k, m):
    """
    假设records.record_list[k...m]是以records.record_list[k]为根的完全二叉树，且分
    别以records.record_list[2k]和records.record_list[2k+1]为根的左右子树为大根堆，
    调整records.record_list[k]，使整个序列ecords.record_list[k...m]满足堆的性质

    :param records:
    :param k:
    :return:
    """
    t = records.record_list[k]  # 暂存“根”记录records.record_list[k]，因在重建根的过程中records.record_list[k]可能被覆盖
    x = t.key  # 暂存“根”的关键字，用于重建根过程中进行比较
    i = k  # 在重建根的过程中i一直指向当前根
    j = i << 1  # 获取当前根的左孩子位置
    finished = False  # 标记重建堆过程是否完成
    while j <= m and not finished:
        # j不能溢出且直到重建堆过程完成为止
        if j < m and records.record_list[j].key < records.record_list[j+1].key:
            # 若存在右子树，且右子树根的关键字大，则沿右分支“筛选”
            j = j + 1
        if x >= records.record_list[j].key:
            finished = True  # 筛选完毕
        else:
            # 继续筛选
            records.record_list[i] = records.record_list[j]
            i = j
            j = i << 1
    records.record_list[i] = t  # records.record_list[k]填入到恰当的位置


def crt_heap(records: Records):
    """
    建初堆

    :param records: 待建初堆的记录数组对象
    :return: 返回建好的初堆
    """
    n = records.record_len
    for i in range(n >> 1, 0, -1):  # 自第⌊n/2⌋个记录开始进行筛选建堆
        sift(records, i, n)
    return records


def heap_sort(records: Records):
    """
    堆排序

    对records.record_list[1...record.record_len]进行堆排序，执行本算法后，r中记录按关键字由大到小有序排序
    :param records:
    :return:
    """
    crt_heap(records)
    for i in range(records.record_len, 1, -1):
        records.record_list[i], records.record_list[1] = records.record_list[1], records.record_list[i]  # 将堆顶记录和堆中最后一个记录互换
        sift(records, 1, i-1)  # 进行调整，使records.record_list[1...i-1]变成堆
    return records

# test_seclect_type_sort.py
from select_type_sort import Record, Records, select_sort, crt_heap, heap_sort


# 测试select_sort
records = Records([Record(key) for key in [48, 62, 39, 77, 55, 14, 35, 98]])
records = select_sort(records)
print([record.key for record in records.record_list if record])

# 测试crt_heap
records = Records([Record(key) for key in [48, 62, 35, 77, 55, 14, 35, 98]])
records = crt_heap(records)
print([record.key for record in records.record_list if record])

# 测试heap_sort
records = Records([Record(key) for key in [48, 62, 35, 77, 55, 14, 35, 98]])
records = heap_sort(records)
print([record.key for record in records.record_list if record])


"""
运行结果：
[14, 35, 39, 48, 55, 62, 77, 98]
[98, 77, 35, 62, 55, 14, 35, 48]
[14, 35, 35, 48, 55, 62, 77, 98]

Process finished with exit code 0
"""

[引用 《数据结构–用C语言描述 耿国华版》]