#include <stdio.h> #include <stdlib.h> #define Max 20 int find(int arr[],int n,int x); int del(int arr[],int n,int i); int getData(int arr[]); int saveData(int arr[],int n); int insertX(int arr[] ,int n,int i); void pntArray(int arr[],int n); int main(void) { char c; int n,i,x,j,m; int a[Max]; do{ printf("\n\n系统菜单*******\nV:浏览 D:删除 I:插入 Q:退出\n*********************************\n\n"); printf("请输入菜单项(仅接受大写):"); scanf("%c",&c); getchar(); if(c=='V'||c=='D'||c=='I'||c=='Q') { n=getData(a); switch(c){ case'V':pntArray(a,n);break; case'D': printf("请输入待删除的值："); scanf("%d",&x); for(i=0;i<n;i++) { j=find(a,n,x); if(j==-1) { if(m==0){printf("待删除%d不存在！",x); break;} else break; } else { n=del(a,n,j); m++; } } pntArray(a,n); break; case'I': insertX(a,n,i); printf("插入后的数组："); pntArray(a,n); break; case'Q':exit(0); } continue; } else printf("选项不存在！"); }while(c!='V'||c!='D'||c!='I'||c!='Q'); return 0; } int find(int arr[],int n,int x) { int i; for(i=0;i<n;i++) if(x==arr[i]) return i; return -1; } int del(int arr[],int n,int i) { int j; for(j=i+1;j<n;j++) arr[j-1]=arr[j]; return n-1; } int getData(int arr[]) { FILE *fp; int n=0; if((fp=fopen("data.txt","r"))==NULL) { printf("can not open file!"); return 0; } while(!feof(fp)) { if(n==Max) { printf("存储空间已满，读入数据失败"); return 0; } fscanf(fp,"%d",&arr[n]); n++; } fclose(fp); return n-1; } int saveData(int arr[],int n) { FILE *fp; int i; if((fp=fopen("data.txt","w"))==NULL) { printf("can not open file!"); return 0; } for(i=0;i<n;i++) fprintf(fp,"%d\t",arr[i]); fclose(fp); return 1; } int insertX(int arr[] ,int n,int i) { int x; int j; printf("请输入待插入数据:"); scanf("%d",&x); for(j=n-1;j>=i;j--) arr[j+1]=arr[j]; arr[i]=x; return n+1; } void pntArray(int arr[],int n) { int i; for(i=0;i<n;i++) { printf("%d\t",arr[i]); if((i+1)%10==0)//每10个记录一行 printf("\n"); } }

这是一个基于文件存储的数组操作程序，提供了浏览、删除、插入等功能。主要流程为先读取文件中的数据到数组中，然后根据用户输入的菜单项进行相应操作，最后将修改后的数组内容保存到文件中。

具体实现包括以下函数：

- `find`：在数组中查找指定值的位置。
- `del`：删除数组中指定位置的值，并返回新的数组长度。
- `getData`：从文件中读取数据到数组中，返回数组长度。
- `saveData`：将数组中的数据保存到文件中，返回操作结果。
- `insertX`：在数组中指定位置插入新值，并返回新的数组长度。
- `pntArray`：打印数组中的数据，每10个记录一行。

在 `main` 函数中，根据用户输入的菜单项进行相应操作，并在操作完成后继续显示菜单，直到用户选择退出。

相关问题

改进以下代码#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的值来更改测试的数据量。在无序状态下运行上述排序算法的程序，记录运行时间并比较测试结果。