快速排序法(C语言)

合集下载

快速排序算法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语言对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语言中,常见的算法程序包括排序算法、查找算法、递归算法等等。

以下是一些常用的C语言算法程序的汇总:1.排序算法:-冒泡排序:通过多次迭代比较相邻元素并交换位置,将最大的元素逐渐移动到正确的位置。

-插入排序:将待排序的元素与已排序的部分依次比较并插入到正确的位置。

-选择排序:每次从待排序的元素中选择最小的元素并与已排序的部分交换位置。

-快速排序:通过选择一个基准元素,将数组划分为两个子数组进行递归排序。

2.查找算法:-顺序查找:逐个比较数组中的元素,直到找到目标元素或到数组末尾。

-二分查找:通过比较目标元素与数组中间元素的大小,逐步缩小范围,直到找到目标元素。

-哈希查找:通过散列函数将目标元素映射到哈希表的索引位置进行查找。

3.递归算法:-阶乘:通过递归调用自身计算一个正整数的阶乘。

-斐波那契数列:通过递归调用自身计算斐波那契数列的第n个数。

-二叉树遍历:通过递归调用自身遍历二叉树的各个节点。

4.图算法:- 最短路径算法:如Dijkstra算法和Floyd算法,用于计算图中两个节点之间的最短路径。

-拓扑排序:通过对有向无环图进行排序,使得所有的边从排在前面的节点指向排在后面的节点。

- 最小生成树:如Prim算法和Kruskal算法,用于找到图中连接所有节点的最小子树。

5.动态规划:-最长公共子序列:通过寻找两个字符串中的最长公共子序列,解决字符串匹配问题。

-背包问题:通过动态规划解决在给定容量下选取物品使得总价值最大的问题。

-最大子序列和:通过动态规划解决一个数组中选取连续子序列使得和最大的问题。

以上只是一些C语言中常用的算法程序的汇总,实际上,还有很多其他的算法,如逆波兰表达式、霍夫曼编码、最小割等等。

通过学习这些算法,可以更好地理解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语⾔⼋⼤排序算法,附动图和详细代码解释!来源: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语言中,数字的排序是程序员需要掌握的计算机技能之一。

下面将介绍如何使用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语言中,数组是一种常见的数据结构,用于存储一系列相同数据类型的元素。

在实际编程中,经常需要对数组进行比较操作,以找到数组中的最大值、最小值、排序等。

本文将详细介绍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种方法)

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循环,每次取出一个元素跟数组的其他元素比较//将最大的元素排到最后。

五个数排序c语言编程

五个数排序c语言编程

五个数排序c语言编程以五个数排序为题,我们将使用C语言编程来实现。

排序是计算机科学中非常基础且重要的算法之一,它可以将一组数据按照指定的规则进行排列,使得数据更加有序。

在这篇文章中,我们将介绍常见的五个数排序算法,并使用C语言编程来实现它们。

一、冒泡排序冒泡排序是排序算法中最简单的一种,它的原理是通过比较相邻的两个元素,如果它们的顺序不符合规定的规则,则交换它们的位置。

经过一轮的比较和交换,最大(或最小)的元素就像气泡一样逐渐浮到了最后的位置。

重复这个过程,直到所有的元素都排好序。

二、插入排序插入排序的原理是将未排序的元素逐个插入到已排序的序列中。

具体来说,我们从第二个元素开始,逐个比较它与前面的元素的大小,如果顺序不符合规定的规则,则交换它们的位置。

通过不断地插入和交换,最终将所有的元素都按照规定的顺序排列好。

三、选择排序选择排序的原理是通过每一轮的比较,选择出最小(或最大)的元素,并将其放到已排序序列的末尾。

具体来说,我们从未排序序列中选择出最小的元素,然后与未排序序列的第一个元素交换位置。

重复这个过程,直到所有的元素都排好序。

