快速排序法(C语言)
快速排序算法c语言实验报告

快速排序算法c语言实验报告冒泡法和选择法排序C程序实验报告实验六:冒泡法排序物理学416班赵增月F12 2011412194日期:2013年10月31日一·实验目的 1.熟练掌握程序编写步骤;2.学习使用冒泡法和选择法排序;3.熟练掌握数组的定义和输入输出方法。
二·实验器材1.电子计算机;2.VC6.0三·实验内容与流程1.流程图(1)冒泡法(2)选择法 2.输入程序如下:(1)冒泡法#includestdio.h void main() { int a[10]; int i,j,t; printf(请输入10个数字:\n); for(i=0;i10;i++)scanf(%d,&a[i]); printf(\n); for(j=0;j9;j++)for(i=0;i9-j;i++) if(a[i]a[i+1]) { t=a[i]; a[i]=a[i+1]; a[i+1]=t; } printf(排序后如下:\n); for(i=0;i10;i++) printf(%d,a[i]); printf(\n); }(2)选择法#includestdio.h void main() { int a[10]; int i,j,t,k; printf(请输入10个数字:\n); for(i=0;i10;i++)scanf(%d,&a[i]);printf(\n); for(i=0;i9;i++) {k=i;for(j=i+1;j10;j++) if (a[k]a[j])k=j;t=a[i];a[i]=a[k];a[k]=t; }printf(排序后如下:\n); for(i=0;i10;i++)printf(%d,a[i]); printf(\n); }四.输出结果(1冒泡法)请输入10个数字:135****2468排序后如下:12345678910 (2)选择法输出结果请输入10个数字:135****6810排序后如下:12345678910五.实验反思与总结1.冒泡法和选择法是一种数组排序的方法,包含两层循环,写循环时,要注意循环变量的变化范围。
c语言对double数组排序

c语言对double数组排序C语言对double数组进行排序有多种方法,包括冒泡排序、选择排序、插入排序、快速排序等。
本文将介绍其中几种常见的排序方法。
首先是冒泡排序,它是一种简单直观的排序算法。
冒泡排序的基本思想是通过相邻元素的比较和交换来将数组中较大的元素逐步“冒泡”到末尾。
下面是使用C语言实现的冒泡排序算法:```cvoid bubble_sort(double 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]) {double temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;}}}}```其次是选择排序,它是一种简单且不稳定的排序算法。
选择排序的基本思想是每次从未排序的部分选择最小(或最大)的元素放到已排序部分的末尾。
下面是使用C语言实现的选择排序算法:```cvoid selection_sort(double arr[], int n) {int min_idx;for (int i = 0; i < n-1; ++i) {min_idx = i;for (int j = i+1; j < n; ++j) {if (arr[j] < arr[min_idx]) {min_idx = j;}}double temp = arr[i];arr[i] = arr[min_idx];arr[min_idx] = temp;}}```接下来是插入排序,它是一种稳定的排序算法。
插入排序的基本思想是将数组分成已排序和未排序两部分,每次从未排序部分选择一个元素插入到已排序部分的正确位置。
下面是使用C语言实现的插入排序算法:```cvoid insertion_sort(double arr[], int n) {int i, j;double key;for (i = 1; i < n; ++i) {key = arr[i];j = i - 1;while (j >= 0 && arr[j] > key) {arr[j+1] = arr[j];--j;}arr[j+1] = key;}}```最后是快速排序,它是一种常用且高效的排序算法。
C语言常用算法程序汇总

