冒泡排序、选择排序

冒泡排序

算法原理

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

Java语言实现

public class BubbleSort {
    public static void main(String[] args) {

        //声明一个数组并赋值
        int[] arr = {94,23,51,2,86,44,27,10};

        System.out.println("--------冒泡排序--------");
        System.out.println("排序前：");
        for(int x:arr){
            System.out.print(x+"\t");
        }
        System.out.println();

        //声明并初始化一个变量
        int temp=0;

        //将数组中的值从小到大排序
        //外层循环，需循环arr.length-1次
        for(int i=0; i<arr.length-1; i++){

            //内层循环，比较数组中前arr.length-i个数值，
            //两两比较，将最大值交换到arr[arr.length-1-i]中
            for(int j=0; j< arr.length-1-i; j++){
                if(arr[j] > arr[j+1]){//判断是否需要交换

                    //交换数值
                    temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println("从小到大排序：");
        for(int x:arr){
            System.out.print(x+"\t");
        }
    }
}

运行结果

--------选择排序--------
排序前：
94 23 51 2 86 44 27 10
从小到大排序：
2 10 23 27 44 51 86 94

选择排序

算法原理

1. 第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置。
2. 再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。
3. 以此类推，直到全部待排序的数据元素的个数为零。

Java语言实现

public class SelectionSort {
    public static void main(String[] args) {

        //声明一个数组并赋值
        int[] arr = {38,18,44,83,29,66,1,23,41,7};

        //打印出未排序的数组的值
        System.out.println("--------选择排序--------");
        System.out.println("排序前：");
        for(int x:arr){
            System.out.print(x+"\t");
        }
        System.out.println();

        //声明两变量并初始化
        int temp=0,orderNumber=0;

        for(int i=0;i<arr.length;i++){//交换次数

            //假设数组中最小值的下标为i
            orderNumber=i;

            //遍历数组中剩下未排序的值,与arr[orderNumber]比较大小
            //将较小值的下标存入orderNumber，循环结束，得到最小值的下标
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[orderNumber]){
                    orderNumber=j;
                }
            }

            //判断是否需要交换位置，如需要，借助temp变量将最小值与arr[i]交换位置
            if(orderNumber != i){
                temp = arr[i];
                arr[i] = arr[orderNumber];
                arr[orderNumber] = temp;
            }
        }

        //排序完成，输出排好序的数组
        System.out.println("从小到大排序：");
        for(int x:arr){
            System.out.print(x+"\t");
        }

        System.out.println();

        //从大到小排序，不同的在于arr[j]>arr[orderNumber]与arr[j]<arr[orderNumber];
        for(int i=0;i<arr.length;i++){
            orderNumber=i;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]>arr[orderNumber]){
                    orderNumber=j;
                }
            }
            if(orderNumber != i){
                temp = arr[i];
                arr[i] = arr[orderNumber];
                arr[orderNumber] = temp;
            }
        }

        System.out.println("从大到小排序：");
        for(int x:arr){
            System.out.print(x+"\t");
        }
    }
}

运行结果

--------选择排序--------
排序前：
38 18 44 83 29 66 1 23 41 7
从小到大排序：
1 7 18 23 29 38 41 44 66 83
从大到小排序：
83 66 44 41 38 29 23 18 7 1

补充部分`

public class Practise {
    public static void main(String[] args) {

        //共用部分，声明数组，生成随机数作为数组的值
        Random ran = new Random();
        final int N = 100;
        int[] array = new int[N];
        for(int i=0;i<N;i++){
            array[i]= ran.nextInt(1001);
        }
        System.out.println("排序前：");
        System.out.println(Arrays.toString(array));

        //冒泡排序，时间复杂度O(n²)
        for(int i=0,t;i<N-1;i++){
            for(int j=0;j<N-1-i;j++){
                if (array[j] > array[j+1]) {
                    t=array[j];
                    array[j]=array[j+1];
                    array[j+1]=t;
                }
            }
        }

        //选择排序
        for(int i = 0, maxValAddress, maxValNum, t; i<N-1; i++){
            maxValAddress = 0;//最大值在数组中的实际位置
            maxValNum =N-1-i;//最大值在数组中应该在的位置
            for(int j = 1; j <= maxValNum; j++){
                if(array[j]>array[maxValAddress])
                    maxValAddress =j;
            }
            if(maxValNum != maxValAddress){
                t=array[maxValNum];
                array[maxValNum]=array[maxValAddress];
                array[maxValAddress]=t;
            }
        }

        //插入排序
        for(int i=1,j,temp;i<=N-1;i++){
            if(array[i]>=array[i-1]){
                continue;
            }
            temp=array[i];
            for(j=i-1;j>=0&&array[j]>temp;j--){
                array[j+1]=array[j];
            }
            array[j+1]=temp;
        }

        //希尔排序，在插入排序之前先进行相对排序
        int step = array.length,temp;
        while ((step=step/2)>=2){
            for(int i=0;i+step<N;i++){
                if(array[i]>array[i+step]){
                    temp=array[i];
                    array[i]=array[i+step];
                    array[i+step]=temp;
                }
            }
        }
        for(int i=1,j;i<=N-1;i++){
            if(array[i]>=array[i-1]){
                continue;
            }
            temp=array[i];
            for(j=i-1;j>=0&&array[j]>temp;j--){
                array[j+1]=array[j];
            }
            array[j+1]=temp;
        }

        //输出排好序的数组的值
        System.out.println("排序后：");
        System.out.println(Arrays.toString(array));
    }
}