四、快速排序快速排序是一种分治的排序算法,它的原理是通过选择一个基准元素,将待排序序列分成两个子序列,其中一个子序列的所有元素都比基准元素小,另一个子序列的所有元素都比基准元素大。

然后对这两个子序列分别进行递归调用快速排序,最终将所有的元素都排好序。

五、归并排序归并排序是一种采用分治策略的排序算法,它的原理是将待排序序列分成两个子序列,分别对这两个子序列进行递归调用归并排序,得到两个有序的子序列。

然后将这两个有序的子序列合并成一个有序的序列。

通过不断地合并,最终将所有的元素都排好序。

以上就是常见的五个数排序算法的介绍。

接下来,我们将使用C语言编程来实现这些排序算法。

我们定义一个包含五个元素的数组,并初始化它们的值。

然后,按照不同的排序算法,调用相应的排序函数,对数组进行排序。

C语言常用简单算法

C语言常用简单算法

C语言常用简单算法C语言是一种广泛应用的编程语言,支持各种算法的实现。

以下是一些常用的简单算法,涵盖了排序、查找、递归等方面。

1. 冒泡排序(Bubble Sort):通过不断比较相邻元素的大小,将较大的元素逐步“冒泡”到数组的末尾。

2. 选择排序(Selection Sort):每次从未排序的数组中选择最小(或最大)的元素,放到已排序数组的末尾。

3. 插入排序(Insertion Sort):将数组分为已排序和未排序两个部分,每次将未排序部分中的元素插入到已排序部分的正确位置。

4. 快速排序(Quick Sort):选择一个基准元素,将数组分成两部分,将小于基准的元素放在左边,大于基准的元素放在右边,然后递归地对两部分进行排序。

5. 归并排序(Merge Sort):将待排序数组递归地分成两部分,分别进行排序,然后再将两个有序的数组合并成一个有序的数组。

6. 二分查找(Binary Search):对于有序数组,通过比较中间元素和目标值的大小,缩小查找范围,直到找到目标值或查找范围为空。

7. 线性查找(Linear Search):对于无序数组,逐个比较数组中的元素和目标值,直到找到目标值或遍历完整个数组。

8. 求阶乘(Factorial):使用递归方式或循环方式计算给定数字的阶乘。

9. 斐波那契数列(Fibonacci Sequence):使用递归方式或循环方式生成斐波那契数列。

10. 汉诺塔(Tower of Hanoi):使用递归方式实现汉诺塔问题的解决,将一组盘子从一个柱子移动到另一个柱子。

11. 判断回文数(Palindrome):判断给定数字是否为回文数,即正序和倒序相同。

12.求最大公约数(GCD):使用辗转相除法或欧几里德算法求两个数的最大公约数。

13.求最小公倍数(LCM):通过最大公约数求得最小公倍数。

14. 求质数(Prime Number):判断给定数是否为质数,即只能被1和自身整除。

C语言常用的入门算法

C语言常用的入门算法

C语言常用的入门算法C语言是一门广泛应用于计算机科学和软件开发领域的编程语言。

作为一门通用的编程语言,C语言提供了丰富的算法和数据结构库,使得开发人员能够解决各种不同类型的问题。

下面是C语言入门算法的一些常见示例:1.排序算法:-冒泡排序:通过不断比较相邻的元素,并交换它们的位置来排序。

-插入排序:将未排序的元素逐一插入已排序的列表中。

-选择排序:通过重复找到最小的元素并将其放置在已排序序列的末尾来排序。

-快速排序:通过选择一个基准元素,将列表划分成较小和较大的两部分,然后对其进行递归排序。

-归并排序:将列表分成较小的子列表,然后逐个合并这些子列表。

2.查找算法:-顺序查找:逐个比较列表中的元素,直到找到匹配的元素为止。

-二分查找:在已排序的列表中通过递归或循环的方式,将待查找的元素与中间元素进行比较,以确定它可能在哪一半中。