C语言常用算法程序汇总C语言是一门广泛应用于计算机编程的语言,具有较高的效率和灵活性。
在C语言中,常见的算法程序包括排序算法、查找算法、递归算法等等。
以下是一些常用的C语言算法程序的汇总:1.排序算法:-冒泡排序:通过多次迭代比较相邻元素并交换位置,将最大的元素逐渐移动到正确的位置。
-插入排序:将待排序的元素与已排序的部分依次比较并插入到正确的位置。
-选择排序:每次从待排序的元素中选择最小的元素并与已排序的部分交换位置。
-快速排序:通过选择一个基准元素,将数组划分为两个子数组进行递归排序。
2.查找算法:-顺序查找:逐个比较数组中的元素,直到找到目标元素或到数组末尾。
-二分查找:通过比较目标元素与数组中间元素的大小,逐步缩小范围,直到找到目标元素。
-哈希查找:通过散列函数将目标元素映射到哈希表的索引位置进行查找。
3.递归算法:-阶乘:通过递归调用自身计算一个正整数的阶乘。
-斐波那契数列:通过递归调用自身计算斐波那契数列的第n个数。
-二叉树遍历:通过递归调用自身遍历二叉树的各个节点。
4.图算法:- 最短路径算法:如Dijkstra算法和Floyd算法,用于计算图中两个节点之间的最短路径。
-拓扑排序:通过对有向无环图进行排序,使得所有的边从排在前面的节点指向排在后面的节点。
- 最小生成树:如Prim算法和Kruskal算法,用于找到图中连接所有节点的最小子树。
5.动态规划:-最长公共子序列:通过寻找两个字符串中的最长公共子序列,解决字符串匹配问题。
-背包问题:通过动态规划解决在给定容量下选取物品使得总价值最大的问题。
-最大子序列和:通过动态规划解决一个数组中选取连续子序列使得和最大的问题。
以上只是一些C语言中常用的算法程序的汇总,实际上,还有很多其他的算法,如逆波兰表达式、霍夫曼编码、最小割等等。
通过学习这些算法,可以更好地理解C语言的应用和开发。
各种排序算法代码(C语言版)

