20200303——剑指offer 关于排序的稳定性与时间复杂度

刷剑指的题的时候，总会有一些知识点没弄清楚。比如关于排序的诸多事宜，都有些记不清楚，本篇博客旨在重新复习与梳理这些知识。

稳定性
一个算法，对于一个序列中的相同元素，如果排序后的相对位置保持不变，那么我们就认为该算法是稳定的

序列【2，5，6，3，4，2】

编号【0，1，2，3，4，5】

排序后

序列【2，2，3，4，5，6】

编号【0，5，3，4，1，2】

如上，排序好后，编号5代表的2元素依然在编号0代表的2元素的后面，此时，我们就认为该排序算法是稳定的

稳定性的作用
稳定性有什么作用呢？
如上面的列子，如果我们按照序号从1~100进行排序，最后排序的时候还希望按照序号的顺序进行排序，那么最好不要进行改变序号，我们需要这种稳定排序。

归并排序、冒泡排序、插入排序。基数排序是稳定的

选择排序、快速排序、希尔排序、堆排序是不稳定的

时间复杂度
正统来说，就是描述一个算法的运行时间，即该算法运行的工作量
当然，我们定义每个基础操作的运行时间是一致的。

public static void main(String[] args) {
        
        int n=10;
        // （1）执行了n次
        for (int i = 0; i < n; i++) {
            // 执行了n此
            for (int j = 0; j < n; j++) {
                System.out.println("执行了一次");
            }
            // 执行了n此
            for (int j = 0; j < n; j++) {
                System.out.println("执行了一次");
            }
        }
        
        // （2）执行了n此
        for (int j = 0; j < n; j++) {
            System.out.println("执行了一次");
        }
        
        System.out.println("执行了一次");
    }

此例中第一个（1）for循环每执行一次其内部都会又执行两次n次，所以其执行的次数为n(2n)，而第二个（2）for循环又会执行n次，再加上末尾有个打印语句，所以可以表示其运行时间为T(n)=2n2+n+1;但是我们知道计算机的执行速度非常快，其单次运行的时间可以忽略不计，所以T(n)近等于2n2+n，此时虽然看起来比较好了但是还不够，尤其是当一个式子比较复杂时依然看起来比较麻烦，而我们知道，当n的值越大时，其最高项系数决定了该函式的主要趋势，所以我们只保留其函式的最高项，并去除其常数系数，用来表示其时间复杂度的渐进趋势，称为渐进时间复杂度，用O来表示，所以此例的渐进时间复杂度表示为O(n2)

空间复杂度
有的时候我们可能需要在算法中开辟一些空间来存储算法所运行或者得到的一些数据。
等同于时间复杂度，你开辟多少空间，就是空间复杂度。

八大排序算法

这个表示从网上转载的。

冒泡排序
他是一种稳定的排序方式，稳定的意义在于，如果两个相邻的元素相等，不交换位置。

package sort_collection;

/**
 * @Classname BubbleSortTest
 * @Description TODO
 * @Date 2020/3/3 17:48
 * @Created by mmz
 */
public class BubbleSortTest {
    public static void bubbleSort(int[] arr){
        for(int i = 0;i<arr.length-1;++i){
            for(int j = 0;j<arr.length-1-i;++j){
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    public static void printArr(int[] arr){
        for(int i = 0;i<arr.length;++i){
            System.out.print(arr[i]+ " ");
        }
    }


    public static void main(String[] args) {
        int[] arr = new int[]{1,7,3,9,4,0,5};
        printArr(arr);
        System.out.println("------");
        bubbleSort(arr);
        printArr(arr);
    }
}

是相邻元素之间的比较和交换，两重循环O(n2)；所以，如果两个相邻元素相等，是不会交换的。所以它是一种稳定的排序方法

选择排序

package sort_collection;

/**
 * @Classname SelectSortTest
 * @Description TODO
 * @Date 2020/3/3 20:24
 * @Created by mmz
 */
public class SelectSortTest {
    public static void selectSort(int[] arr){
        for(int i = 0;i<arr.length;++i){
            int min = i;
            for(int j = i+1;j<arr.length;++j) {
                if (arr[j] < arr[min]) {
                    min = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[min];
            arr[min]  = temp;
        }
    }
    public static void printArr(int[] arr){
        for(int i = 0;i<arr.length;++i){
            System.out.print(arr[i]+ " ");
        }
    }


    public static void main(String[] args) {
        int[] arr = new int[]{1,7,3,9,4,0,5};
        printArr(arr);
        System.out.println("-----------");
        selectSort(arr);
        printArr(arr);
    }
}

选择排序，在每次排序的时候找最小或者最大放在第一位或者最后一位
一开始比较的一定是min与j比较
最后一定是i与min进行替换

插入排序

package sort_collection;

/**
 * @Classname InsertSortTest
 * @Description TODO
 * @Date 2020/3/3 21:15
 * @Created by mmz
 */
public class InsertSortTest {
    public static void insertSort(int[] arr){
        int current;
        for(int i = 0;i<arr.length -1 ;++i){
            current = arr[i+1];
            int previous = i;
            while(previous>=0&&current<arr[previous]){
                arr[previous+1] = arr[previous];
                previous--;
            }
            arr[previous+1] = current;
        }
    }

    public static void printArr(int[] arr){
        for(int i = 0;i<arr.length;++i){
            System.out.print(arr[i]+ " ");
        }
    }


    public static void main(String[] args) {
        int[] arr = new int[]{1,7,3,9,4,0,5};
        printArr(arr);
        System.out.println("-----------");
        insertSort(arr);
        printArr(arr);

    }
}

插入排序，就相当于第一个数字已经排序好的，之后往这个第一个数字里面进行插入。要记住数据不要越界，循环中应该写的是，i<arr.length-1

快速排序
快速排序是一种排序执行效率很高的排序算法，它利用分治法来对待排序序列进行分治排序，它的思想主要是通过一趟排序将待排记录分隔成独立的两部分，其中的一部分比关键字小，后面一部分比关键字大，然后再对这前后的两部分分别采用这种方式进行排序，通过递归的运算最终达到整个序列有序，下面我们简单进行阐述。

关于快速排序很好的图解

package sort_collection;

/**
 * @Classname QuickSortTest
 * @Description TODO
 * @Date 2020/3/3 21:50
 * @Created by mmz
 */
public class QuickSortTest {

    public static void quickSort(int[] arr,int left,int right){
        int len;
        if(arr == null
                || (len = arr.length) == 0
                || len == 1) {
            return ;
        }
        if(left > right) {
            return;
        }
        int base = arr[left];
        int i = left;
        int j = right;
        while(i < j){
            while(arr[j] >= base && i < j){
                j--;
            }
            while(arr[i] <= base &&i < j){
                i++;
            }
            if(i < j){
                int temp = arr[j];
                arr[j] = arr[i];
                arr[i] =temp;
            }
        }
        arr[left] = arr[i];
        arr[i] = base;

        quickSort(arr,left,i-1);
        quickSort(arr,i+1,right);
    }

    public static void printArr(int[] arr){
        for(int i = 0;i<arr.length;++i){
            System.out.print(arr[i]+ " ");
        }
    }


    public static void main(String[] args) {
        int[] arr = new int[]{1,7,3,9,4,0,5};
        printArr(arr);
        System.out.println("-----------");
        int left = 0;
        int right = arr.length-1;
        quickSort(arr,left,right);
        printArr(arr);
    }
}

这是一个递归程序，一定要找到程序的出口。而且程序的一开始一定要进行判断