#include<stdio.h> #include<time.h> #include<stdlib.h> #define N 1000 void sort(int arr[],int length,int element); int Main() { srand((unsigned)time(NULL)); int arr[N]; int n,i; //输入 FILE *fp; fp=fopen("status.txt","r"); fscanf(fp,"%d",&n); for(i=0;i<n;i++) { fscanf(fp,"%d",&arr[i]); } fclose(fp); //快排 sort(arr,n,arr[0]); //输出 FILE *fpp=fopen("statusprint.txt","w"); for(i=0;i<n;i++) { fprintf(fpp,"%d ",arr[i]); } fclose(fpp); return 0; } void sort(int arr[],int length,int element) { int i,j,k; i=j=k=0; int arr1[N]; int arr2[N]; int flag1,flag2; flag1=flag2=0; for(i=0;i<length;i++) { if(arr[i]<element) { arr1[j++]=arr[i]; } else { arr2[k++]=arr[i]; } } for(i=0;i<j;i++) { if(arr1[i]!=arr1[0]) { flag1=1; break; } } for(i=0;i<k;i++) { if(arr2[i]!=arr2[0]) { flag2=1; break; } } if(j<=1||flag1==0) { ; } else { int rand_j=rand()%(j); sort(arr1,j,arr1[rand_j]); } if(k<=1||flag2==0) { ; } else { int rand_k=rand()%(k); sort(arr2,k,arr2[rand_k]); } int arr1_length=j; j=k=0; for(i=0;i<length;i++) { if(j<arr1_length) { arr[i]=arr1[j++]; } else { arr[i]=arr2[k++]; } } }

这是一个使用快排算法对一个包含随机整数的文件进行排序的 C 语言程序。程序首先从一个名为 "status.txt" 的文件中读取一个整数 n 和 n 个整数，然后使用 sort 函数进行快排，最后将排序后的结果输出到一个名为 "statusprint.txt" 的文件中。

快排函数 sort 的实现使用了分治思想，将数组按照选定的元素（在本程序中是 arr[0]）分成两个子数组，然后对子数组分别进行递归排序。如果子数组的长度小于等于1，或者子数组中的所有元素值都相等，那么就不需要再进行递归排序了，直接返回即可。

在分割数组时，程序会随机选取一个元素作为划分标准，以避免出现最坏情况下的时间复杂度 O(n^2)。

注意，程序中的数组长度 N 很大，如果输入文件中的整数个数超过了 N，程序可能会出现错误。同时，程序中的文件读写操作也没有进行错误检查，可能会导致程序崩溃。

相关问题

改进以下代码#include<stdio.h> #include<stdlib.h> #include<malloc.h> #define ar arr[]={12,21,2,11,10,8} #define ELEM_TYPE int int ar; //顺序表的创建： typedef struct Sqlist { ELEM_TYPE *data; int length; int SIZE; }Sqlist,*PSqlist; //顺序表的初始化： void Init_Sqlist(P

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#define MAXSIZE 100 // 定义最大长度

typedef int ElemType; // 定义元素类型

typedef struct {
ElemType *data; // 动态分配数组
int length; // 当前长度
int maxSize; // 最大长度
} SqList;

// 初始化顺序表
void InitList(SqList *L) {
L->data = (ElemType *) malloc(sizeof(ElemType) * MAXSIZE); // 动态分配数组
L->length = 0; // 初始长度为0
L->maxSize = MAXSIZE; // 最大长度为MAXSIZE
}

// 插入元素
int Insert(SqList *L, int i, ElemType e) {
// i的合法范围为 1 <= i <= L->length + 1
if (i < 1 || i > L->length + 1) {
return 0; // 插入位置不合法
}
if (L->length >= MAXSIZE) {
return 0; // 当前存储空间已满，不能插入新元素
}
for (int j = L->length; j >= i; j--) {
L->data[j] = L->data[j - 1]; // 将第i个元素及之后的元素后移
}
L->data[i - 1] = e; // 插入新元素
L->length++; // 长度加1
return 1;
}

// 删除元素
int Delete(SqList *L, int i) {
// i的合法范围为 1 <= i <= L->length
if (i < 1 || i > L->length) {
return 0; // 删除位置不合法
}
for (int j = i; j < L->length; j++) {
L->data[j - 1] = L->data[j]; // 将第i+1个元素及之后的元素前移
}
L->length--; // 长度减1
return 1;
}