各种排序算法代码(C语⾔版)选择排序#include <stdio.h>/** 选择排序* 稳定性:不稳定* 时间复杂度:O(N^2)**/void select_sort(int a[], int l, int r){for (int m_v, m_idx, t, i = l; i < r; ++i) {m_v = a[i]; m_idx = i;for (int j = i + 1; j < r; ++j) {if (m_v > a[j]) {m_v = a[j];m_idx = j;}}t = a[i]; a[i] = a[m_idx]; a[m_idx] = t;}}int main(void){int a[100];int n; scanf("%d", &n);for (int i = 0; i < n; ++i) scanf("%d", &a[i]);select_sort(a, 0, n);for (int i = 0; i < n; ++i) printf("%d ", a[i]);return0;}冒泡排序#include <stdio.h>/** 冒泡排序* 稳定性:稳定void bubble_sort(int a[], int l, int r){for (int i = l; i < r; ++i) {for (int j = l; j < r - i - 1; ++j) {if (a[j] > a[j + 1]) {int tmp = a[j];a[j] = a[j + 1];a[j + 1] = tmp;}}}}int main(void){int a[100];int n; scanf("%d", &n);for (int i = 0; i < n; ++i) scanf("%d", &a[i]); bubble_sort(a, 0, n);for (int i = 0; i < n; ++i) printf("%d ", a[i]);return0;}插⼊排序#include <stdio.h>/** 插⼊排序* 稳定性:稳定* 时间复杂度: O(N^2)**/void insert_sort(int a[], int l, int r){for (int tmp, j, i = l + 1; i < r; ++i) {tmp = a[i], j = i - 1;while (j >= l && tmp < a[j]) a[j+1] = a[j--]; a[j+1] = tmp;}}int main(void){for (int i = 0; i < n; ++i) scanf("%d", &a[i]); insert_sort(a, 0, n);for (int i = 0; i < n; ++i) printf("%d ", a[i]);return0;}希尔排序#include <stdio.h>/** 希尔排序* 稳定性:不稳定* 时间复杂度:O(N*logN)**/void shell_insert_sort(int a[], int l, int r, int d) {for (int tmp, j, i = l + d; i < r; ++i) {tmp = a[i], j = i - d;while (j >= l && tmp < a[j]) {a[j + d] = a[j];j -= d;}a[j + d] = tmp;}}void shell_sort(int a[], int l, int r){int d = (r - l) / 2;while (d >= 1) {shell_insert_sort(a, l, r, d);d /= 2;}}int main(void){int a[100];int n; scanf("%d", &n);for (int i = 0; i < n; ++i) scanf("%d", &a[i]); shell_sort(a, 0, n);for (int i = 0; i < n; ++i) printf("%d ", a[i]);归并排序/** 归并排序* 稳定性:稳定* 时间复杂度:O(N*logN)**/void merge(int a[], int n, int b[], int m, int t[]) {int i, j, k;i = j = k = 0;while (i < n && j < m) {if (a[i] < b[j]) t[k++] = a[i++];else t[k++] = b[j++];}while (i < n) t[k++] = a[i++];while (j < m) t[k++] = b[j++];}void my_merge_sort(int a[], int l, int r, int t[]) {int mid = (l + r) >> 1;int n = r - l;int i;if (l + 1 < r) {my_merge_sort(a, l, mid, t);my_merge_sort(a, mid, r, t);merge(a+l, mid-l, a+mid, r-mid, t);for (i = 0; i < n; ++i) a[i + l] = t[i];}}void merge_sort(int a[], int l, int r){int *t = (int *)malloc((r-l) * sizeof (int));my_merge_sort(a, l, r, t);free(t);}堆排序* 堆排序* 稳定性:不稳定* 时间复杂度:O(N*logN)**/// big top pilevoid heap_adjust(int a[], int fa, int n){int cd = fa * 2 + 1;while (cd < n) {if (cd + 1 < n && a[cd] < a[cd + 1]) cd++;if (a[fa] >= a[cd]) break;int tmp = a[fa];a[fa] = a[cd];fa = cd;cd = fa * 2 + 1;a[fa] = tmp;}}void build_heap(int a[], int n){// ignore leap nodefor (int i = (n - 1) / 2; i >= 0; --i) {heap_adjust(a, i, n);}}void heap_sort(int a[], int l, int r){build_heap(a + l, r - l);for (int tmp, i = r - 1; i > l; --i) {tmp = a[i]; a[i] = a[0]; a[0] = tmp;heap_adjust(a + l, 0, i);}}int main(void){int a[100];int n; scanf("%d", &n);for (int i = 0; i < n; ++i) scanf("%d", &a[i]); heap_sort(a, 0, n);return0;}快速排序/** 快速排序* 稳定性:不稳定* 时间复杂度:O(N*logN)**/void quick_sort(int a[], int l, int r){if (l + 1 >= r) return ;int low = l, high = r;int key = a[l];while (low < high) {while (low < high && a[--high] >= key); a[low] = a[high];while (low < high && a[++low] < key); a[high] = a[low];}a[low] = key;quick_sort(a, l, low);quick_sort(a, low+1, r);}基数排序/** 基数排序* 稳定性:稳定* 时间复杂度:O(d(n+radix)) [d个关键码,关键码的取值范围为radix] **/int tmp[100000000];void radix_sort(int arr[], int beg, int ed){static int a[9] = {1, 10, 100, 1000, 10000, 100000, 1000000};int cnt[10]; // 0~9⼗个数字int digit = 0; // 最⼤位数for (int i = beg; i < ed; ++i)while (arr[i] / a[digit + 1] > 0) digit++;for (int idx = 0; idx <= digit; ++idx) {for (int i = 0; i < 10; ++i) cnt[i] = 0; // 桶计数清零for (int i = beg; i < ed; ++i) cnt[ arr[i]/a[idx]%10 ]++; // 统计每个数字出现的次数// 前缀和统计每个数字前⾯的数字个数这样就可以知道每个数字应该排在第⼏位了for (int i = 1; i < 10; ++i) cnt[i] += cnt[i - 1];for (int i = ed - 1; i >= beg; --i) tmp[ --cnt[arr[i]/a[idx]%10] ] = arr[i];for (int i = beg, j = 0; i < ed; ++i, ++j) arr[i] = tmp[j];}}测试性能int a[100000000];double test(void(*fun)(int*, int, int), int range){for (int i = 0; i < range; ++i) a[i] = rand();clock_t start = clock();fun(a, 0, range);clock_t finish = clock();//for (int i = 0; i < range; ++i) printf("%d\n", a[i]);return ((double)finish - start) / CLOCKS_PER_SEC;}int main(){srand((unsigned)time(NULL));printf(" 数据范围堆排序归并排序希尔排序快速排序插⼊排序冒泡排序选择排序基数排序\n");for (int range = 100; range <= 100000; range *= 10) {printf("%9d %8.3f %8.3f %8.3f %8.3f %8.3f %8.3f %8.3f\n", range, test(heap_sort, range), test(merge_sort, range), test(shell_sort, range), test(quick_sort, range), test(insert_sort, range), test(bubble_sort, range), test(select_sort, range), test(radix_sort, range));}for (int range = 1000000; range <= 10000000; range *= 10) {printf("%9d %8.3f %8.3f %8.3f %8.3f %8.3f\n", range, test(heap_sort, range), test(merge_sort, range), test(shell_sort, range),test(quick_sort, range), test(radix_sort, range));}return0;。
C语言八大排序算法

