JavaDay04--Notes（冒泡排序+插入排序+快速排序）

数组排序：

1. 冒泡排序

     共有n个数据，则需要进行n-1趟排序(可优化)，每一趟排序都会通过“两两交换”的方式对数据进行比较，每一趟排序后都会将本趟排序的最大值“冒”到后面。

package sort;

public class BubbleSort {

   public static void main(String[] args) {

      int[] a={22,55,11,66,88,77,44,99,33};

        bubbleSort(a);

   }

  

   public static void bubbleSort(int[] a){

      for (int i = 1; i <=a.length-1; i++) {   // 外层循环控制比较的“趟数”

      // System.out.println("开始第"+i+"趟排序");

        boolean flag=true;

       

        for(int j=0;j<a.length-i;j++){   // j变量是数组的索引(下标)，j也控制着当前趟的“两两比较”的次数

           if(a[j]>a[j+1]){

              int temp=a[j];

              a[j]=a[j+1];

              a[j+1]=temp;

              flag=false;

           }

        }

      // System.out.println("第"+i+"趟结束");

        if(flag){   // 如果当前“趟”已经排号序，则不必进行下一趟的排序，直接跳出外层循环

           break;

        }

      /**  

        System.out.println("第"+i+"趟排序结果：");

        for(int x:a){

           System.out.print(x+"  ");

        }

       

        System.out.println();

        **/

      }

   }

}

 

2. 插入排序

对一个有n个元素的数据序列，排序需要进行n-1趟插入操作(可优化)。

第一趟插入将第2个元素插入前面的有序子序列(此时前面只有一个元素)。

第二趟插入将第3个元素插入前面的有序子序列，前面两个元素是有序的。

第n-1趟插入将第n个元素插入前面的有序子序列，前面n-1个元素是有序的。

package sort;

public class InsertSort {

   public static void main(String[] args) {

      int[] a={22,55,11,66,88,77,44,99,33};

        insertSort(a);

        System.out.println("插入排序的结果：");

        for (int i = 0; i < a.length; i++) {

        System.out.print(a[i]+"  ");

      }

   }

  

   public static void insertSort(int[] a){

      for (int i = 1; i <=a.length-1; i++) {

        int data=a[i];  // 当前“指示灯数据”

        int j=i-1;   // 使用j变量记录“指示灯数据”的前一个数据的索引

        while(j>=0 && data<a[j]){

           a[j+1]=a[j];   // 后移“指示灯”数据前面的数据

           j--;

        }

        a[j+1]=data;

      }

   }

}

 

3. 快速排序

（1）从待排序的数据序列中任取一个数据(如第一个数据)作为分界值，所有比它小的数据元素放到左边，所有比它大的数据元素放到它的右边。

（2）对左右两个子序列按照上述方法进行递归排序，直到排序完成。

package sort;

public class QuickSort {

   public static void main(String[] args) {

      int[] a={22,55,11,66,88,77,44,99,33};

      quickSort(a,0,a.length-1);

      for (int i = 0; i < a.length; i++) {

        System.out.print(a[i]+"  ");

      }

   }

  

   public static void quickSort(int[] array,int start,int end){

      if(start>=end){

        return;   // 结束方法

      }

      int data=array[start];   // 将起始索引执行的值作为“分界值”

      int i=start+1;  // 记录向右移动的位置（“红军”）

      int j=end;   // 记录向左移动的位置("蓝军")

      while(true){

        while(i<=end && array[i]<data){

           i++;   // 索引右移

        }

        while(j>=start+1 && array[j]>data){

           j--;   // 索引左移

        }

        if(j>i){

           int temp=array[i];

           array[i]=array[j];

           array[j]=temp;

        }else{

           break;

        }

      }

      // “蓝军”与“分界值”交换位置

      array[start]=array[j];

      array[j]=data;  

      quickSort(array,start,j-1);   // 递归调用完成“分界值”左边的排序

      quickSort(array,j+1,end);   // 递归调用完成“分界值”右边的排序

   }

}

Copyright © 2017 Jin Hanquan. All rights reserved.