冒泡排序

冒泡排序是最为出名的排序算法，一共有八大排序

冒泡代码比较简单，两层循环，外层冒泡轮数，里层依次比较

我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2)

package com.kuang.array;
 ​
 import java.util.Arrays;
 ​
 public class AraayDemo07 {
     public static void main(String[] args) {
         int[] a={1,4,2,3,7,6,5};
         System.out.println(Arrays.toString(arrays(a)));
         System.out.println(Arrays.toString(sort(a)));
         int[] result=mp(a);
         System.out.println(Arrays.toString(result));
 ​
     }
 ​
     //冒泡排序
     //1. 比较数组中两个相邻元素的大小，如果第一个元素大于第二个元素，我们就交换两个元素的位置
     //2. 每一次比较，都会产生一个最大，或者最小的数字
     //3. 下一轮可以少一次排序
     //4. 依次循环，直到结束
     public static int[] sort(int[] array){
         //定义临时变量
         int temp=0;
         //外层循环，判断外层循环运行几次
         for (int i = 0; i < array.length-1; i++) {
             //内层循环，如果第一个元素大于第二个元素，我们就交换两个元素的位置
             for (int j = 0; j < array.length - 1-i; j++) {
                 if (array[j+1]>array[j]){
                     temp=array[j];
                     array[j]=array[j+1];
                     array[j+1]=temp;
                 }
             }
         }
         return array;
     }
 ​
     public static int[] arrays(int[] arrays){
 ​
 ​
         for (int i = 0; i < arrays.length-1; i++) {
             for (int j = 0; j < arrays.length-1-i; j++) {
                 if (arrays[j]>arrays[j+1]){
                     int x=arrays[j];
                     arrays[j]=arrays[j+1];
                     arrays[j+1]=x;
 ​
 ​
                 }
             }
         }
         return arrays;
     }
 ​
 ​
     public static int[] mp(int[] array){
         int x=0;
         for (int i = 0; i < array.length-1; i++) {
             for (int j = 0; j < array.length-1-i; j++) {
                 if (array[j]>array[j+1]){
                    x=array[j];
                    array[j]=array[j+1];
                    array[j+1]=x;
                 }
             }
         }
         return array;
     }
 }

 ​