递归及归并排序

   典型的汉诺塔圆盘移动方法：
  

    /**
     * 每次只能移动一个圆盘，将原本放在初始位置的圆盘借助中间位置按原来的顺序移动到目标位置
     * 
     * @param topN 开始时在初始位置共有多少圆盘
     * @param from 初始位置
     * @param inter 中间位置
     * @param to 目标位置
     */
    public static void doTowers(int topN, char from, char inter, char to)
    {
        if(topN == 1)//将最后一个圆盘放到最终位置
            System.out.println(" DISK 1 FROM " + from + " TO " + to);
        else
        {
            doTowers(topN - 1, from, to, inter);//借助于目标位置先将除最后一个圆盘的所有圆盘放在中间位置
            System.out.println(" DISK " + topN + " FROM " + from + " TO " + to);
            doTowers(topN - 1, inter, from, to);//借助于初始位置将已经处于中间位置的除最后一个圆盘的所有圆盘放在目标位置
        }
    }

    归并排序类：
  

/**
 * @param args 归并排序，递归方法
 * @author xujp1
 */
class Darray
{

    private final long[] theArray;
    private int          eItem;

    public Darray(int max)
    {
        theArray = new long[max];
        eItem = 0;
    }

    public void insert(long value)
    {
        theArray[eItem++] = value;
    }

    public void display()
    {
        for(int i = 0; i < eItem; i++)
            System.out.print(theArray[i] + "  ");
        System.out.println();
    }

    public void mergeSort()
    {
        long[] workspace = new long[eItem];
        recMergeSort(workspace, 0, eItem - 1);
    }

    public void recMergeSort(long[] workspace, int lowerBound, int upperBound)
    {
        if(lowerBound == upperBound)
            return;
        else
        {
            int mid = (lowerBound + upperBound) / 2;
            recMergeSort(workspace, lowerBound, mid); // 归并前半部分
            recMergeSort(workspace, mid + 1, upperBound); // 归并后半部分
            merge(workspace, lowerBound, mid + 1, upperBound);
        }
    }

    /**
     * 类似于两个数组从小到大合并到第三个数组
     * 
     * @param workspace 中间变量（类似于第三个数组，即合并的结果）
     * @param lowerPtr 数组下标最左边（类似于第一个数组的index1）
     * @param highPtr 数组下标中间位置（类似于第二个数组的index1）
     * @param upperBound 数组下标最右边，比较结束后可用此参数。
     */
    public void merge(long[] workspace, int lowerPtr, int highPtr, int upperBound)
    {
        int j = 0;
        int lowerBound = lowerPtr; // lowerBound后续用到
        int mid = highPtr - 1; // 作为跟lowerPtr比较的参数
        int n = upperBound - lowerPtr + 1; // 本次归并后的数组大小
        /**
         * 最左边的值和中间的值进行比较，哪个数比较小则赋值给workspace,同时下标加1。
         */
        while (lowerPtr <= mid && highPtr <= upperBound)
            if(theArray[lowerPtr] > theArray[highPtr])
                workspace[j++] = theArray[highPtr++];
            else
                workspace[j++] = theArray[lowerPtr++];
        while (lowerPtr <= mid)
            workspace[j++] = theArray[lowerPtr++];
        while (highPtr <= upperBound)
            workspace[j++] = theArray[highPtr++];
        for(int i = 0; i < n; i++)
            theArray[lowerBound + i] = workspace[i];
    }

}

  注：以上代码均出自JAVA数据结构和算法第二版