Java基础 20 冒泡排序

  冒泡排序:

• 冒泡排序无疑是最出名的排序算法之一，总共有八大排序！

• 冒泡的代码还是相当简单，两层循环，外层冒泡轮数，内层依次比较，江湖中人人尽皆知

• 排序思想：相邻两个元素进行比较，如果需要则进行交换，每完成一次循环是将其它数进行类似操作

  (相邻的两个元素进行比较，如果需要则交换)

     每次比较都会产生出一个最大或者最小的数字。

class Bubbling
{
    public static void main(String[] args) {
        int x[]={1,2,4,5,9,2,3};
        int temp;
        for (int i = 1; i < x.length; i++)
        {
            for (int j= 0; j< x.length-i; j++) {
                if (x[j] <x[j + i]) {
                    temp = x[j];
                    x[j] = x[j + 1];
                    x[j + 1] = temp;
                }
            }
        }
        for (int i = 0; i < x.length; i++)
        {
            System.out.print(x[i]+" ");//5 4 9 2 2 3 1 
​
        }
    }
}

 

//4,7,3,1
//4和7比,交换谁大就放在后面4和7，7和3比，交换后3和7，7和1比，最大是7，第一轮4 3 1 7
//4和3比 交换后3和4，4和1比 交换后1和4 所以最大值为4，第二轮3 1 4 7
//3和1比 交换后1和3 第三轮1 3 4 7
  int [] arr=new  int[] {4,7,3,1};
  int temp=0;
  for (int i = 0; i < arr.length-1; i++) //外循环是循环轮次，轮次循环的次数是数字长度-1
      
  {
    for (int j = 0; j < arr.length-1-i; j++)//每一轮数字对比 ,每轮次的循环依次432，轮次长度-1-i；
    {
        if (arr[j] >arr[j+1])//如果要是两个相邻的元素，前面的大于后面的，前后两个值交换
        {
            temp=arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=temp;
        }
    }
    
  }
for (int i = 0; i < arr.length; i++) 
{
 System.out.println(arr[i]);
}

 

package src1;
​
import java.util.Arrays;
​
public class Demo33 
{
    public static void main(String[] args) 
    {
        
    int [] a= {1,35,64,2,5,8,44};
      int[] sort= sort(a);//调用完返回新的数组，（调用完我们自己写的排序方法以后，返回一个排序后的数组）
      System.out.println(Arrays.toString(sort));
    /*
     * 冒泡排序
     * 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置
     * 每一次比较，都会产生出一个最大，或者最小的数字：
     * 下一轮则可以少一次排序！
     * 依次循环，直到结束！
     */
    }
    public static int[] sort(int [] array) 
    {
        int temp=0;
       for (int i = 0; i < array.length; 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;
    }
}

 

优化

package src1;
​
import java.util.Arrays;
​
public class Demo33 
{
    public static void main(String[] args) 
    {
        
    int [] a= {1,35,64,2,5,8,44};
      int[] sort= sort(a);//调用完返回新的数组，（调用完我们自己写的排序方法以后，返回一个排序后的数组）
      System.out.println(Arrays.toString(sort));
    /*
     * 冒泡排序
     * 比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置
     * 每一次比较，都会产生出一个最大，或者最小的数字：
     * 下一轮则可以少一次排序！
     * 依次循环，直到结束！
     */
    }
    public static int[] sort(int [] array) 
    {
        int temp=0;
       for (int i = 0; i < array.length; i++) 
       {
           boolean falg=false;//通过flag标识位减少没有意义的比较
        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;
               falg=true;
            }
        }
        if (falg=false) 
        {
            break;
        }
       }    
       return array;
    }
}