排序算法总结

1、冒泡排序

1.1、冒泡排序的基本思想

从无序队列的头部开始（当然也可以从尾部开始，两两比较，将最小的数交换到队首），从前往后，将相邻的两个数进行两两比较，根据大小交换位置，将最大的数交换到无序数列的队尾，从而成为有序数列的一部分。下一次继续这个过程，直到将无序数列变成有序数列。

如下图所示，每次都把最大的数浮动到队列的末尾：

1.2、java代码实现

package BubbleSort;

public class BubbleSort {
    public void bubblesort(int[] array){
        if (array == null || array.length == 0)
            return ;
        for(int i = 0; i < array.length - 1; i++){

            //设定一个标记flag,若为true,则表示此次循环没有交换，也就是待排列顺序已有序，排序已完成
            boolean flag = true;

            //从队首开始，将大的数字向后排
            for (int j = 0; j < array.length - i - 1; j++){
                if (array[j] > array[j+1]){
                    int temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                    flag = false;
                }
            }
            if (flag)
                break;
        }
    }

    public static void main(String[] args) {
        BubbleSort bubbleSort = new BubbleSort();

        int array[] = {4,6,1,2,8,7,9,0,3,5};

        bubbleSort.bubblesort(array);
        //遍历array数组
        for (int x : array){
            System.out.print(x + " ");
        }
    }
}


执行结果：
0 1 2 3 4 5 6 7 8 9 

1.3、性能分析

时间复杂度

根据上面这种冒泡实现，若原数组本身就是有序的（最理想情况），仅需n-1次比较就可以完成，时间复杂度为O（n）；如果是倒序，比较次数为：（n-1）+（n-2）+...+1=n（n-1）/ 2，所以其时间复杂度仍为O（n^2）。

空间复杂度

冒泡排序过程中需要一个临时变量来进行两两交换，所需的额外空间为1，因此空间复杂度为O（1）。

稳定性

冒泡排序在排序过程中，元素两两交换，相同元素的前后顺序没有改变，所以冒泡排序是一种稳定算法。

2、插入排序

插入排序的基本思想就是从第一个元素开始（该元素可以默认为已经排好序），每一步将一个待排序的记录，按照顺序插入到前面已经排好序的数列中去，直到插完所有的数。

如下图所示，中括号内代表已经排好序的数列：

2.2、java代码实现

package SortDemo;

public class InsertSort {
    public void sort(int[] array){
        for (int i = 1; i < array.length; i++){
            int j = i;
            while (j > 0 && array[j] < array[j-1]){
                int temp = array[j];
                array[j] = array[j-1];
                array[j-1] = temp;
                j--;
            }
        }
    }

    public static void main(String[] args) {
        InsertSort insertSort = new InsertSort();

        int[] array = {4,6,1,2,8,7,9,0,3,5};

        insertSort.sort(array);

        for (int x : array){
            System.out.print(x + " ");
        }
    }
}


执行结果：0 1 2 3 4 5 6 7 8 9 

2.3、性能分析

时间复杂度

最理想情况下，数组为正序数组，需要比较n-1次，无需交换元素，时间复杂度为O（n）；

在最坏情况下，时间复杂度仍为O（n^2）。