算法与设计学习过程
坚持更新（使用JAVA语言）

递归：实现汉诺塔问题

public class Hannota {
    public static void main(String[] args) {
        int N = 3;
        Hanoi('A', 'B', 'C', N);      //使用
    }
    public static void Hanoi(char from, char inter, char to, int  N) {    //方法
        if (N == 1){
            System.out.println("移动 1 从 "+ from + " 到 " + to);  //只有一个的情况下 
        }else {
            Hanoi( from, to, inter, N - 1); 
            System.out.println("移动 " + N + " 从 " + from + " 到 " + to);         
            Hanoi( inter, from, to, N - 1);         
        } 
    }
}

递归：实现排序问题

public class Sort {
	public static int S[] = new int[]{1,2,3};    //定义一个数组s{1,2,3}
	public static void main(String[] args) {
		perm(S,0,S.length-1);
	}
	private static void swap(int i1, int i2) {
		int temp = S[i2];
		S[i2] = S[i1];
		S[i1] = temp;
	}
	public static void perm(int arr[], int begin,int end) {
		if(end==begin){			//一到递归的出口就输出数组，此数组为全排列
		    for(int i=0;i<=end;i++){
			System.out.print(arr[i]+" ");
	}
			System.out.println();
			return;
	}
			
		else{
			for(int j=begin;j<=end;j++){	
				swap(begin,j);		//for循环将begin~end中的每个数放到begin位置中去
				perm(arr,begin+1,end);	//假设begin位置确定，那么对begin+1~end中的数继续递归     //递归
				swap(begin,j);		//换过去后再还原
			}
		}
	}
}

分治：递归实现的快速排序

public class Quicksort {
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] src = {7, 9, 2, 3, 6, 5, 4, 1, 8, 10};
		System.out.print("原数组为：");
		for (int i : src) {
			System.out.print(" " + i);
			
		}
		System.out.print("\n");
		quickSort(src);
		System.out.print("现数组为：");
		for (int i : src) {
			System.out.print(" " + i);
		}
	}
	
	/**
	 * 对整个源数组进行快速排序
	 * @param src
	 * @return
	 */
	public static void quickSort(int[] src) {
		sortPartision(src, 0, src.length - 1);
	}
	
	/**
	 * 排序分治区域  
	 * @param src
	 * @param start
	 * @param end
	 */
	
	private static void sortPartision(int[] src, int start, int end) {
		int i = start;    //将开始赋值给i 
		int r = end;         //将结尾赋值给r
		int x = src[i];       
		while (i < r) {
			while (i < r && src[r] > x) {
				r--;
			}
			if (src[r] < x) {
				src[i] = src[r];
				i++;
			}
			while (i < r && src[i] < x) {
				i++;
			}
			if (src[i] > x) {
				src[r] = src[i];
				r--;
			}
		}
		src[i] = x;
		int I = i;
		if (I > start) {
			sortPartision(src, start, I-1);
		}
		if (I < end) {
			sortPartision(src, I+1, end);
		}
	}
}

分治：递归实现的合并排序

