C 计数排序，C 快速排序

1.计数排序称为 countingsort，而不是 choicesort

2.void choicesort（ int a，int n ）n 表示数组元素的数量，而 while（ k < n ）k 表示元素下标，下标与元素数量相比不正确，应改为 while（k < n - 1）。

3. for( i = 0 ; i < n ;i++会出现重复比较，如果当前元素是第3个，那么这个**也是从第一个元素开始比较的，其实前两个元素已经按顺序排列好了，所以改成for（ i = k + 1 ; i < n ;i++ 开始与当前元素的下一个进行比较。

4.在一行中做一件事，不要在同一行上定义多个变量。

5.程序应该将函数模块化为只做一件事，而不仅仅是排序、输出结果并将输出提取到外部。

#include

using namespace std;

void countingsort( int a,int n )int count = 0 ;

int k = 0 ;

while( k < n - 1)

for( int i = k + 1 ; i < n ; i++if( a[k] >a[i] )

count++;

if(count == 0)

k++ if( count > 0 )

swap( a[k] ,a[count] )count = 0;

void output(int a,int n)for(int i = 0 ; i < n ; i++cout int n = 5 ;

int a[5] = ;

countingsort( a , 5 );

output(a, 5) ;

system("pause");

return 0;

我不知道你想做什么.........

#include

using namespace std;

void choicesort( int a,int n )int count = 0, i , k = 0;

while( k < n )

for( i = 0 ; i < n ; i++if( a[k] >a[i] )

count++;

if( count > 0 )

swap( a[k] ,a[count] )int temp = a[k];

a[k] = a[i] ;

a[i] = temp;

if( count == 0 )

k++;永远不可能进去，明白吗？

count = 0;

for( i = 0 ; i < n ; i++cout int main()

int n = 5,a[5] = ;

choicesort( a , n );

system("pause");

return 0;

你的k永远不会进入，所以你永远不会离开循环......但是你的算法能解释这一点吗？ 我不明白。。。。。。无论如何里面有一股东西的味道。

int temp = a[k];

你在这里创建一个断点，然后逐步执行并查看结果。

你的程序呢，它是一个无限循环吗？

是的，你为什么不发布这个程序？

冒泡分拣。

工作原理：它重复访问要排序的序列，一次比较两个元素，如果它们的顺序错误，则将它们交换。 重复访问该系列的工作，直到不再需要交换，即序列已被排序。

以下是气泡排序算法的工作原理：

1.比较相邻元素。 如果第一个比第二个大，请交换它们。

2.对每对相邻元素执行相同的工作，从第一对开始，到最后一对结束。 此时，最后一个元素应该是最大的。

3.对除最后一个元素之外的所有元素重复上述步骤。

4.每次重复上述步骤，使元素越来越少，直到没有数字对进行比较。

**如下：包括

using namespace std;

int main();

int i,j,t;

for(i=0;i<9;i++） ，下沉到最大数量。

一种 10 个数字，下沉到 9 个最大的数字，你可以排序。

for(i=0;i<10;i++)

cout<

return 0;

分析：通过逐二比较，第一次排序会将最大的数字 88 放入最后一个 a[9] 中。 第九次行程，a[1]=2，然后排序完成。

选择排序方法。

原理：选择顺序的基本思想是每次行程都在 n-i+1（i=1,2,...n-1） 关键字最低的记录被选为有序序列中的第 i 条记录。

第 i 次简单选择排序是指通过对 n-i 个关键字的比较，从 n-i+1 个记录中选取关键字最小的记录，并与第 i 个记录进行交换。 总共执行 I-1 比较，直到所有记录都排序完毕。 例如：

在第 i 轮评选中，从当前候选记录中选出关键字最低的 k 号记录，并与第 i 条记录交换。

**如下：包括

using namespace std;

int main();

int i,j,t,k=0;

for(i=0;i<9;i++)

t=a[k];

a[k]=a[i];

a[i]=t;

for(i=0;i<10;i++)

cout<

return 0;}

#include

using namespace std;

int a[100];

int i,j,k,n,m;

int main()

n=10;for (i=1;i<=n;i++)

cin>>a[i];

sort(a+1,a+n+1);从小到大的快速排序，时间复杂度O（n log N）C++ STL自带。

for (i=1;i<=n;i++)

cout<

本段**是用do....while语句设计有外循环，条件是i小于j（i为左下标，j为右下标），这意味着如果两边的下标交错，循环就会停止，内层的两个循环用来比较中间值两侧的数组元素， 当左边元素的值小于中间值时，取下一个元素与中间值比对，否则退出第一个内循环;当右侧的值大于中间值时，将前一个元素与中间值进行比较，否则启动第二个内循环; 然后判断 i 的值是否小于或等于 j，（这一行不能删除，因为你输入的值可能大于 j，这里你必须在执行前判断它），如果是这样，则将 i 和 j 作为下标交换两个元素值，继续外循环。 当外循环结束时，以数组的第一个元素递归调用函数到以 j 为下标的元素（递归知道喇叭，即函数被重复调用，但递归函数需要知道两个条件，结束条件和递归关系），同时， 将 i 作为数组元素到数组元素的最后一个参数的下标的数组元素也作为参数递归调用。

依此类推，直到您知道按从小到大的顺序重新排列数组元素。 （=登录时不能去，否则当a[i]a[j]等于中间值时，以后会有问题**）。

这是对折的排序方法，我会费心为你敲掉段落**。

#include

声明函数。 void celerityrun(int left,int right,int array);

int main()

从小到大排序。

celerityrun(0,9,a);

输出数组。 for(i=0;i<10;i++)

return 0;程序结束。

void celerityrun(int left,int right,int array)

while(i<=j);如果两边的下标交错出现，请停止（完成一次）。

递归左半。

if(lefti)

celerityrun(i,right,array);

我玩腻了，希望对你有帮助，我只是大一新生，我有问题要一起讨论！

你在使用二分法吗？ 建议跟着敲书，实在是满是错误，改不了。。。

快速行 您可以简单地使用 排序 （排序速度最快） 简单包括

#include

using namespace std;

int main()

如果是不同类型的排序（例如结构体），你可以去互联网上找到更高级的 qsort 函数。

实际上，排序的原理很容易理解。

排序过程：

1.在每次排序中，首先在数组中间取出一个数字（中间）进行排序

2.使用两个指针（i，j）从前端和后端扫描数组到中间，要求将比中间较大的数字放在后面，将较小的数字放在前面。

3. 确定 i 指向的数字大于 mid，j 指向的数字小于 mid，然后交换以使阵列满足步骤 2 的条件并继续扫描。

直到扫描整个阵列。

4.扫描后，会有j=i-1。 而且，数组满足从左边到j的数字不大于mid，从i到右边的数字不小于mid（即右边的数字大于左边的数字，但顺序不一定在两边之内）。

5.取第四步的分界，分别递归左右两边，用排序功能继续整理（所以前一个应该判断l r）。

6. 数组将被编号，直到所有数组都是递归的。

数组 c 的大小未确定。

我不知道你说的是哪七个。 我不认为有这样的数字。 我会拿起一些我熟悉的东西来谈论它。

第一个是 o（log（n））。

1.快速行。 除了面试，我没找到什么地方用手写快行，不过这个东西真的是又快又好写，记得有个枢轴，然后两个光标，分而治之，看c**你就知道细节**就可以了;

2. 合并。 该算法时间稳定，效率高，合并排序，顾名思义，就是从基本元素进行排序合并，得到结果。 根据个人经验，合并一般用于链表，相邻表的排序会更愉快;

接下来是 O（N2）：

3、4、5、选择、插入、气泡...... 记住这个原因没关系，你根本不需要写它。

如果您愿意，您可以在开始时选择最小或最大的一个。

如果你插入它，这很容易说，也就是说，当你平时在整理钱包或整理书籍时，你只需插入和分类，只要记住这一点。

冒泡，也许比较常用，找到一个数字和号码周围的顺序不对，就换一下，这就是冒泡。

还有什么？ 桶排（红衣主教）？ 山丘分类？ 这些都比较冷门。虽然在特殊的地方，想法还是需要用到的，但一般顺序不涉及这些。

另外还有排序和qsort，这些都是学习思维，没有必要手写，除非你想搞acm之类的。

需要这方面的帮助吗？ 私聊。

首先，这是一个快速排序算法，你也应该知道，快速排序就是选择序列中的一个元素作为基准，通过一个循环找到这个基准的最终位置，把所有小于这个基准的元素移动到这个位置的左边，把大于基本坐标的元素向右移动， 这样基准面的左右两侧就递归地称呼自己，最后可以得到排序结果。

我们再解释一下这个例子，它选择的基准是 v[（left+right） 2]，然后交换这个基准 rain v[left]，现在假设你想从头到尾排序，那么你就向左传递一个 0，也就是说，他会把这个基准换成 v[0]，这时开始循环， 因为第一个元素是基准，所以从第二个元素（即left+1）开始循环，然后转到if判断部分，if v[i]。< v[left]，也就是说此时至少有一个元素比基准面小，所以基准面至少是 v[1] 或更晚，所以他交换了你发现比基准面小的 v[i] 和 v[++last]，并且 v[i] 的位置已经在基准面的正确位置或之前， 不是在基准之后，所以这意识到在将小于基准的元素移动到基准的正确位置之前，你说的 [在第一次执行中，第 8 行 last=left=0，那么在第 11 行它相当于交换 v[1] 和 v[0+1]] 这没有错，它确实在交换自己， 但这与之前的想法并不矛盾，对吧？当 if 条件不满足时，最后一个不会增加，但 i 总是会加 1，所以最后一个和 i 会不同，这是在将小于基准的元素移动到基准之前，每当有一个小于基准的元素时，最后一个就会加 1，这样当你循环遍历最后一个值时，就是基准应该在的位置， 而这个时候，所有小于基本元素的元素也在最后一个之前，这个时候最后一个位置的元素也比基准小，这没关系，因为后面有一个句子swap[v，last，left]，到现在的位置，就找到了基准的位置， 基准左侧的元素小于基准，右侧的元素大于基准，然后在基准的左右两侧递归调用自己，序列排序。