递归 --与三角数字,阶乘,变位字,汉诺塔问题,递归的二分查找法,归并排序

                           1)三角数字

                                         数列1,3,6,10,15,21,...   这个数列中的第n项是由第n-1项加n得到的.

                            int triangle(int n){

                           int total=0;

                             while(n>0){

                             total+=n--;

                              }

                             return total;

                           }

                           2)变位字

                                           一个单词cat的全排列,会形成多少个不同的单词,打印出它们.

                                          1全排列最右连的n-1个字母

                                          2 轮换所有n个字母

                                         3 重复以上步聚n次

                   

public class Anagram {

    private static  char[] words;
    private static int count;

    public static void main(String[] args) {
        if(args.length<1) {
            System.out.println("请输入需要打印变位字的单词");
            System.exit(0);
        }
        words=args[0].toCharArray();
        count=0;
        doAnagram(words.length);
    }

    private static void doAnagram(int newSize) {
        if(newSize==1)
            return;
        for(int j=0; j<newSize; j++) {
            doAnagram(newSize-1);
            if(newSize==2)
                displayWord();
            rotate(newSize);
        }
    }


    private static void rotate(int newSize) {
        int j=words.length-newSize;
        char temp=words[j];
        for(; j+1<words.length; j++) {
            words[j]=words[j+1];
        }
        words[j]=temp;
    }


    private static void displayWord() {
        System.out.print(++count+":");
        for(int j=0; j<words.length; j++) {
            System.out.print(words[j]);
        }
        System.out.print("   ");
        if(count%5==0)
            System.out.println("");
    }



}

        

        

         

3 汉诺塔问题

  假设想要把n个盘子从源塔座(S)移动到目标塔座(D)上,有一个可以使用的中介塔座(I)

   1 从塔座S移动包含n-1个盘子到塔座I上

   2 从塔座S移动剩余那个盘子到塔座D上

 3 从塔座I移动n-1个盘子到塔座D上

这样移动n个盘子的问题变成了移动n-1个盘子的问题.

4 归并排序

简单排序都要用O(N^2)时间,归并排序只要O(N*logN)时间

import java.util.Random;
public class MergeSort {


    public static void main(String[] args) {
        int size=15;
        Random ran = new Random();
        int[] sort = new int[size];
        for(int i = 0 ; i < size ; i++) {
            sort[i] = ran.nextInt(50);
        }
        System.out.print("排序前的数组为");
        for(int i : sort) {
            System.out.print(i+" ");
        }
        int[] workSpace=new int[size];
        recMergeSort(workSpace,sort,0,size-1);
        System.out.println();
        System.out.print("排序后的数组为");
        for(int i : sort) {
            System.out.print(i+" ");
        }
    }

    /**
     * 归并排序,时间复杂度O(N*LogN),空间复杂度,需要一个和原数组一样大小的空间O(N)
     * @param sort
     */

    private static void recMergeSort(int[] workSpace,int[] sort,int lowerBound,int upperBound) {
        if(lowerBound==upperBound)
            return;
        else {
            int mid=(lowerBound+upperBound)/2;
            recMergeSort(workSpace,sort,lowerBound,mid);
            recMergeSort(workSpace,sort,mid+1,upperBound);
            merge(workSpace,sort,lowerBound,mid+1,upperBound);
        }
    }




    private static void merge(int[] workSpace,int[] sort,int lowPtr,int highPtr,int upperBound) {
        int j=0;
        int lowerBound=lowPtr;
        int mid=highPtr-1;
        int n=upperBound-lowerBound+1;
        while(lowPtr<=mid&&highPtr<=upperBound) {
            if(sort[lowPtr]<sort[highPtr])
                workSpace[j++]=sort[lowPtr++];
            else
                workSpace[j++]=sort[highPtr++];
        }
        while(lowPtr<=mid)
            workSpace[j++]=sort[lowPtr++];
        while(highPtr<=upperBound)
            workSpace[j++]=sort[highPtr++];
        for(j=0; j<n; j++) {
            sort[lowerBound+j]=workSpace[j];
        }
    }


}

5)表插入排序

   先把数据插入到一个有序链表中,然后清空数组,再把数据复制回数组,插入第N个数据平均比较n/2次, 

     数据序数  平均比较次数

    1                  0

    2                 1

    3                 (1+2)/2

   4                 (1+2+3)/3

   5                  (1+2+3+4)/4

....

  N                 (1+2+3+4+N-1)/n   =n(n-1)/(2*n)= (n-1)/2       

    -----------------------------------------------------------------------------------

总平均比较次数(0/2+1/2+2/2+..+(n-1)/2)= 0.5*(n-1)*n*0.5=N^2/4

总复制次数2N,优于直接插入排序的 平均比较次数n^2/2,复制次数n^2/2,但空间占用是O(n)