-哈希表:通过散列函数将元素映射到一个较小的固定大小的数组(哈希表)中,并通过索引快速查找。

3.字符串算法:-字符串长度:使用循环逐个字符遍历,直到遇到字符串结束符'\0'为止,统计字符个数。

-字符串比较:逐个字符比较两个字符串的对应位置,直到遇到不相等的字符或字符串结束符。

-字符串拼接:将一个字符串的字符逐个复制到另一个字符串的末尾,直到遇到字符串结束符'\0'。

-子字符串匹配:在一个较长的字符串中查找一个较短的子字符串,常用的算法有朴素算法和KMP算法。

4.数值算法和运算:-求和、平均值、最大/最小值:循环遍历列表,累加求和,计算平均值,找出最大/最小值。

-阶乘和斐波那契数列:使用循环或递归计算给定数字的阶乘和斐波那契数列。

-幂运算和开方:通过循环或递归计算给定数字的幂和开方。

- 线性方程求解:求解形如ax + b = 0的一元线性方程。

5.图算法:-广度优先(BFS):通过遍历图的邻居节点来逐层扩展区域,通常用于查找最短路径。

-深度优先(DFS):通过遍历图的邻居节点来递归到达所有可能的节点,通常用于查找所有路径、拓扑排序等。

c语言各种排序方法及其所耗时间比较程序

c语言各种排序方法及其所耗时间比较程序

c语言各种排序方法及其所耗时间比较程序#include <iostream.h> #include <stdlib.h> #include <iomanip.h>#include <time.h> #include <stdio.h>const int N=1000;//数据量,用于检测算法质量 const int M=1000;//执行次数//冒泡排序(递增)void Bubblesort(int r[],int n){int flag=1;//flag为0停止排序for(int i=1;i<n;i++){flag=0;for(int j=n-1;j>=i;j--)if(r[j]<r[j-1]){int t=r[j];r[j]=r[j-1];r[j-1]=t;flag=1;}if(flag==0)return;}}//快速排序void quicksort(int r[],int left,int right) {int i,j;int swap;i=left;j=right;swap=r[left];while(i<j){while((i<j)&&(swap<r[j]))j--;if(i<j){r[i]=r[j];i++;}while((i<j)&&(swap>r[i]))i++;if(i<j){r[j]=r[i];j--;}}r[i]=swap;if(i>left)quicksort(r,left,i-1);if(i<right)quicksort(r,i+1,right);return;}//堆排序先建立堆void creatheap(int r[],int i,int n) {int j;int t;t=r[i];j=2*i;while(j<n){if((j<n)&&(r[j]<r[j+1]))j++;if(t<r[j]){r[i]=r[j];i=j;j=2*i;}else j=n;r[i]=t;}}//堆排序void heapsort(int r[],int n){int t;for(int i=n/2;i>=0;i--)creatheap(r,i,n);for(i= n-1;i>=0;i--){t=r[0];r[0]=r[i];r[i]=t;creatheap(r,0,i-1);}return;}//二路归并void merge(int r[],int r1[],int low,int mid,int high)//进行二合一的函数 {int i=low,j=mid+1,k=low;while((i<=mid)&&(j<=high)){if(r[i]<=r[j])r1[k++]=r[i++];elser1[k++]=r[j++];}while(i<=mid)r1[k++]=r[i++];while(j<=high)r1[k++]=r[j++];}void mergepass(int r[],int r1[],int length)//用来区分填入merge函数的变量计算式{int i=0,j;while(i+2*length<=N){merge(r,r1,i,i+length-1,i+2*length-1);i=i+2*length;}if(i+length-1<N-1)merge(r,r1,i,i+length-1,N-1);elsefor(j=i;j<N;j++)r1[j]=r[j];}void mergesort(int r[])//二路并归总算法{int length=1;int r1[N+1];while(length<N){mergepass(r,r1,length); length=2*length; mergepass(r1,r,length); length=2*length;}return;}//进行输出void print(int r[],int n) { for(int i=0;i<=n-1;i++) {if(i%10==0){cout<<endl;} cout<<r[i]<<setw(6);}cout<<endl;}//主函数void main(){int i,j,k;int r[N],a[N];clock_t start, finish;double duration;cout<<"请选择排序方式,1、冒泡法;2、快速排序法;3、堆排序法;4、二路并归法"<<endl;cin>>j;srand((unsigned)time(NULL));for(i=0;i<N;i++){a[i]=rand()%10000;}switch(j){case(1):{cout<<"冒泡法";start = clock();for(i=0;i<M;i++){k=N-1;while(k+1){r[k]=a[k];k--;}Bubblesort(r,N);//冒泡法}finish = clock();duration = (double)(finish - start)/1000; print(r,N);printf( "%f seconds\n", duration );}break;case(2):{cout<<"快速排序法";start = clock();for(i=0;i<M;i++){k=N-1;while(k+1){r[k]=a[k];k--;}quicksort(r,0,N-1);//快速排序法}finish = clock();duration = (double)(finish - start)/1000;print(r,N);printf( "%f seconds\n", duration );}break;case(3):{cout<<"堆排序法";start = clock();for(i=0;i<M;i++){k=N-1;while(k+1){r[k]=a[k];k--;}heapsort(r,N);//堆排序法}finish = clock();duration = (double)(finish - start)/1000; print(r,N);printf( "%f seconds\n", duration );}break;case(4):{cout<<"二路并归法";start = clock();for(i=0;i<M;i++){k=N-1;while(k+1){r[k]=a[k];k--;}mergesort(r);//二路并归法}finish = clock();duration = (double)(finish - start)/1000; print(r,N);printf( "%f seconds\n", duration );}break;}}。