C语⾔⼋⼤排序算法C语⾔⼋⼤排序算法,附动图和详细代码解释!来源:C语⾔与程序设计、⽵⾬听闲等⼀前⾔如果说各种编程语⾔是程序员的招式,那么数据结构和算法就相当于程序员的内功。
想写出精炼、优秀的代码,不通过不断的锤炼,是很难做到的。
⼆⼋⼤排序算法排序算法作为数据结构的重要部分,系统地学习⼀下是很有必要的。
1、排序的概念排序是计算机内经常进⾏的⼀种操作,其⽬的是将⼀组“⽆序”的记录序列调整为“有序”的记录序列。
排序分为内部排序和外部排序。
若整个排序过程不需要访问外存便能完成,则称此类排序问题为内部排序。
反之,若参加排序的记录数量很⼤,整个序列的排序过程不可能在内存中完成,则称此类排序问题为外部排序。
2、排序分类⼋⼤排序算法均属于内部排序。
如果按照策略来分类,⼤致可分为:交换排序、插⼊排序、选择排序、归并排序和基数排序。
如下图所⽰:3、算法分析1.插⼊排序*直接插⼊排序*希尔排序2.选择排序*简单选择排序*堆排序3.交换排序*冒泡排序*快速排序4.归并排序5.基数排序不稳定排序:简单选择排序,快速排序,希尔排序,堆排序稳定排序:冒泡排序,直接插⼊排序,归并排序,奇数排序1、插⼊排序将第⼀个和第⼆个元素排好序,然后将第3个元素插⼊到已经排好序的元素中,依次类推(插⼊排序最好的情况就是数组已经有序了)因为插⼊排序每次只能操作⼀个元素,效率低。
元素个数N,取奇数k=N/2,将下标差值为k的数分为⼀组(⼀组元素个数看总元素个数决定),在组内构成有序序列,再取k=k/2,将下标差值为k的数分为⼀组,构成有序序列,直到k=1,然后再进⾏直接插⼊排序。
3、简单选择排序选出最⼩的数和第⼀个数交换,再在剩余的数中⼜选择最⼩的和第⼆个数交换,依次类推4、堆排序以升序排序为例,利⽤⼩根堆的性质(堆顶元素最⼩)不断输出最⼩元素,直到堆中没有元素1.构建⼩根堆2.输出堆顶元素3.将堆低元素放⼀个到堆顶,再重新构造成⼩根堆,再输出堆顶元素,以此类推5、冒泡排序改进1:如果某次冒泡不存在数据交换,则说明已经排序好了,可以直接退出排序改进2:头尾进⾏冒泡,每次把最⼤的沉底,最⼩的浮上去,两边往中间靠16、快速排序选择⼀个基准元素,⽐基准元素⼩的放基准元素的前⾯,⽐基准元素⼤的放基准元素的后⾯,这种动作叫分区,每次分区都把⼀个数列分成了两部分,每次分区都使得⼀个数字有序,然后将基准元素前⾯部分和后⾯部分继续分区,⼀直分区直到分区的区间中只有⼀个元素的时候,⼀个元素的序列肯定是有序的嘛,所以最后⼀个升序的序列就完成啦。
c语言数字从大到小排列

c语言数字从大到小排列C语言数字从大到小排列C语言中,数字的排序是程序员需要掌握的计算机技能之一。
下面将介绍如何使用C语言编写程序来实现数字从大到小的排序。
I. 程序思路1. 输入需要排序的数字,将其存储在数组中;2. 从数组中选择一个数字作为基准点,将比基准点小的数字放在基准点左边,比基准点大的数字放在基准点右边;3. 对基准点左边和右边的数字重复第2步,直到所有数字都排列完成。
II. 编程实现1. 定义函数来实现数字排序:```void sort(int arr[], int left, int right){int i, j, pivot, temp;if (left < right) {pivot = left;i = left;j = right;while (i < j) {while (arr[i] >= arr[pivot] && i < right)i++;while (arr[j] < arr[pivot])j--;if (i < j) {temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}temp = arr[pivot];arr[pivot] = arr[j];arr[j] = temp;sort(arr, left, j - 1);sort(arr, j + 1, right);}}```2. 在主函数中输入需要排序的数字,并输出排序结果:```int main(){int arr[100], i, n;printf("请输入数字的个数:");scanf("%d", &n);for (i = 0; i < n; i++) {printf("请输入第 %d 个数字:", i + 1);scanf("%d", &arr[i]);}sort(arr, 0, n - 1);printf("数字按从大到小排列的结果:\n");for (i = 0; i < n; i++)printf("%d ", arr[i]);return 0;}```在上述代码中,sort函数使用快速排序算法实现数字从大到小的排列。
c语言数组数据比较算法

