Java冒泡排序法和选择排序法的实现

Java的冒泡排序法和选择排序法都是常用的排序算法，冒泡排序法和选择排序法的原理都很简单，但是实现方法有一些区别。

冒泡排序法

冒泡排序法的原理是通过不断交换相邻的元素，比较他们的大小，将大的数不断上移或者将小的数下移，直到整个序列排好顺序。

以下是Java实现冒泡排序法的代码：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {10, 8, 6, 4, 2, 1};
        int temp = 0;
        for(int i=0; i<arr.length-1; i++){//外层循环控制排序趟数
            for(int j=0; j<arr.length-i-1; j++){//内层循环控制每一趟排序次数
                if(arr[j]>arr[j+1]){
                temp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

代码解释：

• 外层循环控制排序趟数，长度为n的数组进行n-1趟排序。
• 内层循环控制每一趟排序次数，判断相邻的两个数字，如果前者比后者大，则进行交换。
• 运用Arrays的toString方法输出。

示例：

public class ExampleOne {
    public static void main(String[] args) {
        int[] arr = {3,6,8,2,4,1,9,5};
        System.out.print("原序列：");
        System.out.println(Arrays.toString(arr));
        sort(arr);
        System.out.print("排序后：");
        System.out.println(Arrays.toString(arr));
    }
    // 冒泡排序法
    static void sort(int[] arr){
        int temp;
        for (int i = 0; i < arr.length-1; i++) {//控制排序趟数
            for (int j = 0; j < arr.length-i-1; j++) {//控制每一趟排序次数
                if (arr[j] > arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

输出结果：

原序列：[3, 6, 8, 2, 4, 1, 9, 5]
排序后：[1, 2, 3, 4, 5, 6, 8, 9]

选择排序法

选择排序法的原理是每一趟找到一个最小数，放在数组的最前面或最后面。

以下是Java实现选择排序法的代码：

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {10, 8, 6, 4, 2, 1};
        int temp = 0;
        int minIndex = 0;
        for(int i=0; i<arr.length-1; i++){//外层循环控制排序趟数
            minIndex = i;
            for(int j=i+1; j<arr.length; j++){//内层循环控制每一趟排序次数
                if(arr[j]<arr[minIndex]){
                    minIndex = j;
                }
            }
            if(i != minIndex){
                temp = arr[minIndex];
                arr[minIndex] = arr[i];
                arr[i] = temp;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

代码解释：

• 外层循环控制排序趟数，长度为n的数组进行n-1趟排序。
• 内层循环控制每一趟排序次数，找出最小的数的位置。
• 如果最小的数不在第一个位置，则进行交换。
• 运用Arrays的toString方法输出。

示例：

public class ExampleTwo {
    public static void main(String[] args) {
        int[] arr = {3,6,8,2,4,1,9,5};
        System.out.print("原序列：");
        System.out.println(Arrays.toString(arr));
        sort(arr);
        System.out.print("排序后：");
        System.out.println(Arrays.toString(arr));
    }
    // 选择排序法
    static void sort(int[] arr){
        int minIndex;
        int temp;
        for (int i = 0; i < arr.length-1; i++) {//控制排序趟数
            minIndex = i;
            for (int j = i+1; j < arr.length; j++) {//控制每一趟排序次数
                if (arr[j] < arr[minIndex]){
                    minIndex = j;
                }
            }
            if(minIndex != i){
                temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }
}

输出结果：

原序列：[3, 6, 8, 2, 4, 1, 9, 5]
排序后：[1, 2, 3, 4, 5, 6, 8, 9]

以上是Java冒泡排序法和选择排序法的实现的完整攻略。