C语言几种常见的排序方法

C语言几种常见的排序方法

C语言几种常见的排序方法2009-04-22 19:55插入排序是这样实现的:首先新建一个空列表,用于保存已排序的有序数列(我们称之为"有序列表")。

从原数列中取出一个数,将其插入"有序列表"中,使其仍旧保持有序状态。

重复2号步骤,直至原数列为空。

插入排序的平均时间复杂度为平方级的,效率不高,但是容易实现。

它借助了"逐步扩大成果"的思想,使有序列表的长度逐渐增加,直至其长度等于原列表的长度。

冒泡排序冒泡排序是这样实现的:首先将所有待排序的数字放入工作列表中。

从列表的第一个数字到倒数第二个数字,逐个检查:若某一位上的数字大于他的下一位,则将它与它的下一位交换。

重复2号步骤,直至再也不能交换。

冒泡排序的平均时间复杂度与插入排序相同,也是平方级的,但也是非常容易实现的算法。

选择排序选择排序是这样实现的:设数组内存放了n个待排数字,数组下标从1开始,到n结束。

i=1从数组的第i个元素开始到第n个元素,寻找最小的元素。

将上一步找到的最小元素和第i位元素交换。

如果i=n-1算法结束,否则回到第3步选择排序的平均时间复杂度也是O(n&sup2;)的。

快速排序现在开始,我们要接触高效排序算法了。

实践证明,快速排序是所有排序算法中最高效的一种。

它采用了分治的思想:先保证列表的前半部分都小于后半部分,然后分别对前半部分和后半部分排序,这样整个列表就有序了。

这是一种先进的思想,也是它高效的原因。

因为在排序算法中,算法的高效与否与列表中数字间的比较次数有直接的关系,而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了,大大减少了数字间不必要的比较。

但查找数据得另当别论了。

堆排序堆排序与前面的算法都不同,它是这样的:首先新建一个空列表,作用与插入排序中的"有序列表"相同。

快速排序(C语言)-解析

快速排序(C语言)-解析

快速排序(C语⾔)-解析快速排序快速排序是⼀种排序算法,对包含 n 个数的输⼊数组,最坏情况运⾏时间为O(n2)。

