08.冒泡排序

冒泡排序,就是将一个数组中的元素按照从大到小或者从小到大排序.

int[] nums={9,8,7,6,5,4,3,2,1,0};   //我们将它升序排序

思考的内容:

第一趟比较:8 7 6 5 4 3 2 1 0 9  //交换了9次     第一趟比较时i=0   交换了9次j=9    j=9  可写成j=nums.Length-1-0

第二趟比较:7 6 5 4 3 2 1 0 8 9  //交换了8次     第一趟比较时i=1   交换了9次j=8    j=8  可写成j=nums.Length-1-1

第三趟比较:6 5 4 3 2 1 0 7 8 9  //交换了7次     第一趟比较时i=2   交换了9次j=7    j=7  可写成j=nums.Length-1-2

第四趟比较:5 4 3 2 1 0 6 7 8 9  //交换了6次     第一趟比较时i=3   交换了9次j=6

第五趟比较:4 3 2 1 0 5 6 7 8 9  //交换了5次     第一趟比较时i=4   交换了9次j=5

第六趟比较:3 2 1 0 4 5 6 7 8 9  //交换了4次

第七趟比较:2 1 0 3 4 5 6 7 8 9  //交换了3次

第八趟比较:1 0 2 3 4 5 6 7 8 9  //交换了2次

第九趟比较:0 1 2 3 4 5 6 7 8 9  //交换了1次

外层循环                                      里层循环

由此可见这个是一个循环的嵌套

//总共是10个数,但是比较了9次就完成了排序,故循环九次即可

for(int i=0;i<nums.Length-1;i++)

{

for(int j=0;j<nums.Length-1-i;j++)

{

if(nums[j]>nums[j+1])

{

int temp=nums[j];

nums[j]=nums[j+1];

nums[j+1]=temp;

}

}

}

冒泡排序的练习:

  1. namespace _17.冒泡排序
  2. {
  3. class Program
  4. {
  5. static void Main(string[] args)
  6. {
  7. int[] nums = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }; //我们将它升序排序
  8. /*
  9. 思考的内容:
  10. 第一趟比较:8 7 6 5 4 3 2 1 0 9 //交换了9次 第一趟比较时i=0 交换了9次j=9 j=9 可写成j=nums.Length-1-0
  11. 第二趟比较:7 6 5 4 3 2 1 0 8 9 //交换了8次 第一趟比较时i=1 交换了9次j=8 j=8 可写成j=nums.Length-1-1
  12. 第三趟比较:6 5 4 3 2 1 0 7 8 9 //交换了7次 第一趟比较时i=2 交换了9次j=7 j=7 可写成j=nums.Length-1-2
  13. 第四趟比较:5 4 3 2 1 0 6 7 8 9 //交换了6次 第一趟比较时i=3 交换了9次j=6
  14. 第五趟比较:4 3 2 1 0 5 6 7 8 9 //交换了5次 第一趟比较时i=4 交换了9次j=5
  15. 第六趟比较:3 2 1 0 4 5 6 7 8 9 //交换了4次
  16. 第七趟比较:2 1 0 3 4 5 6 7 8 9 //交换了3次
  17. 第八趟比较:1 0 2 3 4 5 6 7 8 9 //交换了2次
  18. 第九趟比较:0 1 2 3 4 5 6 7 8 9 //交换了1次
  19. */
  20. for (int i = 0; i < nums.Length - 1; i++)
  21. {
  22. for (int j = 0; j < nums.Length - 1 - i; j++)
  23. {
  24. if (nums[j] > nums[j + 1]) // > 进行升序判断
  25. {
  26. int temp = nums[j];
  27. nums[j] = nums[j + 1];
  28. nums[j + 1] = temp;
  29. }
  30. }
  31. }
  32. foreach (var element in nums)
  33. {
  34. Console.WriteLine(element);
  35. }
  36. Console.ReadKey();
  37. }
  38. }
  39. }



 可能会出现的面试题:

(1).不使用第三方变量,交换两个变量的值

(2).冒泡排序

(3).求一个字符串中每一个字母出现的次数.

实际上C#内置了数组排序的方法,我们可以调用Sort(),对代码进行排序.

但是,面试的时候,我们必须手写冒泡排序的原理.

数组的两个方法:

Array数组类  Array类是一个静态类

Sort();方法只能针对数组进行升序排序

Reverse();  方法,会对数组的内容的进行反转.

来自为知笔记(Wiz)

时间: 2024-10-10 17:41:40

