排序算法之选择排序、冒泡排序

选择排序

原理

每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕。

基本思想

给定数组：int[] arr={n个数据}; 第一趟排序，在待排序数据arr[1]~arr[n]中选出最小的数据，将他与arr[1]交换；第2趟，在待排序数据arr[2]-arr[n]中选出最小的数据，将它与arr[2]交换，以此类推，直到第n个数据。

实例

数组 int[] arr={5,2,8,4,9,1};

排序思路：

• 第一趟排序： 原始数据：5 2 8 4 9 1
  最小数据1，把1放在首位，也就是1和5互换位置，
  排序结果：1 2 8 4 9 5
• 第二趟排序：
  第1以外的数据{2 8 4 9 5}进行比较，2最小，
  排序结果：1 2 8 4 9 5
• 第三趟排序：
  除1、2以外的数据{8 4 9 5}进行比较，4最小，8和4交换
  排序结果：1 2 4 8 9 5
• 第四趟排序：
  除第1、2、4以外的其他数据{8 9 5}进行比较，5最小，8和5交换
  排序结果：1 2 4 5 9 8
• 第五趟排序：
  除第1、2、4、5以外的其他数据{9 8}进行比较，8最小，8和9交换
  排序结果：1 2 4 5 8 9

代码实现

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {5,2,8,4,9,1,};
        System.out.println("排序前：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
        //选择排序的优化
        for (int i = 0; i < arr.length; i++) {//做第i趟排序
            int k = i;
            for (int j = k + 1; j < arr.length; j++) {//选最小的记录
                if (arr[j] < arr[k]) {
                    k = j;//记下目前找到的最小值所在的位置
                }
                //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
                if (i != k) {//交换a[i]和a[k]
                    int temp = arr[i];
                    arr[i] = arr[k];
                    arr[k] = temp;
                }
            }
            System.out.println();
            System.out.println("交换后：");
            for (int num: arr){
                System.out.print(num+" ");
            }
        }
    }
}
 

debug显式
排序前：
5 2 8 4 9 1 
交换后：
1 2 8 4 9 5 
交换后：
1 2 8 4 9 5 
交换后：
1 2 4 8 9 5 
交换后：
1 2 4 5 9 8 
交换后：
1 2 4 5 8 9 
交换后：
1 2 4 5 8 9

冒泡排序

原理

比较两个相邻的元素，将值最大的元素交换至右端。

思路

依次比较相邻的两个数，将小数放在前面，大数放在后面。第一趟，首先比较第一个数和第二个数，小数放前，大数放后。然后比较第二个数和第三个数，小数放前，大数放后。以此类推，直至最后两个数。然后重复第一趟的步骤，直至排序完成。

优点

每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值。
每进行一趟比较，每一趟少比较一次，一定程度上减少了算法的量。

实例

要排序数组：int[] arr={6,3,8,2,9,1};

• 第一趟排序：
  第一次排序：6和3比较，6大于3，交换位置： 3 6 8 2 9 1
  　第二次排序：6和8比较，6小于8，不交换位置：3 6 8 2 9 1
  　第三次排序：8和2比较，8大于2，交换位置： 3 6 2 8 9 1
  　第四次排序：8和9比较，8小于9，不交换位置：3 6 2 8 9 1
  　第五次排序：9和1比较：9大于1，交换位置： 3 6 2 8 1 9
  　第一趟总共进行了5次比较， 排序结果： 3 6 2 8 1 9
• 第二趟排序：
  　第一次排序：3和6比较，3小于6，不交换位置：3 6 2 8 1 9
  　第二次排序：6和2比较，6大于2，交换位置： 3 2 6 8 1 9
  　第三次排序：6和8比较，6大于8，不交换位置：3 2 6 8 1 9
  　第四次排序：8和1比较，8大于1，交换位置： 3 2 6 1 8 9
  　第二趟总共进行了4次比较， 排序结果： 3 2 6 1 8 9
• 第三趟排序：
  　第一次排序：3和2比较，3大于2，交换位置： 2 3 6 1 8 9
  　第二次排序：3和6比较，3小于6，不交换位置：2 3 6 1 8 9
  　第三次排序：6和1比较，6大于1，交换位置： 2 3 1 6 8 9
  　第二趟总共进行了3次比较， 排序结果： 2 3 1 6 8 9
• 第四趟排序：
  　第一次排序：2和3比较，2小于3，不交换位置：2 3 1 6 8 9
  　第二次排序：3和1比较，3大于1，交换位置： 2 1 3 6 8 9
  　第二趟总共进行了2次比较， 排序结果： 2 1 3 6 8 9
• 第五趟排序：
  　第一次排序：2和1比较，2大于1，交换位置： 1 2 3 6 8 9
  　第二趟总共进行了1次比较， 排序结果： 1 2 3 6 8 9

---

最终结果：1 2 3 6 8 9
由此可见：N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次。

代码实现

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {6,3,8,2,9,1};
        System.out.println("排序前数组为： ");
        for (int num:arr) {
            System.out.print(num + " ");
        }
        for (int i = 0;i < arr.length; i++){//外层控制循环排序趟数
            for (int j = 0; j < arr.length - 1; j++){//内层控制每一趟排序多少次
                if (arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println();
        System.out.println("排序后数组为： ");
        for (int num:arr) {
            System.out.print(num + " ");
        }
    }
}

编译后结果

排序前数组为： 
6 3 8 2 9 1 
排序后数组为： 
1 2 3 6 8 9

字符串倒叙

主要利用String类的toCharArray()方法，把字符串分割成字符数组。

代码实现

public class Stringflushback {
    public static void main(String[] args) {
        //首先，定义一个字符串
        String s1 = "一二三四五六七";
        //System.out.println(s1.toCharArray());
        char[] char1 = s1.toCharArray();
/*
    依次取出数组中的元素
        for (int i = 0; i < char1.length; i++){
            System.out.println(char1[i]);
        }
*/
//        利用for循环倒着取出char数组中的元素
        for (int j = char1.length-1;j>=0;j--){
            System.out.println(char1[j]);
        }
    }
}