虽然这个最坏情况运⾏时间⽐较差,但快速排序通常是⽤于排序的最佳的实⽤选择,这是因为其平均性能相当好:期望的运⾏时间为O(nlgn),且O(nlgn)记号中隐含的常数因⼦很⼩。

另外,它还能够进⾏就地排序,在虚存环境中也能很好的⼯作。

快速排序(Quicksort)是对的⼀种改进。

快速排序由C. A. R. Hoare在1962年提出。

它的基本思想是:通过⼀趟排序将要排序的数据分割成独⽴的两部分,其中⼀部分的所有数据都⽐另外⼀部分的所有数据都要⼩,然后再按此⽅法对这两部分数据分别进⾏快速排序,整个排序过程可以进⾏,以此达到整个数据变成有序。

像合并排序⼀样,快速排序也是采⽤分治模式的。

下⾯是对⼀个典型数组A[p……r]排序的分治过程的三个步骤:分解:数组 A[p……r]被划分为两个(可能空)⼦数组 A[p……q-1] 和 A[q+1……r] ,使得 A[p……q-1] 中的每个元素都⼩于等于 A(q) , ⽽且,⼩于等于 A[q+1……r] 中的元素。

⼩标q也在这个划分过程中进⾏计算。

解决:通过递归调⽤快速排序,对于数组 A[p……q-1] 和 A[q+1……r] 排序。

合并:因为两个⼦数组是就地排序的,将它们的合并不需要操作:整个数组 A[p……r] 已排序。

下⾯的过程实现快速排序(伪代码):QUICK SORT(A,p,r)1if p<r2 then q<-PARTITION(A,p,r)3 QUICKSORT(A,p,q-1)4 QUICKSORT(A,q+1,r)为排序⼀个完整的数组A,最初的调⽤是QUICKSORT(A,1,length[A])。

数组划分: 快速排序算法的关键是PARTITION过程,它对⼦数组 A[p……r]进⾏就地重排(伪代码):PARTITION(A,p,r)1 x <- A[r]2 i <- p-13for j <- p to r-14do if A[j]<=x5 then i <- i+16 exchange A[i] <-> A[j]7 exchange A[i + 1] <-> A[j]8return i+1排序演⽰⽰例假设⽤户输⼊了如下数组:下标012345数据627389创建变量i=0(指向第⼀个数据), j=5(指向最后⼀个数据), k=6(为第⼀个数据的值)。

C语言常见排序算法.ppt

C语言常见排序算法.ppt

1.1.2 快速排序
算法实例:
始关键字
pivotkey 21 25 low
49 25* 16 08 high
一次交换
21
二次交换
三次交换
high-1 完成一趟排序
08 25 low
49 25* 16
high
08
49 25* 16 25
low
high
08 16 49 25*
25
low
08 16
low
常见排序算法
1.1 常见的排序算法
冒泡排序 快速排序 直接插入排序 希尔排序 选择排序 堆排序 归并排序
1.1.1 冒泡排序
算法描述
设待排序记录序列中的记录个数为n 一般地,第i趟起泡排序从1到n-i+1 依次比较相邻两个记录的关键字,如果发生逆序,则交换之 其结果是这n-i+1个记录中,关键字最大的记录被交换到第n-i+1的位 置上,最多作n-1趟。
08 16
21
high 25* 49 25
high 25* 49 25
low high
1.1.2 快速排序
算法实例:
完成一趟排序
08 16
21 25* 49 25
分别进行快速排序 有序序列
08 16
21 25* 25 49
08 16
21 25* 25 49
11
1.1.2 快速排序
算法分析:
快速排序是一个递归过程; 利用序列第一个记录作为基准,将整个序列划分为左右两个子序列。只要 是关键字小于基准记录关键字的记录都移到序列左侧; 快速排序的趟数取决于递归树的高度。 如果每次划分对一个记录定位后, 该记录的左侧子序列与右侧子序列的长 度相同, 则下一步将是对两个长度减半的子序列进行排序, 这是最理想的情 况

