【分治算法】

1. 欧几里得算法（辗转相除法）

知识背景：
求a和b的最大公约数
记

$a (mod) b=c$
$a=kb+c$

设a b的最大公约数为d,则

$a=m*d$
$b=n*d$

且m和n互质。

$c=a-kb=md-knd=(m-kn)d$

因为m和n互质，则n和m-kn互质，c和b的最大公约数也是d

所以：
“a和b(a>b)的最大公约数等于b和a Mode b的最大公约数”
递归或迭代计算，直到余数为0，此时除数为最大公约数。

#include <stdio.h>
int gcd(int small,int big)
{
    if(small==0)
        return big;
    return gcd(big%small,small);
}
int main()
{
    int small,big;
    while(scanf("%d%d",&small,&big)!=EOF)
    {
        printf("%d\n",small<big?gcd(small,big):gcd(big,small));
    }
    return 0;
} 

2. 归并排序

package test;

import java.util.Arrays;
import java.util.Scanner;


public class First {
    public static void main(String args[])
    {
        Scanner in = new Scanner(System.in);
        String nString;
        while((nString=in.nextLine())!=null)
        {
            String[] nArray = nString.split(" ");
            int[] num = new int[nArray.length];
            for(int i=0;i<nArray.length;i++)
            {
                num[i] = Integer.parseInt(nArray[i]);
            }
            mergeSort(num, 0, nArray.length-1);   // 这里传入的是下标不是数量！
            for(int res : num)
            {
                System.out.print(res+" ");
            }

        }
    }

    public static void mergeSort(int[] nArray,int start,int end)
    {   
        if(end > start)
        {
            int mid = (start + end)/2;
            mergeSort(nArray, start, mid);
            mergeSort(nArray, mid+1, end);
            conquer(nArray,start,mid,end);
        }
    }

    public static void conquer(int[] nArray,int start,int mid,int end) 
    {
        int n1 = mid - start + 1;
        int n2 = end - mid;
        int[] l = new int[n1];
        int[] r = new int[n2];
        System.arraycopy(nArray, start, l, 0, n1);
        System.arraycopy(nArray, mid+1, r, 0, n2);
        int x = 0;
        int y = 0;
        int left = start;
        while(x < n1 && y < n2)
        {
            if(l[x] < r[y])
            {
                nArray[left] = l[x];
                left++;
                x++;
            }
            else
            {
                nArray[left] = r[y];
                left++;
                y++;
            }   
        }
        while(x < n1)
        {
            nArray[left] = l[x];
            left++;
            x++;            
        }
        while(y < n2)
        {
            nArray[left] = r[y];
            left++;
            y++;            
        }

    }
}

3. 重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树（输出后序遍历的结果）并返回。

Test.java

public class Test {
     public static void main(String[] args){
         int pre[] = {1,2,4,7,3,5,6,8};
         int in[] = {4,7,2,1,5,3,8,6};
         Solution s = new Solution();
         TreeNode t = null;
         t = s.reConstructBinaryTree(pre,in);
         Test.fun(t);

     }
     public static void fun(TreeNode t)
     {
         if(t == null) return;
         fun(t.left);
         fun(t.right);
         System.out.println(t.val);
     }
}

Solution.java

import java.util.Arrays;

class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
     TreeNode(int x) { val = x; }
  }


public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if(pre.length == 0 || pre == null) return null;
        TreeNode root = new TreeNode(pre[0]);
        int mid;
        for(mid = 0;mid < in.length;mid++)
        {
            if(pre[0] == in[mid])
            {
                break;
            }
        }
        int leftLength = mid;
        int rightLength = pre.length - mid - 1;
        int[] preLeftTree = Arrays.copyOfRange(pre,1,leftLength+1);
        int[] inLeftTree = Arrays.copyOfRange(in,0,leftLength);
        int[] preRightTree = Arrays.copyOfRange(pre,leftLength+1,pre.length);
        int[] inRightTree = Arrays.copyOfRange(in,mid+1,in.length);

        root.left = reConstructBinaryTree(preLeftTree,inLeftTree);
        root.right = reConstructBinaryTree(preRightTree,inRightTree);
        return root;
    }

}

知识点

• 空串与null串

    public static void main(String args[])
    {
        int[] a = new int[0];
        int[] b = null;
        int[] c = {};
        System.out.println(a.length);    // 0
        System.out.println(b.length);    // error:对null调用length方法
        System.out.println(c.length);    // 0
    }

故，要检测一个数组既不为空，也不为null：

if(array != null && array.length != 0)  // 必须先检测是否为空，否则可能报错。
    Sysout.out.print("array is empty！")

• 字符串拷贝

System.arraycopy(src, 2, dest, 5, 1);
//从src中的第2个位置到dest的第5个位置;总数为1个
dest=Arrays.copyOfRange(src, 2, 4);
//从src中的第2个位置到第4个位置;总数为2个 2=obj<4