总结 插入、选择、冒泡、快速、合并和堆排序 6种排序的算法（使用文字描述或伪代码、流程图的方式均可

1. 插入排序算法：
- 从第二个元素开始，将其与前一个元素进行比较，如果前一个元素较大，则交换它们的位置，再继续与前面的元素进行比较，直到找到合适的位置插入该元素。
- 重复以上步骤，直到所有元素都被插入到正确的位置。

伪代码：

for i = 1 to n
    j = i
    while j > 0 and arr[j-1] > arr[j]
        swap arr[j] and arr[j-1]
        j = j - 1

2. 选择排序算法：
- 首先在未排序的序列中找到最小的元素，将其放在序列的起始位置。
- 然后，在剩余的元素中继续寻找最小的元素，将其放在已排序序列的末尾。
- 重复以上步骤，直到所有元素都被排序。

伪代码：

for i = 0 to n-1
    min_index = i
    for j = i+1 to n
        if arr[j] < arr[min_index]
            min_index = j
    swap arr[i] and arr[min_index]

3. 冒泡排序算法：
- 从序列的起始位置开始，比较相邻的两个元素，如果它们的顺序不正确，则交换它们的位置。
- 重复以上步骤，直到所有元素都被排序。

伪代码：

for i = 0 to n-1
    for j = 0 to n-i-1
        if arr[j] > arr[j+1]
            swap arr[j] and arr[j+1]

4. 快速排序算法：
- 选取序列中的一个元素作为基准值，将序列分为两部分，一部分包含所有小于基准值的元素，另一部分包含所有大于基准值的元素。
- 对于这两个部分，分别递归地应用快速排序算法。
- 重复以上步骤，直到所有元素都被排序。

伪代码：

function quicksort(arr, left, right)
    if left < right
        pivot_index = partition(arr, left, right)
        quicksort(arr, left, pivot_index-1)
        quicksort(arr, pivot_index+1, right)

function partition(arr, left, right)
    pivot = arr[right]
    i = left-1
    for j = left to right-1
        if arr[j] < pivot
            i = i+1
            swap arr[i] and arr[j]
    swap arr[i+1] and arr[right]
    return i+1

5. 合并排序算法：
- 将序列分为两个部分，对于每个部分，递归地应用合并排序算法。
- 将两个已排序的部分合并成一个有序的序列。
- 重复以上步骤，直到所有元素都被排序。

伪代码：

function mergesort(arr)
    if length(arr) <= 1
        return arr
    mid = length(arr) / 2
    left = mergesort(arr[1...mid])
    right = mergesort(arr[mid+1...length(arr)])
    return merge(left, right)

function merge(left, right)
    result = []
    i = 0
    j = 0
    while i < length(left) and j < length(right)
        if left[i] < right[j]
            result.append(left[i])
            i = i + 1
        else
            result.append(right[j])
            j = j + 1
    result.append(left[i...length(left)])
    result.append(right[j...length(right)])
    return result

6. 堆排序算法：
- 构建一个最大堆或最小堆，将序列中的元素依次插入堆中。
- 从堆顶依次取出堆中的元素，直到堆为空。
- 重复以上步骤，直到所有元素都被排序。

伪代码：

function heapsort(arr)
    build_max_heap(arr)
    for i = length(arr)-1 to 1
        swap arr[0] and arr[i]
        heapify(arr, 0, i-1)

function build_max_heap(arr)
    for i = floor(length(arr)/2) downto 0
        heapify(arr, i, length(arr)-1)

function heapify(arr, i, max_index)
    left_child = 2*i + 1
    right_child = 2*i + 2
    largest = i
    if left_child <= max_index and arr[left_child] > arr[largest]
        largest = left_child
    if right_child <= max_index and arr[right_child] > arr[largest]
        largest = right_child
    if largest != i
        swap arr[i] and arr[largest]
        heapify(arr, largest, max_index)