c语言数组数据比较算法概述在C语言中,数组是一种常见的数据结构,用于存储一系列相同数据类型的元素。
在实际编程中,经常需要对数组进行比较操作,以找到数组中的最大值、最小值、排序等。
本文将详细介绍C语言中常用的数组数据比较算法。
一、数组元素比较1.1 逐个元素比较法逐个元素比较法是最简单的数组比较方法,其基本思想是将两个数组中的对应元素逐个进行比较,找出差异或相同之处。
具体步骤如下:1.声明两个数组a和b;2.逐个比较数组a和数组b的对应元素;3.如果找到不同的元素,输出差异;4.如果所有对应元素都相同,则输出相同。
1.2 利用循环遍历比较法逐个元素比较法虽然简单,但需要逐个比较所有元素,效率较低。
利用循环遍历比较法可以通过循环结构实现更高效的数组比较。
具体步骤如下: 1. 声明两个数组a和b; 2. 使用循环结构遍历数组a和数组b的对应元素; 3. 逐个比较数组a 和数组b的对应元素; 4. 如果找到不同的元素,输出差异; 5. 如果所有对应元素都相同,则输出相同。
二、数组排序算法2.1 冒泡排序法冒泡排序是一种简单的排序算法,其基本思想是多次遍历数组,每次遍历都将相邻的两个元素进行比较并交换位置,从而实现将最大(或最小)元素逐渐移到数组的末尾(或开头)。
具体步骤如下: 1. 声明一个数组a; 2. 外层循环遍历数组元素,从第一个元素到倒数第二个元素; 3. 内层循环遍历数组元素,从第一个元素到当前外层循环变量所指示的位置; 4. 逐个比较相邻的两个元素,如果前一个元素大于后一个元素,则交换它们的位置; 5. 继续下一轮的遍历,直到所有元素排序完成。
2.2 插入排序法插入排序是一种简单直观的排序算法,其基本思想是将数组分为已排序和未排序两部分,每次从未排序部分取出一个元素,插入到已排序部分的适当位置。
具体步骤如下: 1. 声明一个数组a; 2. 外层循环遍历数组元素,从第二个元素到最后一个元素; 3. 内层循环从外层循环变量所指示的位置开始,向前逐个比较并移动已排序部分的元素; 4. 当找到合适位置时,插入当前未排序元素; 5. 继续下一轮的遍历,直到所有元素排序完成。
c语言实现简单排序(8种方法)

