排序算法小结（未完）

排序算法稳定性概念：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。
堆排序、快速排序、希尔排序、直接选择排序是不稳定的排序算法，而基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序是稳定的排序算法。

1.冒泡排序：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr={4,5,1,8,5};
        System.out.println("排序之前的数组：");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.print("\n");
        bubbleSort1(arr);//调用冒泡排序方法
        System.out.println("冒泡排序后的数组：");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
        System.out.print("\n");
    }

    private static void bubbleSort1(int[] arr) {
        int temp;
        for(int i=1;i<arr.length;i++){//外部循环控制几轮排序
            for(int j=0;j<arr.length-i;j++){
                if(arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }//每一轮排序都将最大的数据往后排
            System.out.print("第"+i+"步排序后的结果：");
            for(int x=0;x<arr.length;x++){
                System.out.print(arr[x]+" ");
            }//输出每一轮排序后的结果
            System.out.println();
        }
    }
}

排序之前的数组：
4 5 1 8 5 
第1步排序后的结果：4 1 5 5 8 
第2步排序后的结果：1 4 5 5 8 
第3步排序后的结果：1 4 5 5 8 
第4步排序后的结果：1 4 5 5 8 
冒泡排序后的数组：
1 4 5 5 8

时间复杂度（最坏情况）：对于n位的数列则有比较次数为 (n-1) + (n-2) + … + 1 = n * (n - 1) / 2所以时间复杂度为O(N^2)。并且是稳定的。

2.选择排序

public class Sort {

    public static void main(String[] args) {
        int arr[]={38,80,43,4,59,48};

        System.out.println("排序前的数组：");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }

        System.out.println();

        selectionSort(arr);//调用选择排序方法

        System.out.println("选择排序后的数组：");
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }


    }
    private static void selectionSort(int[] arr) {
        int temp,index;
        for(int i=0;i<arr.length-1;i++){
            index=i;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[index]){
                    index=j;
                }
            }//找到数组剩余数中最小的数赋给arr[index]
            if(index!=i){
                temp=arr[i];
                arr[i]=arr[index];
                arr[index]=temp;
            }//将每一次得到的最小数据arr[index]与arr[0],[1],,,交换
            System.out.print("第"+(i+1)+"步排序后结果：");
            for(int x=0;x<arr.length;x++){
                System.out.print(arr[x]+" ");
            }
            System.out.println();
        }
    }

输出：

排序前的数组：
38 80 43 4 59 48 
第1步排序后结果：4 80 43 38 59 48 
第2步排序后结果：4 38 43 80 59 48 
第3步排序后结果：4 38 43 80 59 48 
第4步排序后结果：4 38 43 48 59 80 
第5步排序后结果：4 38 43 48 59 80 
选择排序后的数组：
4 38 43 48 59 80 

时间复杂度：对于n位的数列则有比较次数为 (n-1) + (n-2) + … + 1 = n * (n - 1) / 2，所以时间复杂度为O(N^2)。不稳定，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。