输入数据: 8 7 0 10 2 1 运行结果: 0 1 2 7 8 10

好的，那我们就以整数为待排序记录，并以您提供的数据为例，分别演示这些排序算法的实现方法和对应的代码：

1. 直接插入排序

直接插入排序的基本思想是：将待排序的记录插入到已经排好序的记录序列中，从而得到一个新的、记录数增加1的有序序列。

示例代码如下：

#include <iostream>
using namespace std;

void insert_sort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

int main() {
    int arr[] = {8, 7, 0, 10, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    insert_sort(arr, n);
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

2. 希尔排序

希尔排序是直接插入排序的改进版，它利用了分组插入排序的思想，先将待排序的记录分割成若干组，对每一组进行直接插入排序，然后逐步减小分组的跨度，直至跨度为1，完成排序。

示例代码如下：

#include <iostream>
using namespace std;

void shell_sort(int arr[], int n) {
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int key = arr[i];
            int j = i - gap;
            while (j >= 0 && arr[j] > key) {
                arr[j + gap] = arr[j];
                j -= gap;
            }
            arr[j + gap] = key;
        }
    }
}

int main() {
    int arr[] = {8, 7, 0, 10, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    shell_sort(arr, n);
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

3. 快速排序

快速排序的基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后分别对这两部分记录继续进行排序，直到整个序列有序为止。

示例代码如下：

#include <iostream>
using namespace std;

int partition(int arr[], int low, int high) {
    int pivot = arr[low];
    while (low < high) {
        while (low < high && arr[high] >= pivot) high--;
        arr[low] = arr[high];
        while (low < high && arr[low] <= pivot) low++;
        arr[high] = arr[low];
    }
    arr[low] = pivot;
    return low;
}

void quick_sort(int arr[], int low, int high) {
    if (low < high) {
        int pivot_pos = partition(arr, low, high);
        quick_sort(arr, low, pivot_pos - 1);
        quick_sort(arr, pivot_pos + 1, high);
    }
}

int main() {
    int arr[] = {8, 7, 0, 10, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    quick_sort(arr, 0, n - 1);
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

4. 冒泡排序

冒泡排序的基本思想是：将待排序的记录按照关键字的大小进行两两比较和交换，使关键字较小的记录逐渐从前往后移动，直到整个序列有序为止。

示例代码如下：

#include <iostream>
using namespace std;

void bubble_sort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
            }
        }
    }
}

int main() {
    int arr[] = {8, 7, 0, 10, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, n);
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

5. 堆排序

堆排序的基本思想是：将待排序记录构建成一个二叉堆，然后将堆顶记录（即最大记录）与堆底记录交换，再将剩余的记录重新调整为二叉堆，重复此过程直到整个序列有序为止。

示例代码如下：

#include <iostream>
using namespace std;

void adjust_heap(int arr[], int i, int n) {
    int child = 2 * i + 1;
    int temp = arr[i];
    while (child < n) {
        if (child + 1 < n && arr[child] < arr[child + 1]) {
            child++;
        }
        if (arr[child] > temp) {
            arr[i] = arr[child];
            i = child;
            child = 2 * i + 1;
        } else {
            break;
        }
    }
    arr[i] = temp;
}

void heap_sort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--) {
        adjust_heap(arr, i, n);
    }
    for (int i = n - 1; i >= 1; i--) {
        swap(arr[0], arr[i]);
        adjust_heap(arr, 0, i);
    }
}

int main() {
    int arr[] = {8, 7, 0, 10, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    heap_sort(arr, n);
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

6. 选择排序

选择排序的基本思想是：在待排序序列中选择一个最小的记录，将其与序列的第一个记录交换，然后在剩下的记录中选择一个最小的记录，将其与序列的第二个记录交换，如此重复，直到整个序列有序为止。

示例代码如下：

#include <iostream>
using namespace std;

void select_sort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int min_idx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }
        swap(arr[i], arr[min_idx]);
    }
}

int main() {
    int arr[] = {8, 7, 0, 10, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    select_sort(arr, n);
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

7. 基数排序

基数排序的基本思想是：将待排序的记录按照各个位上的数字来进行分配和收集，从而得到一个有序序列。

示例代码如下：

#include <iostream>
#include <queue>
#include <cmath>
using namespace std;

void radix_sort(int arr[], int n) {
    int max_num = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > max_num) {
            max_num = arr[i];
        }
    }
    int max_digit = static_cast<int>(log10(max_num)) + 1;

    queue<int> buckets[10];
    int radix = 1;
    for (int i = 0; i < max_digit; i++) {
        for (int j = 0; j < n; j++) {
            int digit = arr[j] / radix % 10;
            buckets[digit].push(arr[j]);
        }
        int idx = 0;
        for (int j = 0; j < 10; j++) {
            while (!buckets[j].empty()) {
                arr[idx++] = buckets[j].front();
                buckets[j].pop();
            }
        }
        radix *= 10;
    }
}

int main() {
    int arr[] = {8, 7, 0, 10, 2, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    radix_sort(arr, n);
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    return 0;
}

以上就是这7种排序算法的实现方法和示例代码，希望能够帮助到您。