算法思路@@huzicpp(更新中,思路纯搬运为了自己学习）

本文内容来自于力扣，再此只是做笔记使用

2020/7/24

---

除数博弈

爱丽丝和鲍勃一起玩游戏，他们轮流行动。爱丽丝先手开局。
最初，黑板上有一个数字 N 。在每个玩家的回合，玩家需要执行以下操作：
选出任一 x，满足 0 < x < N 且 N % x == 0 。
用 N - x 替换黑板上的数字 N 。
如果玩家无法执行这些操作，就会输掉游戏。
只有在爱丽丝在游戏中取得胜利时才返回 True，否则返回 false。假设两个玩家都以最佳状态参与游戏。
示例 1：
输入：2
输出：true
解释：爱丽丝选择 1，鲍勃无法进行操作。
示例 2：
输入：3
输出：false
解释：爱丽丝选择 1，鲍勃也选择 1，然后爱丽丝无法进行操作。
提示：
1 <= N <= 1000

分析：
博弈型可以通过写几个得知规律，偶数Alice赢，否则ALICE输，所以直接很简单。

class Solution {
public:
    bool divisorGame(int N) {
        if(N%2 == 0){
            return true;
        }else{
            return false;
        }
    }
};

几种排序手段**

1. 直接插入排序
   思路描述：外层循环确定扫描个数，内层循环确定新加入的数插入位置。

void Insert(int a[], int N){
    std::cout << "直接排序法结果" <<std::endl;
    int temp, j;
    for (int i = 1; i < N; i++) {
        j = i;
        temp = a[i];
        //*把大于a[i]的全部后移，考虑的和我相反，所以我需要三次循环，人家只要两次
        while(j > 0&& temp < a[j-1]) {  //while学习不到位
            a[j] = a[j - 1];
            j--;
        }
        a[j] = temp;
    }
}

2. 希尔排序算法
   基本思路

void Sort::Xier(int a[], int N) {
    int temp, j;
    for (int gap = N / 2; gap > 0; gap /= 2) {  //将数组分组后操作
        for (int i = gap; i < N; i++) {  //从gap个元素跨组排序，少用一个for循环
            temp = a[i];
            j = i;
            if (a[j] < a[j - gap]) {
                while (j > 0 && temp < a[j - gap]) {  //后面的都是gap，因为是不连续的
                    a[j] = a[j - gap];
                    j -= gap;
                }
            }
            a[j] = temp;
        }
    }
}

3. 冒泡法排序

void Sort::Effer(int a[], int N) {
    for (int i = 0; i < N; i++) { //冒泡法排序的次数
        for (int j = 0; j <  N - i; j++) {  //j每次需要缩小，经过一次排序后增加一个有序的序列（两端每次都会是有序的）
            if (a[j] > a[j + 1]) {
                a[j] = a[j] + a[j + 1];
                a[j + 1] = a[j] - a[j + 1];
                a[j] = a[j] - a[j + 1];
            }
        }
    }
}

4. 快速排序法
   基本思路

void Sort::quicksort(int a[], int bg, int ed) {
    int i = bg;
    int j = ed;
    int temp = a[bg];

    while (i < j)
    {
        // 越过不小于基准值的数据 
        while (a[j] >= temp && j > i) j--;

        if (j > i)
        {
            a[i] = a[j]; //将值赋到空位上
   /*         i++;*/
        }
        // 越过小于基准值的数据 
        while (a[i] < temp && i < j)  i++;
        if (i < j)
        {
            a[j] = a[i]; //将值赋到空位上
            j--;
        }
        
    }
    a[i] = temp;
    //递归要设置条件，不然无限递归
    if (bg < (i - 1)) quicksort(a, bg, i - 1);
    if ((j + 1) < ed) quicksort(a, j + 1, ed);
}

---

2020/7/30

有序数组查找等于下标的数字

1. 跳跃式查找，比较i+1和数字大小来实现跳跃

class Solution {
    public int findMagicIndex(int[] nums) {
        for(int i=0;i<nums.length; ){
            if(nums[i]==i)
                return i;
            i=Math.max(nums[i],i+1);
        }
        return -1;
    }
}

利用类似于"2+2*3"来实现计算器**

int calculate(string s) {
    int res = 0, d = 0;
    char sign = '+';
    stack<int> nums; //栈，先进后出
    for (int i = 0; i < s.size(); ++i) {
        if (s[i] >= '0') {//加减乘除和空格ASCII码都小于'0'
            d = d * 10 - '0' + s[i];//进位(先减法)
        }
        if ((s[i] < '0' && s[i] != ' ') || i == s.size() - 1) {
            if (sign == '+') {
                nums.push(d); //push将元素放进栈中
            } else if (sign == '-') {
                nums.push(-d);
            } else if (sign == '*' || sign == '/') {
                int tmp = sign == '*' ? nums.top() * d : nums.top() / d;
                nums.pop();
                nums.push(tmp);
            }
            sign = s[i]; //保存当前符号
            d = 0;
        }
    }
    for (; !nums.empty(); nums.pop()) {
        res += nums.top();
    }
    return res;
}