复习冒泡排序，选择排序和插入排序

冒泡排序

冒泡排序是一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果左边大于右边则交换，看起来像冒泡一样

分析

如下图：将3与44比较，3比44小，则不用交换，再用44与38比较，44大于38，交换，以此类推。

代码的实现

public class Bubble {
    /* 对数组a中的元素进行排序 */
    public static void sort(int[] a){
        //多少个元素参与冒泡
        for (int i = a.length-1 ; i > 0 ; i--){
            for (int j = 0 ; j< i ; j++){
                if (a[j]>a[j+1]){
                    int temp;
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
        list(a);
    }
    private static void list(int[] a){
        for (int i : a){
            System.out.println(i);
        }
    }

    public static void main(String[] args) {
        int[] a ={5,4,3,8,7,6};
        sort(a);
    }

}

输出结果为：

3
4
5
6
7
8

稳定性和时间复杂度的分析

只有当arr[i]>arr[i+1]的时候，才会交换元素的位置，而相等的时候并不交换位置，所以冒泡排序是一种稳定排序
算法。

按照大O推导法则，保留函数中的最高阶项那么最终冒泡排序的时间复杂度为O(N^2).

选择排序

选择排序就是通过n-1次关键字间的比较，从n-1+1个记录中选出关键字最小的记录，并和第i（1<=i<=n）个记录交换。

分析

每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处
的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引

代码的实现

public class Selector {
    public static void main(String[] args) {
        int[] a = {66,93,53,86,22,66,84,56,78,90,245,764,234,666};
        Sort(a);
    }
    public static void Sort(int[] a){
        for (int i =0;i<a.length-1;i++){
            int minIndex=i;
            for (int j =i+1 ;j<a.length;j++){
                if (a[minIndex]>a[j]){
                    minIndex=j;
                }
            }
            int temp =a[minIndex];
            a[minIndex] = a[i];
            a[i] = temp;
        }
        List(a);
    }

    private static void List(int[] a) {
        for (int i : a){
            System.out.println(i);
        }
    }
}

结果为

22	53	56	66	66	78	84	86	90	93	234	245	666	764

稳定性和时间复杂度的分析

选择排序是给每个位置选择当前元素最小的,例如有数据{5(1)，8 ，5(2)， 2， 9 },第一遍选择到的最小元素为2，
所以5(1)会和2进行交换位置，此时5(1)到了5(2)后面，破坏了稳定性，所以选择排序是一种不稳定的排序算法。

时间复杂度为O(N^2)

插入排序

插入排序是是将一个记录插入到已经排序好的有序表中，从而得到一个新的、记录数增一的有序表。

分析

1.把所有的元素分为两组，已经排序的和未排序的；
2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；
3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个 元素小于等于待插入元素，那么就把待
插入元素放到这个位置，其他的元素向后移动一位；

如下图

代码的实现

public class Insertion {
    public static void main(String[] args) {
        int[] a={3,543,64,7,467,567,657,8678,9,54,35,856,85,8,567,65};
        Sort(a);
    }
    public static void Sort(int[] a){
        for (int i = 1 ; i <a.length ;i++){
            for (int j  =i ; j>=0 ;j--){
                if (a[j-1]>a[j]){
                    int temp =a[j-1];
                    a[j-1]=a[j];
                    a[j]=temp;
                }else{
                    break;
                }
            }
        }
        List(a);
    }
    private static void List(int[] a) {
        for (int i = 0; i <a.length ; i++) {
            System.out.println(a[i]);

        }
    }
}

结果为

[3, 7, 8, 9, 35, 54, 64, 65, 85, 467, 543, 567, 567, 657, 856, 8678]

稳定性和时间复杂度的分析

比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其
后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么把要插入的元素放在相等
元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序
是稳定的

时间复杂度为O(N^2)