Java之Algorithm_analysis案例详解

/*
冒泡排序：双层循环
1.外层循环：控制排序轮数，排序数组长度减1（最后一次循环只剩下一个元素，不需要比较，同时数组已完成排序。

2.内层循环：比较数组临近元素大小，确定是否交换位置，对比和交换次数随排序轮数而减少。
*/

public class BubbleSort {
   public void sort(int[] array){
       for(int i=1;i<array.length;i++){//控制轮数
           //比较相邻两个元素，较大的数往后冒泡
           for(int j=0;j<array.length-i;j++){//控制交换次数
               if(array[j]>array[j+1]){//第一个数大于第二个数，进行交换
                   int temp = array[j];
                   array[j] = array[j+1];
                   array[j+1] = temp;
                   System.out.println("第-------"+j+"-------次");
               }
               System.out.println("第"+i+"轮");
               showArray(array);
           }
       }
       showArray(array);
   }
   /*
   显示数组
    */
   public void showArray(int[] array){
       for(int i:array){//遍历数组
           System.out.print("  》"+i);
       }
       System.out.println();
   }
   public static void  main(String[] args) {
       //创建一个数组，这个数组元素是乱序的
       int[] array = {63,4,24,1,3,15};
       System.out.println("数组长度："+array.length);
       System.out.println("=========================");
       //创建冒泡排序类对象
       BubbleSort sorter = new BubbleSort();
       //调用排序方法将数组排序
       sorter.sort(array);
   }

显示结果

数组长度：6
=========================
第-------0-------次
第1轮
》4  》63  》24  》1  》3  》15
第-------1-------次
第1轮
》4  》24  》63  》1  》3  》15
第-------2-------次
第1轮
》4  》24  》1  》63  》3  》15
第-------3-------次
第1轮
》4  》24  》1  》3  》63  》15
第-------4-------次
第1轮
》4  》24  》1  》3  》15  》63
第2轮
》4  》24  》1  》3  》15  》63
第-------1-------次
第2轮
》4  》1  》24  》3  》15  》63
第-------2-------次
第2轮
》4  》1  》3  》24  》15  》63
第-------3-------次
第2轮
》4  》1  》3  》15  》24  》63
第-------0-------次
第3轮
》1  》4  》3  》15  》24  》63
第-------1-------次
第3轮
》1  》3  》4  》15  》24  》63
第3轮
》1  》3  》4  》15  》24  》63
第4轮
》1  》3  》4  》15  》24  》63
第4轮
》1  》3  》4  》15  》24  》63
第5轮
》1  》3  》4  》15  》24  》63
》1  》3  》4  》15  》24  》63

/*直接选择排序：指定排序位置与其他元素比较。交换次数减少。*/

public class SelectSort {
   public void sort(int[] array) {
       int index;
       for (int i = 1; i < array.length; i++) {
           index = 0;
           for (int j = 1; j <= array.length - i; j++)
               if (array[j] > array[index]) {
                   index = j;
               }
           //交换位置array.length-i和index(最大值）上的两个数
           int temp = array[array.length-i];
           array[array.length - i] = array[index];
           array[index] = temp;
       }
       showArray(array);
   }
   /*
   显示数组
    */
   public void showArray(int[] array) {
       for (int i : array) {//遍历数组
           System.out.print("  》" + i);
       }
       System.out.println();
   }
   public static void main(String[] args) {
       //创建一个数组，这个数组元素是乱序的
       int[] array = {63, 4, 24, 1, 3, 15};
       System.out.println("数组长度：" + array.length);
       System.out.println("=========================");
       //创建冒泡排序类对象
       SelectSort sorter = new SelectSort();
       //调用排序方法将数组排序
       sorter.sort(array);
   }
}

运行结果：

数组长度：6
=========================
》1  》3  》4  》15  》24  》63

来源：https://blog.csdn.net/lxj_csdn/article/details/82825476