数据结构与算法（二）

• 空间复杂度：表示算法的执行时间与数据规模之间的增长关系； int[] a =new int[n]空间复杂度o(n).主要看占内存大小。

• 递归算法：主要应用包括DFS深度优先搜索，前中后序二叉树的遍历；特点：方法自己调用自己，只不过每次调用时参数不同

• 满足递归的条件：1.递归表达式（一个问题的解能够拆分为多个子问题的解，并且拆分之后，子问题的解与原问题的解除了数据规模不一样以外，求解的思路应该与原问题完全相同）2.终止递归的条件（即一个初始条件）

• 递归过程：写递推代码的关键就是找到将原问题拆分为多个子问题的规律，并且基于此写出递推公式，然后再找到递归条件。最终将递推公式和递推条件翻译成代码即可。

• 递归容易引发的问题：1.堆栈溢出（临时变量过多，即递归次数过多，导致堆栈溢出） 2.重复计算（斐波那契数列）

• 斐波那契数列（1 、 1、2、3、5、8、13、21 、34…） 递推公式：当n>=3时;f(n) = f(n-1) + f(n-2).其中f(1) = 1;f(2) = 1;n越大，重复计算越多。

• 递归和循环：循环都可以改写成递归，递归未必能够改写成循环。 应用场景：阶乘问题

• 评判算法程序好坏的标准：1.时间复杂度 2.空间复杂度 3.算法稳定性

• 冒泡排序（Bubble）：通过一次比较两个相邻的元素，看是否满足大小关系，如果不满足，则交换位置；每一次冒泡会让至少一个元素移动到他应该在的位置，经过n次冒泡就完成了n个数据的排序工作

public class BubbleSort {

    public static void bubbleSort(int[] array){
        int length = array.length;
        if(length<=1){
            return;
        }
        for (int i = 0;i<length;i++){
            for (int j = 0;j<length-i-1;j++){
                if(array[j]>array[j+1]){
                    int temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                }
            }
        }
    }
    public static void main(String[] args){
            int[] array = new int[5];
            array[0] = 5;
            array[1] = 2;
            array[2] = 6;
            array[3] = 8;
            array[4] = 1;
            System.out.println(Arrays.toString(array));
            bubbleSort(array);
            System.out.println(Arrays.toString(array));

    }

}

• 冒泡时间复杂度：最好o(n),最坏o(n2)；空间复杂度o(1)
• 插入排序法：将数组中的数据分为两个区间，已排序区间和未排序区间，初始已排序区间只有一个元素，就是数组的第一个元素。核心思想：取未排序区间中的元素，在已排序区间找到合适的位置插入，并保证在以排序区间上数据一直有序，重复直到结束。

public class insertSort {
    public static void insertSort(int[] array) {
        int length = array.length;
        if (length <= 1)
            return;
        for (int i = 1;i<length;i ++){
            int current = array[i];
            int preindex = i-1;
            while (preindex>=0 &&array[preindex]>current){
                array[preindex+1] = array[preindex];
                preindex--;
            }
            array[preindex+1] = current;
        }
    }

• 插入排序时间复杂度：最好o(n)；最坏o(n2) 空间复杂度o(1)属于稳定的排序。
• 选择排序：分已排序区间和未排序区间，选择排序每次都会从未排序区间中 找到最小的元素，放到已排序区间的末尾；初始已排序区间无元素。

public class selectSort {
    public static void selectSort(int[] array) {
        int length = array.length;
        if (length<= 1 ){
            return;
        }
        for (int i = 0;i <length;i++){
            int minindex = i;
            for (int j = i;j<length;j++){
                if (array[minindex]>array[j+1])
                    minindex = j+1;
            }
            int temp = array[i];
            array[i] = array[minindex];
            array[minindex] = temp;
        }
    }

选择排序时间复杂度：最好 o(n2) ；最坏 o(n2) 不是一个稳定的排序算法