c语言的排序方法

c语言的排序方法

c语言的排序方法C语言的排序方法排序是计算机科学中常见的操作,它的作用是将一组数据按照特定的规则进行重新排列。

在C语言中,有多种排序方法可以实现这个目标。

本文将介绍几种常见的排序算法,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。

一、冒泡排序冒泡排序是一种简单但效率较低的排序算法。

它的基本思想是多次遍历待排序的数据,每次比较相邻的两个元素,如果它们的顺序不对就交换它们的位置。

通过多次遍历,最大(或最小)的元素会逐渐“冒泡”到最后。

二、插入排序插入排序是一种稳定且效率较高的排序算法。

它的基本思想是将待排序的数据分为已排序和未排序两部分,每次从未排序部分选择一个元素插入到已排序部分的正确位置。

通过多次插入操作,最终得到完全有序的数据。

三、选择排序选择排序是一种简单但效率较低的排序算法。

它的基本思想是每次从待排序的数据中选择最小(或最大)的元素,然后放到已排序部分的末尾。

通过多次选择操作,最终得到完全有序的数据。

四、快速排序快速排序是一种常用且高效的排序算法。

它的基本思想是通过递归地将待排序的数据分为两部分,一部分小于某个基准值,另一部分大于该基准值。

然后对这两部分分别进行快速排序,直到每个部分只有一个元素或为空。

最后将所有部分合并起来,即得到完全有序的数据。

五、归并排序归并排序是一种稳定且效率较高的排序算法。

它的基本思想是将待排序的数据分成若干个长度相等(或接近)的子序列,然后对每个子序列进行排序。

最后将排好序的子序列两两合并,直到所有子序列合并成一个有序的序列。

不同的排序算法适用于不同的场景。

冒泡排序和选择排序适用于数据量较小的情况,插入排序适用于数据基本有序的情况,快速排序适用于数据量较大且无序的情况,归并排序适用于数据量较大且需要稳定排序的情况。

在C语言中,实现这些排序算法并不复杂。

通过使用循环和条件语句,可以很容易地编写出排序的代码。

同时,为了提高排序算法的效率,还可以使用一些优化技巧,例如设置哨兵、使用递归等。

C语言常见排序算法

C语言常见排序算法

6.1.5 选择排序
排序过程: 排序过程:
首先通过n-1次比较,从n个数中找出最小的, 将它与第一个数 次比较, 个数中找出最小的, 首先通过 次比较 个数中找出最小的 交换—第一趟选择排序, 交换—第一趟选择排序,结果最小的数被安置在第一个元素位 置上 再通过n-2次比较,从剩余的 次比较, 个数中找出关键字次小的记录, 再通过 次比较 从剩余的n-1个数中找出关键字次小的记录, 个数中找出关键字次小的记录 将它与第二个数交换— 将它与第二个数交换—第二趟选择排序 重复上述过程,共经过n-1趟排序后,排序结束 趟排序后, 重复上述过程,共经过 趟排序后
6.1.2 快速排序
算法特点:
快速排序是通过比较关键码、交换记录, 以某个记录为界(该记录称为支点),将待排序列分成两部分 一部分所有记录的关键码大于等于支点记录的关键码 另一部分所有记录的关键码小于支点记录的关键码
6.1.2 快速排序
算法描述:
任取待排序记录序列中的某个记录(例如取第一个记录)作为基准(枢),按照该记录的 关键字大小,将整个记录序列划分为左右两个子序列 左侧子序列中所有记录的关键字都小于或等于基准记录的关键字 右侧子序列中所有记录的关键字都大于基准记录的关键字 基准记录则排在这两个子序列中间(这也是该记录最终应安放的位置)。 然后分别对这两个子序列重复施行上述方法,直到所有的记录都排在相应位置上为 止。 基准记录也称为枢轴(或支点)记录。 取序列第一个记录为枢轴记录,其关键字为Pivotkey 指针low指向序列第一个记录位置 指针high指向序列最后一个记录位置
6.1.3 直接插入排序
算法分析:
关键字比较次数和记录移动次数与记录关键字的初始排列有关。 最好情况下, 排序前记录已按关键字从小到大有序, 每趟只需与前面有序 记录序列的最后一个记录比较1次, 移动2次记录, 总的关键字比较次数 为 n-1, 记录移动次数为 2(n-1)在平均情况下的关键字比较次数和记录 移动次数约为n2/4 。 直接插入排序是一种稳定的排序方法 直接插入排序最大的优点是简单,在记录数较少时,是比较好的办法

