算法rookie02

算法rookie02

算法

算法：对一个问题解决的具体流程，算法还有评价处理流程的可量化的指标。

算法的分类：算法可以分为很多种，分类标准很多。但是，作为一个新手，算法可以分为两种：

​ 1.明确知道怎么算的流程

​ 2.明确知道怎么尝试的流程

分类2很重要，这是计算机作为一种科学的原因之一，计算机不是一种计算工具，还是可以发展的科学，计算机科学的祖师爷为啥是图灵，因为图灵在二战的时候，为英军进行尝试解决破译德军的密码。

例题

题目1：1！+ 2！+ 3！ + 4！ + 5！… + N!的和

code1：

private static int sumOfFac1(int n) {
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            int f = factorial(i);
            sum+=f;
        }
        return sum;
    }

    private static int factorial(int n) {
        int ans = 1;
        for (int i = 1; i <= n; i++) {
            ans*=i;
        }
        return ans;
    }

code2

private static int sumOfFac2(int n) {
        int sum = 0;
        int ans = 1;
        for (int i = 1; i <= n; i++) {
            ans = ans * i;
            sum += ans;
        }
        return sum;
    }

算法的实现可以有不同的实现，但是实现是有优劣的。sumOfFac1方法是就是每个阶乘求出来然后进行累加。sumOfFac2这个方法分析阶乘，n！ = n * (n-1)!,通过增加一个变量保存阶乘用于上个数的阶乘计算。

排序：

选择排序：

排序的思路：

1. 从0到n-1位置，找到最小的数，与0位置交换
2. 从1到n-1位置，再找最小数，与1位置交换
3. 从i到n-1位置，找到最小数，与i位置交换
4. 最后n-2与n-1位置，找到最小数，再判断。

code：

 public static int[] selectSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return arr;
        }
        int length = arr.length;
        for (int i = 0; i < length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < length; j++) {
                minIndex = arr[i] > arr[j] ? j : minIndex;
            }
            if (minIndex != i) {
                swap(arr, i, minIndex);
            }
        }
        return arr;
    }

冒泡排序：

算法的思路：

1. 从0到n-1范围内比较，相邻两个数，那个数大那个往后边移动
2. 从0到i位置比较，两个两个数，较大的往后边移动
3. 只剩0位置的时候，排序完成。

code

private static int[] bubbleSort(int[] arr) {
        // 边界判断
        if (arr == null || arr.length < 2) {
            return arr;
        }
        // 确定范围
        int N = arr.length;
        for (int i = 0; i < N-1; i++) {
            for (int j = i+1; j < N; j++) {
                if (arr[i]> arr[j]) {
                    swap(arr,i,j);
                }
            }
        }
        return arr;
    }

插入排序：

思路：

1. 0到0开始比较，已经排好了
2. 0到1比较，顺序不对了就交换。
3. 0到2范围，2和1比较，顺序不对，就交换，交换完之后，再比较1和0位置。
4. 0到i范围，i和i-1比较，是否需要交换，如果交换再比较i-1与i-2位置。

code：

public static void insertSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int N = arr.length;
        for (int end = 1; end < N; end++) {
            for (int pre = end - 1; pre >= 0 && arr[pre] > arr[pre + 1]; pre--) {
                swap(arr, pre, pre + 1);
            }
        }
    }

多说一句：插入排序和选择排序类似，但是插入排序是一种乐观的冒泡排序，如果排序是好的，检查一遍就走了，不用比较多次了。

var code = “2188b477-d0cd-4b07-af4d-2eed4d7b6d5a”