08.冒泡排序的相关文章

百度哈斯发卡号是减肥哈卡斯加分了卡斯

http://www.ebay.com/cln/ta_ya20/-/167521224015/2015.02.08 http://www.ebay.com/cln/p-m6466/-/167398283011/2015.02.08 http://www.ebay.com/cln/ta_ya20/-/167521242015/2015.02.08 http://www.ebay.com/cln/p-m6466/-/167398294011/2015.02.08 http://www.ebay.co

克同极用后管期果要议向中如极示听适VybVfesyhpR

社保划到税务征收,将大大提升社保费的征管效率.税务的征管能力是目前而言最强的,以后税务征收社保不是代收,属于本职了. 之前税局要把社保信息和交个税的工资比对起来有困难!现在好了,个税是自己的,社保也是自己的,比对困难?不存在的! 这一变革,会给那些不给员工上社保.不全额上社保的企业致命一击! 最新案例 前段时间的发改委关于限制特定严重失信人乘坐民航的一则意见--发改财金[2018]385号,其中还有税务总局的联合署名. http://weibo.com/20180408PP/2309279811

2015.12.08 数组 冒泡排序

昨天学到的函数,在C语言中是这么叫,而在OC和swift中叫做“方法”. 数组 数组不像是“char”.“int”.“float”之类的类型保存单个数据,数组是用来保存多个相同类型的数据的. 在定义数组的时候,必须要确定数组的元素个数! 例://定义一个数组,拥有5个元素,默然每个元素的值为0 int numsArray[5];   //5 * 4 = 20 //定义一个数组,拥有4个元素,依次是1, 2, 3, 4 int numsArray[] = {1, 2, 3, 4};   //4 *

冒泡排序法2014-6-9 20:08:41

1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.Threading.Tasks; 6 7 namespace 冒泡排序法 8 { 9 class Program 10 { 11 static void Main(string[] args) 12 { 13 int[] nums = {23, 23, 44, 66, 76, 98

经典排序算法学习笔记之一——冒泡排序

一.冒泡排序 1.算法思想: 冒泡排序算法的运作如下: 比较相邻的元素.如果第一个比第二个大,就交换他们两个. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对.这步做完后,最后的元素会是最大的数. 针对所有的元素重复以上的步骤,除了最后一个. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较. 2.伪代码: function bubble_sort (array, length) { var i, j; for(i from 0 to length-1){ for

Html5 冒泡排序演示

冒泡排序(Bubble Sort),是一种计算机科学领域的较简单的排序算法. 它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成. 这个算法的名字由来是因为越大的元素会经由交换慢慢"浮"到数列的顶端,故名. ------------------------------------------------------------------------ 本例是用Html展示,冒泡排序的

【排序】冒泡排序算法

特别说明: 对于算法,重在理解其思想.解决问题的方法,思路.因此,以下内容全都假定待排序序列的存储结构为:顺序存储结构. 冒泡排序思想 冒泡排序与插入排序.简单选择排序一样,都是比较简单的一类排序算法.假设待排序序列为 ,则冒泡排序算法思想如下: 01.设置  =  - 1 (注:0     - 1, 用于标记外层循环迭代): 02.如果  = 0,则排序结束,退出: 03.设置  = 0 (注:0    , 用于标记内层循环迭代): 04.如果  = ,跳转并执行 09 步骤 (即:该趟冒泡排

python与冒泡排序

上一篇文章,介绍了一个非常快的排序算法--桶排序,但是它的缺点就是太耗资源了,这次要实现的算法就不用太耗资源了,它就是冒泡排序. 问题提出: 将以下数据升序排列:9, 2, 8, 6, 4 冒泡排序原理: 冒泡排序就是遍历数据,每次只与下一个数字比较,如果这两个数顺序不对,则与交换过来. 就上面那个问题来说,因为要升序排列,所以数字越大越排在后面.则两个数比较的时候,如果后一个数比当前数小,则顺序不对,要将这两个数交换.遍历的过程如下图: 第一次比较第一和第二个数字,9与2相比较,9比2大,顺序

经典排序算法 - 冒泡排序Bubble sort

 原文出自于 http://www.cnblogs.com/kkun/archive/2011/11/23/bubble_sort.html 经典排序算法 - 冒泡排序Bubble sort 原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换, 这样一趟过去后,最大或最小的数字被交换到了最后一位, 然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子 例子为从小到大排序, 原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 | 第一趟排序(外循环) 第