基础

java编程模型、数据抽象、基本数据结构、集合类的抽象数据类型、算法性能分析的方法

解决大型问题或大量小型问题，有效利用时间和空间。

欧几里得算法的java语言描述(求p和q的最大公约数)：

public static int gcd(int p,int q){
  if(q == 0) return p;
  int r = p % q;
  return gcd(q,r);
}

基础编程模型

java基本结构：原始数据类型、语句（声明、赋值、条件、循环、调用和返回）、数组、静态方法、字符串、标准输入\输出、数据抽象。

数组实现方阵相乘 a[][] *b[][] = c[][]：

int N = a.length;
double[] [] c = new double[N][N];
for(int i = 0;i < N;i++)
  for(int j = 0;j <N;j++)
    for(int k = 0;k<N;k++)
        c[i][j] += a[i][k] * b[k][j]
}

将一个数组变量赋予另一个变量，那ing个变量会指向同一个数组，想要复制数组要声明、创建并初始化一个新的数组，然后将元素挨个赋值：

int[] a = new int[N];
a[i] = 1234;
int[] b= a;
b[i] = 5678;   //a[i]的值也为5678

素数判断：

public static boolean isPrime(int N){
    if(N < 2) return false;
    for(int i = 2; i*i <=N;i++){
        if(N % i == 0) return false;
    }
    return ture;
}

计算平方根（牛顿迭代法）

public  static double sqrt(double c){
  if (c<0) return Double.NaN;
  double err = 1e-15;
  double t = c;
  while(Math.abs(t - c/t) > err * t)
    t = (c/t + t) / 2.0;
   return t;
} 

递归最重要的三点:

1. 总有一个最简单的情况。
2. 总是尝试调用解决一个规模更小的子问题
3. 父问题和子问题之间不应该有交集

二分查找的递归实现：（数组必须是有序的）
public static int rank(int key ,int[] a){
    return rank(key,a,0,a.length-1);
}
public static int rank(int key, int[] a,int low,int high){
    if(low > high)  return -1;
    int mid = low + (high - low) / 2;
    if(key < a[mid]) return rank(key,a,low,mid-1)
    else if(key > a[mid]) return rank(key,a,mid+1,high)
    else return mid; 
}
一般实现：
public static int rank(int key, int[] a){
    int low = 0;
    int high = a.length - 1;
    while( low < high){
    int mid = low + (high - low) / 2;
    if(key < a[mid]) high = mid - 1;
    else if(key > a[mid]) low = mid + 1;
    else return mid;
   }
    return -1;
}

API的目的是将调用和实现分离

Math.abs(-2147483648)   //整数溢出结果为 -2147483648
double初始化为无穷大数 ：Double.POSITIVE_INFINITY和Double.NEGATIVR_INFINITY.
1/0除零异常 ，1.0/0.0 值为 Infinity.