史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!什么叫冒泡排序依次比较两个相邻的子元素,如果他们的顺序错误就把他们交换过来,重复地进行此过程直到没有相邻元素需要交换,即完成整个冒泡。现在设定一个数组,元素为2,4,3,1我们需要通过冒泡最终排序成1,2,3,4用图来说明一下:那首先我们就对第一个元素2和第2个元素4进行比较,如果第一个元素大于第2个元素则交换位置,否则不交换于是我们编写代码如下int[]arr=newint[]{2,4,3,1};if(arr[0].

什么叫冒泡排序

依次比较两个相邻的子元素,如果他们的顺序错误就把他们交换过来,重复地进行此过程直到没有相邻元素需要交换,即完成整个冒泡。

现在设定一个数组,元素为 2,4,3,1 我们需要通过冒泡最终排序成1,2,3,4 用图来说明一下:

那首先我们就对第一个元素2和第2个元素4进行比较,如果第一个元素大于第2个元素则交换位置,否则不交换

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

于是我们编写代码如下

      int[] arr = new int[] { 2, 4, 3, 1 };
      
      if(arr[0]>arr[1]){//第一个元素大于第2个元素则执行交换,否则不做操作
         int temp = arr[1];
         arr[1] = arr[0];
         arr[0] = temp;
      }

执行后发现不需要交换,于是得到顺序如下

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

再来处理第2个元素和第3个元素:

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

于是我们代码编写如下:

      int[] arr = new int[] { 2, 4, 3, 1 };
      
      if(arr[0]>arr[1]){
         int temp = arr[1];
         arr[1] = arr[0];
         arr[0] = temp;
      }
      
      if(arr[1]>arr[2]){
         int temp = arr[2];
         arr[2] = arr[1];
         arr[1] = temp;
      }

执行后发现,4大于3 需要交换位置,交换完后顺序如下:

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

再来比较最后两个元素,也就是现在的4和1

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

于是我编写代码如下:

      int[] arr = new int[] { 2, 4, 3, 1 };
      
      if(arr[0]>arr[1]){
         int temp = arr[1];
         arr[1] = arr[0];
         arr[0] = temp;
      }
      
      if(arr[1]>arr[2]){
         int temp = arr[2];
         arr[2] = arr[1];
         arr[1] = temp;
      }
      if(arr[2]>arr[3]){
         int temp = arr[3];
         arr[3] = arr[2];
         arr[2] = temp;
      }

发现次数4大于1需要换行位置,结果如下

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

至此我们完成了第一次冒泡,最大的元素4冒泡到最后,现在来优化一下这段代码

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

细看这段代码,我们很容易发现规律,这里面的0,1,2,3不就是元素对应的下标吗?执行的次数刚好是数组的长度减1,那我们用循环不就可以了,修改以后:

      int[] arr = new int[] { 2, 4, 3, 1 };
     
      for(int j = 0; j < arr.length-1; j++){
         if(arr[j]>arr[j+1]){
            int temp = arr[j + 1];
            arr[j + 1] = arr[j];
            arr[j] = temp;
         }
      }

第二次冒泡

因为4已经移动到最后了,此时需要排序的就剩下前面3个元素了

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

那这个代码就很好写了,无非就是比上一次循环少一个元素

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

在上次循环的基础上,循环的判断条件减去1,就可以达到这个效果

      int[] arr = new int[] { 2, 4, 3, 1 };
     
      for(int j = 0; j < arr.length-1; j++){
         if(arr[j]>arr[j+1]){
            int temp = arr[j + 1];
            arr[j + 1] = arr[j];
            arr[j] = temp;
         }
      }
      
      
      for(int j = 0; j < arr.length-1-1; j++){
         if(arr[j]>arr[j+1]){
            int temp = arr[j + 1];
            arr[j + 1] = arr[j];
            arr[j] = temp;
         }
      }

运行后此时的顺序是这样的 2 1 3 4

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

第三次冒泡

还需要比较前面两个元素,那我们加上代码

      int[] arr = new int[] { 2, 4, 3, 1 };
     
      for(int j = 0; j < arr.length-1; j++){
         if(arr[j]>arr[j+1]){
            int temp = arr[j + 1];
            arr[j + 1] = arr[j];
            arr[j] = temp;
         }
      }
      
      for(int j = 0; j < arr.length-1-1; j++){
         if(arr[j]>arr[j+1]){
            int temp = arr[j + 1];
            arr[j + 1] = arr[j];
            arr[j] = temp;
         }
      }
      
      for(int j = 0; j < arr.length-1-2; j++){
         if(arr[j]>arr[j+1]){
            int temp = arr[j + 1];
            arr[j + 1] = arr[j];
            arr[j] = temp;
         }
      }

我们来运行一下,看看结果

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

结果就是1,2,3,4 至此效果已经实现了,但是代码还是需要改进的,来看看目前代码的规律

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

我们很容易发现其实除了图中框住的以外,都是相同的,是不是在这里做做文章呢,如果我再加一个东西是不是你就看出规律了

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

从0到1到2,是不是很像数组的下标,而且是依次递增的,让我们很容易的想到这里可以再次利用数组的循环,同时我们把图中的里面0,1,2换成对应的下标就好了

      for (int i = 0; i < arr.length-1; i++)
      {
         for(int j = 0; j < arr.length-1-i; j++){
            if(arr[j]>arr[j+1]){
               int temp = arr[j + 1];
               arr[j + 1] = arr[j];
               arr[j] = temp;
            }
         } 
      }

甚至还可以把 arr.length-1 这个判断添加再提出来

      int[] arr = new int[] { 2, 4, 3, 1 };
     
      int condition = arr.length-1;
      for (int i = 0; i < condition; i++)
      {
         for(int j = 0; j < condition-i; j++){
            if(arr[j]>arr[j+1]){
               int temp = arr[j + 1];
               arr[j + 1] = arr[j];
               arr[j] = temp;
            }
         } 
      }

修改数据再试一下

   public static void main(String[] args)
   {
      int[] arr = new int[] { 2000, 400, 30, 100,50,60 };
     
      int condition = arr.length-1;
      for (int i = 0; i < condition; i++)
      {
         for(int j = 0; j < condition-i; j++){
            if(arr[j]>arr[j+1]){
               int temp = arr[j + 1];
               arr[j + 1] = arr[j];
               arr[j] = temp;
            }
         } 
      }
      
      for (int i = 0; i < arr.length; i++)
      {
         System.out.print(arr[i] + " ");
      }
   }

运行结果

史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!

欢迎指正!如果觉得还不错就给个三连咯!

今天的文章史上最详细最简单的冒泡排序,一学就会,一看就懂,一面试就懵!分享到此就结束了,感谢您的阅读。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/8658.html

(0)
编程小号编程小号

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注