public class Mergesort {
    static int arr[] = {100, 20, 15, 30, 5, 75, 40, 12, 514};  //定义排序前的一个是数组
    public static void main(String args[]) {
        System.out.println("数据排序之前 ： ");
        // 排序前打印数组
        printArray(arr, 0, arr.length - 1);
        System.out.println("-----------------------------");

        // 用递归实现排序
        mergeSort(0, arr.length - 1);

        System.out.println("-----------------------------");

        // 排序后打印数组
        System.out.println("排序后打印数组:");
        printArray(arr, 0, arr.length - 1);
    }
    /**
     * 用于合并排序的递归算法
     *
     * @param start
     * @param end
     */
    public static void mergeSort(int start, int end) {
        int mid = (start + end) / 2;
        if (start < end) {
            // 排序左半部分
            mergeSort(start, mid);
            // 排序右半部分
            mergeSort(mid + 1, end);
            // 合并左右两半
            merge(start, mid, end);
        }

    }
    /**
     * @param start
     * @param mid
     * @param end
     */
    private static void merge(int start, int mid, int end) {
        // 初始化临时数组和索引
        int[] tempArray = new int[arr.length];
        int tempArrayIndex = start;
        System.out.print("合并前:  ");
        printArray(arr, start, end);
        int startIndex = start;
        int midIndex = mid + 1;
        // 它将迭代直到较小的列表到达结尾
        while (startIndex <= mid && midIndex <= end) {
            if (arr[startIndex] < arr[midIndex]) {
                tempArray[tempArrayIndex++] = arr[startIndex++];
            } else {
                tempArray[tempArrayIndex++] = arr[midIndex++];
            }
        }
        // 复制剩余的元素
        while (startIndex <= mid) {
            tempArray[tempArrayIndex++] = arr[startIndex++];
        }
        while (midIndex <= end) {
            tempArray[tempArrayIndex++] = arr[midIndex++];
        }
        // 排序后将tempArray复制到实际数组
        for (int i = start; i <= end; i++) {
            arr[i] = tempArray[i];
        }
        System.out.print("合并后:   ");
        printArray(tempArray, start, end);
        System.out.println();
    }
    /**
     * 打印数组
     *
     * @param arr   传入的数组
     * @param start 遍历开始的位置
     * @param end   遍历结束的位置
     */
    public static void printArray(int arr[], int start, int end) {
        for (int i = start; i <= end; i++) 
        {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

1	public class Hannota {
2	public static void main(String[] args) {
3	int N = 3;
4	Hanoi('A', 'B', 'C', N); //使用
5	}
6	public static void Hanoi(char from, char inter, char to, int N) { //方法
7	if (N == 1){
8	System.out.println("移动 1 从 "+ from + " 到 " + to); //只有一个的情况下
9	}else {
10	Hanoi( from, to, inter, N - 1);
11	System.out.println("移动 " + N + " 从 " + from + " 到 " + to);
12	Hanoi( inter, from, to, N - 1);
13	}
14	}
15	}

1	public class Sort {
2	public static int S[] = new int[]{1,2,3}; //定义一个数组s{1,2,3}
3	public static void main(String[] args) {
4	perm(S,0,S.length-1);
5	}
6	private static void swap(int i1, int i2) {
7	int temp = S[i2];
8	S[i2] = S[i1];
9	S[i1] = temp;
10	}
11	public static void perm(int arr[], int begin,int end) {
12	if(end==begin){ //一到递归的出口就输出数组，此数组为全排列
13	for(int i=0;i<=end;i++){
14	System.out.print(arr[i]+" ");
15	}
16	System.out.println();
17	return;
18	}
19
20	else{
21	for(int j=begin;j<=end;j++){
22	swap(begin,j); //for循环将begin~end中的每个数放到begin位置中去
23	perm(arr,begin+1,end); //假设begin位置确定，那么对begin+1~end中的数继续递归 //递归
24	swap(begin,j); //换过去后再还原
25	}
26	}
27	}
28	}

1	public class Quicksort {
2
3	/**
4	* @param args
5	*/
6	public static void main(String[] args) {
7	int[] src = {7, 9, 2, 3, 6, 5, 4, 1, 8, 10};
8	System.out.print("原数组为：");
9	for (int i : src) {
10	System.out.print(" " + i);
11
12	}
13	System.out.print("\n");
14	quickSort(src);
15	System.out.print("现数组为：");
16	for (int i : src) {
17	System.out.print(" " + i);
18	}
19	}
20
21	/**
22	* 对整个源数组进行快速排序
23	* @param src
24	* @return
25	*/
26	public static void quickSort(int[] src) {
27	sortPartision(src, 0, src.length - 1);
28	}
29
30	/**
31	* 排序分治区域
32	* @param src
33	* @param start
34	* @param end
35	*/
36
37	private static void sortPartision(int[] src, int start, int end) {
38	int i = start; //将开始赋值给i
39	int r = end; //将结尾赋值给r
40	int x = src[i];
41	while (i < r) {
42	while (i < r && src[r] > x) {
43	r--;
44	}
45	if (src[r] < x) {
46	src[i] = src[r];
47	i++;
48	}
49	while (i < r && src[i] < x) {
50	i++;
51	}
52	if (src[i] > x) {
53	src[r] = src[i];
54	r--;
55	}
56	}
57	src[i] = x;
58	int I = i;
59	if (I > start) {
60	sortPartision(src, start, I-1);
61	}
62	if (I < end) {
63	sortPartision(src, I+1, end);
64	}
65	}
66	}

1	public class Mergesort {
2	static int arr[] = {100, 20, 15, 30, 5, 75, 40, 12, 514}; //定义排序前的一个是数组
3	public static void main(String args[]) {
4	System.out.println("数据排序之前： ");
5	// 排序前打印数组
6	printArray(arr, 0, arr.length - 1);
7	System.out.println("-----------------------------");
8
9	// 用递归实现排序
10	mergeSort(0, arr.length - 1);
11
12	System.out.println("-----------------------------");
13
14	// 排序后打印数组
15	System.out.println("排序后打印数组:");
16	printArray(arr, 0, arr.length - 1);
17	}
18	/**
19	* 用于合并排序的递归算法
20	*
21	* @param start
22	* @param end
23	*/
24	public static void mergeSort(int start, int end) {
25	int mid = (start + end) / 2;
26	if (start < end) {
27	// 排序左半部分
28	mergeSort(start, mid);
29	// 排序右半部分
30	mergeSort(mid + 1, end);
31	// 合并左右两半
32	merge(start, mid, end);
33	}
34
35	}
36	/**
37	* @param start
38	* @param mid
39	* @param end
40	*/
41	private static void merge(int start, int mid, int end) {
42	// 初始化临时数组和索引
43	int[] tempArray = new int[arr.length];
44	int tempArrayIndex = start;
45	System.out.print("合并前: ");
46	printArray(arr, start, end);
47	int startIndex = start;
48	int midIndex = mid + 1;
49	// 它将迭代直到较小的列表到达结尾
50	while (startIndex <= mid && midIndex <= end) {
51	if (arr[startIndex] < arr[midIndex]) {
52	tempArray[tempArrayIndex++] = arr[startIndex++];
53	} else {
54	tempArray[tempArrayIndex++] = arr[midIndex++];
55	}
56	}
57	// 复制剩余的元素
58	while (startIndex <= mid) {
59	tempArray[tempArrayIndex++] = arr[startIndex++];
60	}
61	while (midIndex <= end) {
62	tempArray[tempArrayIndex++] = arr[midIndex++];
63	}
64	// 排序后将tempArray复制到实际数组
65	for (int i = start; i <= end; i++) {
66	arr[i] = tempArray[i];
67	}
68	System.out.print("合并后: ");
69	printArray(tempArray, start, end);
70	System.out.println();
71	}
72	/**
73	* 打印数组
74	*
75	* @param arr 传入的数组
76	* @param start 遍历开始的位置
77	* @param end 遍历结束的位置
78	*/
79	public static void printArray(int arr[], int start, int end) {
80	for (int i = start; i <= end; i++)
81	{
82	System.out.print(arr[i] + " ");
83	}
84	System.out.println();
85	}
86	}