冒泡排序没缓过来~

1. int[] scores = { 18, 20, 48, 76, 20, 38, 87, 90, 37, 65, 65, 67, 95 };
   
2. for (int i = 0; i < scores.Length - 1; i++)//控制比较的趟数，这个循环一次表示比较了一趟
   
3. {
   
4. for (int j = 0; j < scores.Length - 1 - i; j++)
   
5. {
   
6. if (scores[j] < scores[j + 1])
   
7. {
   
8. int temp = scores[j];
   
9. scores[j] = scores[j + 1];
   
10. scores[j + 1] = temp;
    
11. }
    
12. }
    
13. }
    
14. for (int i = 0; i < scores.Length; i++)
    
15. {
    
16. Console.WriteLine(scores[i]);
    
17. }

复制代码

李礼彬 发表于 2013-5-16 15:15
过程上边两位说得很清晰了，给你个冒泡排序速记口诀（升序）：
N个数字来排队，两两相比小靠前，外层循环N- ...

灰常感谢~

郑丹丹1990 发表于 2013-5-16 11:07
冒泡排序，第一趟将最大（小）值确定并放在确定的位置上。于是第二趟我们比较的次数就减一。
例：18, 20, 4 ...

灰常感谢~

shenge321 发表于 2013-5-16 14:42
你的代码最主要思想就是，把最大的值不停的移到数组前面去，那些小的值自然排到数组末尾了。
流程走一遍。 ...

灰常感谢

过程上边两位说得很清晰了，给你个冒泡排序速记口诀（升序）：
N个数字来排队，两两相比小靠前，外层循环N-1，内层循环N-1-i。如果要降序排序，只要把程序中的大于号换成小于号就行了。
想了解这样的排序，最好的方法就是设断点，一步步的看怎么走，能看明白每一步走的过程，这个排序你就已经熟悉了

你的代码最主要思想就是，把最大的值不停的移到数组前面去，那些小的值自然排到数组末尾了。
流程走一遍。索引是从0开始的，它的最大值就是数组元素总数-1.
1.执行最外层for循环的表达式1，i=0，执行该for循环的表达式2，即步骤2
2.判断此时i的值是否大于数组的长度，有两个分支
分支A.如果i的值小于数组长度，则执行第二层for循环的表达式1，即步骤3
分支B.如果i的值大于或等于数组长度，则不再执行该for循环，程序向下执行，进入管理输出的for循环，即步骤10
3.执行第二层for循环的表达式1，j=0，执行该for循环的表达式2，进入步骤4
4.判断此时j的值是否大于数组的长度，有两个分支
分支A.如果j的值小于数组长度，则执行第二层for循环里的程序块，进入步骤5
分支B.如果j的值大于或等于数组长度，则不再执行该for循环，程序执行最外层for循环的i++，此时不经过表达式1，直接执行其表达式2，即步骤2
5.执行if语句，判断scores[0]是否小于scores[1]，从数组scores里看出，此条件成立，向下执行
6.执行if判断语句的条件，判断执行那个分支（索引是从0开始的，第X位的x是从1开始的，故x=索引+1）
分支A.如果第i+1位元素的值比第i+2位元素的值小，则执行temp=scores[0]，scores[0]=scores[1]，scores[1]=temp。程序块执行完成，则执行第二层for循环的j++，进入步骤4
分支B.如果第i+1位元素的值比第i+2位元素的值大，符合我们的要求，即数组中的元素，从大到小排列。故不执行if语句里的程序块，直接执行第二层for循环的j++，进入步骤4
7.j++后，直接执行表达式2，即其值与数组scores的长度相比，仍然小于数组长度。向下执行步骤5
8.当第二层循环的j经过多次j++，它的值大于或等于数组的长度，则第二层循环结束，开始执行最外层for循环的i++
9.经过i++后，判断此时i的值是否大于数组的长度，决定执行步骤2的分支A，还是分支B
10.当跳出最外层的那个for循环后，开始输出排序结果。因为输出的是数组数据，需要循环来遍历数组，将其元素逐一输出。

冒泡排序，第一趟将最大（小）值确定并放在确定的位置上。于是第二趟我们比较的次数就减一。
例：18, 20, 48, 76, 20, 38, 87, 90, 37, 65, 65, 67, 95 （降序排列）
第一趟把最大值找到放在第一个位置上，18和20比较：18>20于是20和18交换；
此时数组为：20,18，48, 76, 20, 38, 87, 90, 37, 65, 65, 67, 95
18和48比较：18<48，于是18和48不交换；
此时数组仍为：20,18，48, 76, 20, 38, 87, 90, 37, 65, 65, 67, 95
48和76比较：48<76，于是48和76不交换；
此时数组仍为：20,18，48, 76, 20, 38, 87, 90, 37, 65, 65, 67, 95
76和20比较：76>20,于是76和20交换；
此时数组为：此时数组仍为：20,18，48, 20, 76, 38, 87, 90, 37, 65, 65, 67, 95

依次类推：当第一趟跑完后，那么95（最大值）就排在了最后的位置上，此时也只有95的位置被确定。（此时比较的数字的个数为：数组总长度）

那么当第二趟跑完，90（倒数第二大的值）的位置就确定了。（此时比较的数字的个数为：数组总长度-1）
第三趟跑完，87（倒数第三大的值）的位置就确定。（此时比较的数字的个数为：数组总长度-2）


冒泡排序（升序）就像鱼吐泡一样，最大值最先确定。