#include<stdio.h>#include<stdlib.h>//冒泡排序voidbubleSort(int data[], int n);//快速排序voidquickSort(int data[], int low, int high); intfindPos(int data[], int low, int high);//插入排序voidbInsertSort(int data[], int n);//希尔排序voidshellSort(int data[], int n);//选择排序voidselectSort(int data[], int n);//堆排序voidheapSort(int data[], int n);void swap(int data[], inti, int j);voidheapAdjust(int data[], inti, int n);//归并排序voidmergeSort(int data[], int first, int last);void merge(int data[], int low, int mid, int high); //基数排序voidradixSort(int data[], int n);intgetNumPos(intnum, intpos);int main() {int data[10] = {43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");/*printf("冒泡排序:");bubleSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("快速排序:");quickSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("插入排序:");bInsertSort(data,10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("希尔排序:");shellSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");printf("选择排序:");selectSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti;printf("原先数组:");int data[11] = {-1, 43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf(" 堆排序:");heapSort(data, 10);for(i=1;i<11;i++) {printf("%d ", data[i]);}printf("\n");printf("归并排序:");mergeSort(data, 0, 9);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");*/printf("基数排序:");radixSort(data, 10);for(i=0;i<10;i++) {printf("%d ", data[i]);}printf("\n");return 0;}/*--------------------冒泡排序---------------------*/ voidbubleSort(int data[], int n) {inti,j,temp;//两个for循环,每次取出一个元素跟数组的其他元素比较//将最大的元素排到最后。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<time.h>
#define randx(x) (rand()%x)
typedef int KeyType;
typedef int DataType;
typedef struct
{
KeyType key;/*排序码字段*/
DataType info; /*记录的其它字段*/
}RecordNode;
typedef struct
{
int n; /*文件中的记录个数,可以视为常量*/
RecordNode *record;
}SortObject;
void creatsort(SortObject * pvector, int &l, int &r)//新建二叉排序树{
int i; int k;
printf("您即将要创建一个序列\n");
printf("\n请输入该序列元素的个数\n");
scanf("%d", &pvector->n);
pvector->record = (RecordNode*)malloc((sizeof(RecordNode))*(pvector->n));
printf("\n你要以什么方式创建序列?\n方式1:自动创建请输入1,方式2:手动创建请输入0\n");
scanf("%d", &k);
if (k)
{
srand((int)time(0));
for (i = 0; i < pvector->n; i++)
{
if(pvector->n<100)
pvector->record[i].key = randx(100);
else if((pvector->n<1000))
pvector->record[i].key = randx(1000);
else
pvector->record[i].key = randx(pvector->n);
}
}
else
{
printf("\n请输入%d个大小不一样的整数\n", pvector->n);
for (i = 0; i < pvector->n; i++)
{
scanf("%d", &pvector->record[i].key);
}
}
if (pvector)
printf("\n序列创建成功!\n");
else
printf("\n序列创建失败!\n");
l = 0, r = pvector->n-1;
}
void show(SortObject * pvector)
{
printf("\n当前序列为:\n");
if (!pvector)
printf("当前序列为空");
else
for (int i = 1; i <= pvector->n; i++)
{
printf(" %d ", pvector->record[i-1].key);
if (i % 15 == 0)
printf("\n");
}
printf("\n");
}
void quickSort(SortObject* &pvector, int l, int r)
{
int i, j;
RecordNode temp, *data = pvector->record;
if (l >= r)
return; /* 只有一个记录或无记录,则无须排序*/
i = l;
j = r;
temp = data[i];
while (i != j)
{/* 找Rl的最终位置*/
while (i< j && data[j].key >= temp.key)
j--; /* 向左扫描找排序码小于temp.key的记录*/ if (i< j)
data[i++] = data[j];
while (i< j && data[i].key <= temp.key)
i++; /* 向右扫描找排序码大于temp.key的记录*/ if (i< j)
data[j--] = data[i];
}
data[i] = temp; /* 将Rl存入其最终位置*/
quickSort(pvector, l, i - 1); /* 递归处理左区间*/
quickSort(pvector, i + 1, r); /* 递归处理右区间*/
}
void interface(void)
{
printf("\n&&&&&&&&&&&&&&输入序号执行相应操作&&&&&&&&&&&&&&&&&\n");
printf(" 输入1,重新建立序列!\n");
printf("---------------------------------------------------\n");
printf(" 输入2,快速排序当前序列!\n");
printf("---------------------------------------------------\n");
printf(" 输入3,显示当前序列!\n");
printf("---------------------------------------------------\n");
printf(" 输入其他,退出操作!\n");
printf("---------------------------------------------------\n");
}
void operation(SortObject* pvector, int l, int r)
{
int k = 1, num;
while (k)
{
interface();//显示界面
scanf("%d", &num);
switch (num)
{
case 1:
free(pvector->record);//重新生成之前释放空间
free(pvector);//重新生成之前释放空间
creatsort(pvector, l, r);
break;
case 2:
{
quickSort(pvector, l, r);//执行快速排序
printf("\n已经为你执行快速排序!\n");
}
break;
case 3:
{
show(pvector);
}
break;
default:
printf("您未选定任何操作!请重新输入操作序号!\n");
k = 0;
break;
}
}
}
int main()
{
int l=0,r=0;
SortObject * pvector = (SortObject *)malloc(sizeof(SortObject));//分配序列指针creatsort(pvector, l, r);
operation(pvector, l, r);
getchar();
getchar();
return 0;
}
感谢下载!
欢迎您的下载,资料仅供参考。