使用c++语言，随机产生1000-10000个数，分别用希尔排序、快速排序、归并排序和基数排序方法进行排序，

好的，我来为您解答。

首先，我们需要随机产生1000-10000个数。可以使用C++的随机数生成器，具体代码如下：

#include <iostream>
#include <random>
using namespace std;

int main() {
    int n = rand() % 9001 + 1000; // 随机生成1000-10000之间的数
    int a[n];
    srand(time(NULL)); // 初始化随机数种子
    for(int i = 0; i < n; i++){
        a[i] = rand() % 10001; // 随机生成0-10000之间的数
    }
    return 0;
}

接下来，我们来实现四种排序算法。

1. 希尔排序

希尔排序是一种插入排序的变种，它通过将待排序列分割成若干个子序列来提高排序效率。具体实现如下：

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

2. 快速排序

快速排序是一种基于分治思想的排序算法，它通过递归地将待排序列分成两部分来实现排序。具体实现如下：

void quickSort(int a[], int left, int right){
    if(left >= right) return;
    int i = left, j = right, pivot = a[left];
    while(i < j){
        while(i < j && a[j] >= pivot) j--;
        a[i] = a[j];
        while(i < j && a[i] <= pivot) i++;
        a[j] = a[i];
    }
    a[i] = pivot;
    quickSort(a, left, i - 1);
    quickSort(a, i + 1, right);
}

3. 归并排序

归并排序是一种基于分治思想的排序算法，它通过递归地将待排序列分成若干个子序列，然后将这些子序列两两合并来实现排序。具体实现如下：

void merge(int a[], int left, int mid, int right){
    int n1 = mid - left + 1, n2 = right - mid;
    int L[n1], R[n2];
    for(int i = 0; i < n1; i++){
        L[i] = a[left + i];
    }
    for(int i = 0; i < n2; i++){
        R[i] = a[mid + 1 + i];
    }
    int i = 0, j = 0, k = left;
    while(i < n1 && j < n2){
        if(L[i] <= R[j]){
            a[k++] = L[i++];
        }else{
            a[k++] = R[j++];
        }
    }
    while(i < n1){
        a[k++] = L[i++];
    }
    while(j < n2){
        a[k++] = R[j++];
    }
}

void mergeSort(int a[], int left, int right){
    if(left >= right) return;
    int mid = (left + right) / 2;
    mergeSort(a, left, mid);
    mergeSort(a, mid + 1, right);
    merge(a, left, mid, right);
}

4. 基数排序

基数排序是一种非比较排序算法，它通过将待排序列按照每一位的大小进行排序来实现排序。具体实现如下：

void radixSort(int a[], int n){
    int maxNum = a[0];
    for(int i = 1; i < n; i++){
        maxNum = max(maxNum, a[i]);
    }
    int exp = 1;
    while(maxNum / exp > 0){
        int bucket[10] = {0};
        for(int i = 0; i < n; i++){
            bucket[(a[i] / exp) % 10]++;
        }
        for(int i = 1; i < 10; i++){
            bucket[i] += bucket[i - 1];
        }
        int temp[n];
        for(int i = n - 1; i >= 0; i--){
            temp[--bucket[(a[i] / exp) % 10]] = a[i];
        }
        for(int i = 0; i < n; i++){
            a[i] = temp[i];
        }
        exp *= 10;
    }
}

最后，我们可以在主函数中调用这些排序算法来对随机生成的数进行排序：

int main() {
    int n = rand() % 9001 + 1000; // 随机生成1000-10000之间的数
    int a[n];
    srand(time(NULL)); // 初始化随机数种子
    for(int i = 0; i < n; i++){
        a[i] = rand() % 10001; // 随机生成0-10000之间的数
    }
    shellSort(a, n); // 希尔排序
    quickSort(a, 0, n - 1); // 快速排序
    mergeSort(a, 0, n - 1); // 归并排序
    radixSort(a, n); // 基数排序
    return 0;
}

希望能对您有所帮助！