递归--reservsion

package com.jx.xy.Interview.Recursion;

import java.util.Scanner;
import java.util.Stack;

public class Main {
static int sum11=0;
public static void main(String[] args) {
Main m = new Main();

System.out.println();
System.out.println("===========基本===============");
System.out.println();
int sum=m.getSum(100);
System.out.println("计算1~n之间所有自然数的和: "+sum);

int sum1=m.getSum1(100);
System.out.println("计算1~n之间所有自然数的乘积: "+sum1);

int f=m.f(10);//look look 文档注释
System.out.println("f(n)=2*f(n-1)+f(n-2): "+f);

int ff=m.ff(10);//斐波那契数 1 1 2 3 5 8 ...
//f(n)=f(n-1)+f(n-2)
System.out.println("f(n)=f(n-1)+f(n-2): "+ff);


System.out.println();
System.out.println("========汉诺塔==================");
System.out.println();
/**
* 汉诺塔
* A B C 三个柱子
* n个盘子（由大到小）
* digui(n,x,y,z)
* x:初始 y:中间 z:目标
*/
System.out.println("请输入一个值");
Scanner scan=new Scanner(System.in);
//int n =scan.nextInt();
int n=3;
char x='A';//初始
char y='B';//中间
char z='C';//目标

digui(n,x,y,z);
System.out.println("总共花费多少次："+sum11);

System.out.println();
System.out.println("===========快排===============");
System.out.println();

int[] arr = {3,13,1,7,20,5,9,4,11};
quickSort(arr, 0, arr.length - 1);
for (int i : arr) {
System.out.print(i + " ");
}

}
/**
* 计算1~n之间所有自然数的和
* @param n
* @return
*/
public int getSum(int n) {
if(n==1) {
return 1;
}else {
return n+getSum(n-1);
}
}

/**
*计算1~n之间所有自然数的乘积
*/
public int getSum1(int n) {
if(n==1) {
return 1;
}else {
return n*getSum(n-1);
}
}

/**
* f(0)=1 , f(1)=4
* f(n+2)=2*f(n+1)+f(n)
* -->f(n)=2*f(n-1)+f(n-2)
*/
public int f(int n) {
if(n==0) {
return 1;
}else if(n==1) {
return 4;
}else {
return 2*f(n-1)+f(n-2);
}
}

/**
* 斐波那契数 1 1 2 3 5 8 ...
* f(n)=f(n-1)+f(n-2)
*/
public int ff(int n) {
if(n==0) {
return 1;
}else if(n==1) {
return 1;
}else {
return ff(n-1)+ff(n-2);
}
}

/**
* 汉诺塔
* A B C 三个柱子
* n个盘子
* digui(n,x,y,z)
* x:初始 y:中间 z:目标
* sum11 花费次数
*/

public static void digui(int i,char x,char y,char z){
if(i==1){
System.out.println(x+"——》"+z);
sum11++;
}else{
digui(i-1, x, z, y); //先将初始塔的前i-1个盘子借助目的塔移动到借用塔上
sum11++;
System.out.println(x+"——》"+z);//将剩下的一个盘子移动到目的塔上
digui(i-1, y, x, z); //最后将借用塔上的i-1个盘子移动到目的塔上
//初步理解请理解2个盘子，然后理解3个盘子的代码实现
}
}


/**
* 快排 （递归）
* quickSort(int[] arr, int left, int right)
*
* partition(int[] arr, int left, int right)
*/
static void quickSort(int[] arr, int left, int right) {
int dp;
if (left < right) {
dp = partition(arr, left, right);
quickSort(arr, left, dp - 1);
quickSort(arr, dp + 1, right);
}
}
// 非递归
// static void quickSort(int[] arr) {
// if (arr == null || arr.length == 0) return;
// Stack<Integer> stack = new Stack<>();
// stack.push(0);
// stack.push(arr.length - 1);
// while (!stack.isEmpty()) {
// int right = stack.pop();
// int left = stack.pop();
// //如果最大索引小于等于左边索引，说明排序结束了
// if (right <= left) continue;
//
// int dp = partition(arr, left, right);
// if (left < dp - 1) {
// stack.push(left);
// stack.push(dp - 1);
// }
// if (dp + 1 < right) {
// stack.push(dp + 1);
// stack.push(right);
// }
// }
// }

static int partition(int[] arr, int left, int right) {

int key = arr[left];//以最左边为切分点

while (left < right) {
while (left < right && arr[right] >= key) {
right--;
}
if (left < right) { //说明key > arr[right]，左边需要用右元素填充
arr[left++] = arr[right];
}
while (left <right && arr[left] <= key) {
left++;
}
if (left < right) { //说明arr[left] > key，右边需要用左元素填充
arr[right--] = arr[left];
}
}
arr[left] = key; //此时left = right; 将arr[left]置为切分点，这样就能确保了左边都是小于key，右边的是大于等于key
return left;
}

}