冒泡排序

冒泡排序

      冒泡排序又叫做交换排序,两两比较,根据自身的大小一点一点往一侧移动

思想:

  相邻的元素两两比较，根据大小来交换元素的位置,每冒泡一遍,有序数列+1

原始的冒泡排序是稳定排序。由于该排序算法的每一轮要遍历所有元素，轮转的次数和元素数量相当，所以时间复杂度是O（N^2） 。

冒泡排序第一版:

public class BubbleSort{
    private static void sort(int array[]){
         int tmp = 0;
         for(int i = 0; i<array.length;i++){
              for(int j = 0; j < array.length-i-1; j++){
                    if(array[j] > array[j+1]){
                       tmp = array[j];
                       array[j] =  array[j+1];
                       array[j+1] = tmp;
                    }
               }
         }
    }
public static void main (String [] args) {
   int [] array = new int [] {1,2,3,2,5,9,5,6,3}
   sort(array);
   System.out.println(Arrays.toString(array));
}
}

第一版这个代码需要优化,加入排序到最后几步,后面的数据已经有序了,但是我们还是要一步一步的去比较,很浪费时间,所以此代码需要优化

第二版:

private static void sort( int array[])
{
    int tmp  = 0;
    for( int i = 0 ; i < array.length ; i++)
    {
        //有序标记，每一轮的初始是true
        boolean isSorted = true ;
        for(int j = 0; j < array.length - i - 1; j++)
        {
            if(array[j] > array[j+1])
            {
                tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
        //有元素交换，所以不是有序，标记变为false
                isSorted = false;
            }
        }
        if(isSorted){
             break;
        }
    }
}
public static void main( String [] args){
    int[] array = new int[]{5,8,6,3,9,2,1,7};
    sort(array);
    System.out.println(Arrays.toString(array));
}

优化三:冒泡排序中的有序数列远远不止这个长度,例如:2,4,3,1,5,6,7,8
第三版:

private static void sort(int array [])
{
    int tmp  = 0;
    
   //记录最后一次交换的位置
    int lastExchangeIndex = 0;
    
  //无序数列的边界，每次比较只需要比到这里为止
    int sortBorder  = array.length -1;
    for(int i =0;i <array.length;i++)
    {
        //有序标记，每一轮的初始是true
        boolean isSorted = true;
       for(int j =0; j < sortBorder;j++)
      {
         if(array[j]>array[j+1])
            {
                tmp =array[j];
                array[j]=array[j+1];
                array[j+1]=tmp;
                
       //有元素交换，所以不是有序，标记变为false
                isSorted =false;
                
       //把无序数列的边界更新为最后一次交换元素的位置
                lastExchangeIndex =j;
            
}
        
}
        sortBorder =lastExchangeIndex;
        if(isSorted){
            break;
        }
    }
}
public static void main(String []args){ int [] array = new int []{ 3,4,2,1,5,6,7,8};
    sort(array);
    System.out.println(Arrays.toString(array));
}