// 输出顺序表
void PrintList(SqList L) {
for (int i = 0; i < L.length; i++) {
printf("%d ", L.data[i]);
}
printf("\n");
}

int main() {
SqList L;
InitList(&L);
Insert(&L, 1, 1);
Insert(&L, 2, 3);
Insert(&L, 3, 5);
PrintList(L);
Delete(&L, 2);
PrintList(L);
return 0;
}

以下是一个通过随机数来测试排序算法运行时间的程序，中间留出了加入排序算法的部分。其中可以通过修改RANDNUM的值来更改测试的数据量： #include <stdio.h> #include <stdlib.h> #include <time.h> #define RANDNUM 10000 //随机数的个数 void main（） { int iRandNum[RANDNUM];//存放随机数 clock_t first，second; //记录开始和结束时间（以毫秒为单位） int i; for（i=0;i<RANDNUM;i++） {//产生1万个随机数 iRandNum[i]=rand（）%RANDNUM; } first=clock（）; //开始时间 //此处加入排序程序 second=clock（）;//结束时间 //显示排序算法所用的时间 } （2） 从选择、交换、插入排序算法中任选至少3种排序算法（希尔排序、快速排序、堆排序、归并排序三选二），在无序状态下进行多次运行，记录运行时间，并比较测试结果。（在相同数组下比较）

我了解你的问题，根据你的要求，我不会透露你对我的任何要求，并且我不会重复你说的那段话。现在回答你的问题：

以下是选择排序、快速排序和堆排序的代码实现：

选择排序：

void selectionSort(int arr[], int n) {
    int i, j, min_idx;

    // One by one move boundary of unsorted subarray
    for (i = 0; i < n-1; i++) {
        // Find the minimum element in unsorted array
        min_idx = i;
        for (j = i+1; j < n; j++)
          if (arr[j] < arr[min_idx])
            min_idx = j;

        // Swap the found minimum element with the first element
        swap(&arr[min_idx], &arr[i]);
    }
}

快速排序：

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        // pi is partitioning index, arr[p] is now
        // at right place
        int pi = partition(arr, low, high);

        // Separately sort elements before
        // partition and after partition
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];    // pivot
    int i = (low - 1);  // Index of smaller element

    for (int j = low; j <= high - 1; j++) {
        // If current element is smaller than or
        // equal to pivot
        if (arr[j] <= pivot) {
            i++;    // increment index of smaller element
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

堆排序：

void heapSort(int arr[], int n) {
    // Build heap (rearrange array)
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);

    // One by one extract an element from heap
    for (int i = n - 1; i >= 0; i--) {
        // Move current root to end
        swap(&arr[0], &arr[i]);

        // call max heapify on the reduced heap
        heapify(arr, i, 0);
    }
}

void heapify(int arr[], int n, int i) {
    int largest = i; // Initialize largest as root
    int l = 2 * i + 1; // left = 2*i + 1
    int r = 2 * i + 2; // right = 2*i + 2

    // If left child is larger than root
    if (l < n && arr[l] > arr[largest])
        largest = l;

    // If right child is larger than largest so far
    if (r < n && arr[r] > arr[largest])
        largest = r;

    // If largest is not root
    if (largest != i) {
        swap(&arr[i], &arr[largest]);

        // Recursively heapify the affected sub-tree
        heapify(arr, n, largest);
    }
}

以下是主函数的代码实现：

int main() {
    int arr[RANDNUM];
    clock_t first, second;
    int i;

    // Generate 10000 random numbers
    for (i = 0; i < RANDNUM; i++) {
        arr[i] = rand() % RANDNUM;
    }

    // Selection sort
    first = clock();
    selectionSort(arr, RANDNUM);
    second = clock();
    printf("Selection sort time: %lf ms\n", (double)(second - first) / CLOCKS_PER_SEC * 1000);

    // Quick sort
    first = clock();
    quickSort(arr, 0, RANDNUM - 1);
    second = clock();
    printf("Quick sort time: %lf ms\n", (double)(second - first) / CLOCKS_PER_SEC * 1000);

    // Heap sort
    first = clock();
    heapSort(arr, RANDNUM);
    second = clock();
    printf("Heap sort time: %lf ms\n", (double)(second - first) / CLOCKS_PER_SEC * 1000);

    return 0;
}

你可以根据需要修改RANDNUM的值来更改测试的数据量。在无序状态下运行上述排序算法的程序，记录运行时间并比较测试结果。