递归（一）

第一列：*
第二列：**
第三列：***
第四列：****
。。。
求N列中 * 的个数？

我们发现：
1）最后一列，它的值是N。
2）总个数 = N + 所有剩余列的和。

public int triangle(int c) {
　　return c + getCount(c - 1);
}
以上的代码是错误的，递归中必须有一个终止条件，否则会无限地递归下去，引发程序崩溃。

public class Triangle {

    public int triangle(int c) {
        if (c > 0) {
            int i = c - 1;
            return c + triangle(i);
        }
        return 0;
    }

    public static void main(String[] args) {
        Triangle t = new Triangle();
        System.out.println(t.triangle(4));
    }

}

打印结果：
10

递归方法的特征：
1）调用自身
2）当它调用自身的时候，它这么做是为了解决更小的问题。
3）存在某个足够简单的问题的层次，在这一层的算法中不需要调用自己就可以直接解答，且返回结果。

变位字：

public class Anagram {

    static int size;

    static char[] arrChar;

    static int count;

    public static void main(String[] args) {
        String input = "cats";
        arrChar = input.toCharArray();
        size = arrChar.length;
        doAnagram(size);
    }

    public static void doAnagram(int newSize) {
        if (newSize == 1) {
            return;
        }
        for (int i = 0; i < newSize; i++) {
            doAnagram(newSize - 1);
            if (newSize == 2)
                display();
            rotate(newSize);
        }
    }

    public static void display() {
        System.out.print(++count + " : ");
        for (int i = 0; i < size; i++) {
            System.out.print(arrChar[i]);
        }
        if (count % 6 == 0) {
            System.out.println();
        }
        else {
            System.out.print("\t");
        }
    }

    public static void rotate(int newSize) {
        int j;
        int position = size - newSize;
        char temp = arrChar[position];
        for (j = position + 1; j < size; j++) {
            arrChar[j - 1] = arrChar[j];
        }
        arrChar[j - 1] = temp;
    }

}

打印结果：
1 : cats 　　  2 : cast 　　  3 : ctsa 　    4 : ctas 　 　 5 : csat 　　  6 : csta 
7 : atsc 　　  8 : atcs　　   9 : asct 　　 10 : astc 　　11 : acts 　　12 : acst
13 : tsca 　　14 : tsac 　　15 : tcas 　　16 : tcsa 　　17 : tasc 　　18 : tacs　　
19 : scat 　　20 : scta 　　21 : satc 　　22 : sact　　 23 : stca 　　24 : stac

递归二分查找：递归的二分查找和非递归二分查找同样是大O效率 O(logN) ，递归的二分查找比较简洁一些，但速度可能会慢一些。

public class OrderArray {

    private long[] array;

    private int maxLength;

    public OrderArray(int size) {
        array = new long[size];
        maxLength = 0;
    }

    //插入时判断大小，保证有序。
    public void insert(long l) {
        int i;
        for (i = 0; i < maxLength; i++) {
            if (array[i] > l) {
                break;
            }
        }
        for (int j = maxLength; j > i; j--) {
            array[j] = array[j - 1];
        }
        array[i] = l;
        maxLength++;
    }

    //二分查找
    public int find(long key) {
        int lower = 0;
        int upper = maxLength - 1;
        int index;
        while (true) {
            index = (lower + upper) / 2;
            if (array[index] == key) {
                return index;
            }
            else if (lower > upper) {
                return -1;
            }
            else {
                if (array[index] < key) {
                    lower = index + 1;
                }
                else {
                    upper = index - 1;
                }
            }
        }
    }

    public int recFind(long key) {
        return recFind(key, 0, maxLength - 1);
    }

    //递归二分查找
    private int recFind(long key, int lower, int upper) {
        int index = (lower + upper) / 2;
        if (array[index] == key) {
            return index;
        }
        else if (lower > upper) {
            return -1;
        }
        else {
            if (array[index] < key)
                lower = index + 1;
            else
                upper = index - 1;
            return recFind(key, lower, upper);
        }
    }

    public void display() {
        for (int i = 0; i < maxLength; i++) {
            System.out.println("NO." + (i + 1) + " --> " + array[i]);
        }
    }

}

    public static void main(String[] args) throws ParseException, InterruptedException {
        OrderArray array = new OrderArray(100);

        array.insert(49);
        array.insert(158);
        array.insert(81);
        array.insert(93);
        array.insert(18);
        array.insert(1);
        array.insert(9);
        array.insert(7);
        array.insert(81);
        array.insert(669);
        
        array.display();
        
        int key = 18;
        System.out.println(key + " is NO " + (array.recFind(key)+1));
    }

打印结果：
NO.1 --> 1
NO.2 --> 7
NO.3 --> 9
NO.4 --> 18
NO.5 --> 49
NO.6 --> 81
NO.7 --> 81
NO.8 --> 93
NO.9 --> 158
NO.10 --> 669
18 is NO 4