快速排序算法c语言

快速排序算法c语言

快速排序算法c语言快速排序算法是一种常用的排序算法,它的时间复杂度为O(nlogn),效率非常高。

快速排序算法的核心思想是分治法,将一个大问题分解成若干个小问题,然后逐个解决这些小问题,最终得到整个问题的解。

快速排序算法的基本思路是:首先选取一个基准元素,然后将数组中小于基准元素的数放在左边,大于基准元素的数放在右边,然后对左右两个子数组分别进行递归排序,最终得到有序数组。

下面是快速排序算法的C语言实现:```void quick_sort(int arr[], int left, int right){if (left < right){int i = left, j = right, pivot = arr[left];while (i < j){while (i < j && arr[j] >= pivot)j--;if (i < j)arr[i++] = arr[j];while (i < j && arr[i] < pivot)i++;if (i < j)arr[j--] = arr[i];}arr[i] = pivot;quick_sort(arr, left, i - 1);quick_sort(arr, i + 1, right);}}```在这个实现中,我们首先选取数组的第一个元素作为基准元素,然后使用两个指针i和j分别指向数组的左右两端。

接着,我们使用while循环来不断移动指针i和j,将小于基准元素的数放在左边,大于基准元素的数放在右边。

最后,我们将基准元素放在i的位置,然后对左右两个子数组分别进行递归排序。

快速排序算法的优点是效率高,但是它也有一些缺点。

首先,它对于已经有序的数组的排序效率非常低,甚至可能退化为O(n^2)的时间复杂度。

其次,它对于数组中存在大量重复元素的情况,也会导致效率降低。

C语言快速排序实例代码

C语言快速排序实例代码

C语言快速排序实例代码C语言快速排序实例代码快速排序是对冒泡法排序的`一种改进。

下面店铺为大家整理了C 语言快速排序实例代码,希望能帮到大家!#include <stdio.h>int qusort(int s[],int start,int end) //自定义函数 qusort(){int i,j; //定义变量为基本整型i=start; //将每组首个元素赋给ij = end; //将每组末尾元素赋给js[0]=s[start]; //设置基准值while(i<j){while(i<j&&s[0]<s[j])j--; //位置左移if(i<j){s[i]=s[j]; //将s[j]放到s[i]的位置上i++; //位置右移}while(i<j&&s[i]<=s[0])i++; //位置左移if(i<j){s[j]=s[i]; //将大于基准值的s[j]放到s[i]位置j--; //位置左移}}s[i]=s[0]; //将基准值放入指定位置if (start<i)qusort(s,start,j-1); //对分割出的部分递归调用qusort()函数if (i<end)qusort(s,j+1,end);return 0;}int main(){int a[11], i; //定义数组及变量为基本整型printf("请输入10个数: ");for(i=1;i<=10;i++)scanf("%d",&a[i]); //从键盘中输入10个要进行排序的数qusort(a,1,10); //调用qusort()函数进行排序printf("排序后的顺序是: ");for(i=1;i<=10;i++)printf("%5d",a[i]); //输出排好序的数组printf(" ");return 0;}下载全文。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 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;
}
感谢下载!
欢迎您的下载,资料仅供参考。

相关文档
最新文档