P13拓展2 递归，数学归纳法与二分法

---

前言：由于年关将至，这篇文章没有太多打磨就发了，没有钻到最底层去求解，时间和能力都不够用，暂时先想到这以后再说吧

约分问题

例如，f原为4/6，则reduce之后为2/3

方法一：

FUNCTION reduce()
{
    for (int i = 2; i < num || i < den; i++)//从2开始找公约数
    {
        int flag = 0;//0: 没找到公约数， 1，表示找到公约数
        if (num % i == 0 && den % i == 0)//如果i既可以整除分子、也可以整除分母，则。。
        {
            flag = 1;
            num /= i;//分子约分后
            den /= i;//分母约分后
        }
        if (flag)//如果找到了公约数，那么从2开始重新找公约数
        {
            i = 1;
        }

     }

}

这是我把自己约分的思路写成了代码的形式，但是我思考的方式并不是最适合电脑的（代码）

方法二：

这是一个简单的二层嵌套，但是跟选择排序（二层嵌套）不一样的地方是，选择排序是把解题过程直接写出来的代码。而这个是经过了一道转换，把我上面的思路转换成了一个嵌套的函数

FUNCTION reduce()
{
//找到一个分子和分母的公约数，然后对他进行整除，然后除了一个公约数意外还有可能进行进一步的化简，所以是一个while循环
	while(1)
	{
		int flag = 0; // 0: 没找到公约数， 1，表示找到公约数
		for(int i=2; i<=num && i<=den; i++)
		{
			// 如果i既可以整除分子、也可以整除分母，则。。
			if( num % i == 0 && den % i== 0)
			{
				num /= i;
				den /= i;
				flag = 1;
			}
		}
//如果找到了公约数，那就继续，如果没找到公约数，说明分数已是最简，结束
		if(!flag) break;
	}
}

方法二比方法一多了一层while循环，变成了一个双层循环的嵌套函数，看似运算规模扩大了，实际上我的体验是运行比方法一快了不少。

递归

有关递归思想的数学问题

递归在计算机里广泛使用，可以认为是一种嵌套。

拜占庭将军问题

1.兰伯特 分布成节点故障，恶意

如何保持一致性，正确性

2.口头协议

1.忠诚的副官遵守同一个命令

2.若将军是忠诚的，所有忠诚的副官执行他的命令

M：恶意个数 N：总人数 当N>3M时可解

当将军是叛徒时任然满足一致性

1-5号副官得到相同结果n =（a+b+c+d+e）

3.PBFT，可以在有网络延迟的情况下使用的算法

4.比特币，区块链，POW 核心作用：保持一致性（方法是增加叛徒成本）

汉诺塔

FUNCTION 汉诺塔(int a)
{
    if (a == 1)
    {
        return 1;
    }
    else
    return 2 * hannuota(a-1) + 1;//（n-1层a->c）+（n-1层b->c）+1/*第n层a->c*/
}

双蛋问题

放弃

二叉树

一个指向树根的指针

一些运算

一个指向数左侧的指针

一个指向数右侧的指针

放弃

并归排序

#include<iostream>
using namespace std;

void mergesort(int buf[], int* b, int left, int right,int mid)//用来排序
{
    int pos_l = left;
    int pos_r = mid + 1;
    int pos = left;
    while (pos_l <= mid && pos_r <= right)
    {
        if (buf[pos_l] < buf[pos_r])
        {
            b[pos++] = buf[pos_l++];
        }
        if (buf[pos_l] > buf[pos_r])
        {
            b[pos++] = buf[pos_r++];
        }
    }
    while (pos_l > mid && pos_r <= right)
    {
        b[pos++] = buf[pos_r++];
    }
    while (pos_l <= mid && pos_r > right)
    {
        b[pos++] = buf[pos_l++];
    }
    while (left<=right)
    {
        buf[left] = b[left];
        left++;
    }
}

void merge(int buf[],int* b,int left,int right)//用来递归
{
    if (left < right)
    {
        int mid = (left + right) / 2;
        merge(buf, b, left, mid);
        merge(buf, b, mid+1, right);
        mergesort(buf, b, left, right, mid);
    }
}

int main()
{
    int buf[] = {9,8,7,6,4,3,2,5,1};
    int n = sizeof (buf) / sizeof (int);
    int* b = (int*)malloc(n*sizeof(int));//申请一个和原数组一样大的内存，用来储存排序后的数组
    merge(buf, b, 0, n - 1);
    free(b);
    for (int i = 0; i < n; i++)//循环打印
        cout << buf[i] << " ";
    return 0;
}