版权声明：中华人民共和国持有版权 https://blog.csdn.net/Fly_Fly_Zhang/article/details/83473035
递归的优缺点：
-
递归条件: 1，趋近于某个临近值。2，循环调用自己本身。
-
优点：代码简洁。
-
缺点：
-
递归由于是函数调用自身，而函数调用是有时间和空间的消耗的：每一次函数调用，都需要在内存栈中分配空间以保存参数、返回地址以及临时变量，而往栈中压入数据和弹出数据都需要时间。->效率
-
.递归中很多计算都是重复的，由于其本质是把一个问题分解成两个或者多个小问题，多个小问题存在相互重叠的部分，则存在重复计算，如fibonacci斐波那契数列的递归实现。->效率
-
调用栈可能会溢出，其实每一次函数调用会在内存栈中分配空间，而每个进程的栈的容量是有限的，当调用的层次太多时，就会超出栈的容量，从而导致栈溢出。->性能
递归练习:
import java.util.Arrays;
import java.util.Scanner;
//栈溢出信息；
//Exception in thread "main" java.lang.StackOverflowError
public class HomeWork {
//for循环斐波那契前n项和。
public static int forFeiBoNaQie(int n){
int a=0;
int b=1;
int tmp;
int sum=1;
if(n<=0){
return -1;
}else if(n==1){
return sum;
}else {
for (int i = 1; i < n; i++) {
tmp=a+b;
a=b;
b=tmp;
sum+=b;
}
}
return sum;
}
//斐波那契第n项值；
public static int diGuiFeiBoNaQieN(int n) {
int x ;
if (n <= 0) {
return -1;
} else {
if (n == 1) {
return x=1;
}else if (n == 2) {
return x=1;
} else {
x = diGuiFeiBoNaQieN(n - 1) + diGuiFeiBoNaQieN(n - 2);
}
return x;
}
}
//递归查找前n项和；
public static int diGuiFeiBoNaQieSum(int n) {//递归太慢。
int sum=1;
if(n==1){
return sum;
}else{
sum=diGuiFeiBoNaQieSum(n-1)+diGuiFeiBoNaQieN(n);
}
return sum;
}
//普通二分法查找。
public static int Search(int [] array,int key){
for (int i = 0; i <array.length ; i++) {
for (int j = 0; j <array.length-i-1 ; j++) {
if(array[j]>array[j+1]){
int tmp;
tmp=array[j];
array[j]=array[j+1];
array[j+1]=tmp;
//array[j]=array[j]+array[j+1];
//array[j+i]=array[j]-array[j+1];
//array[j]=array[j]-array[j+1];
}
}
}
System.out.println(Arrays.toString(array));
int min=0;
int max=array.length;
int mid=0;
while(min<max){ //array[mid]!=key 这两个条件都可以
mid=(max+min)>>>1;
if(array[mid]==key){
return mid; //break 也行。
}else if(array[mid]>key){
max=mid;
}else{
min=mid;
}
}
return mid;
}
//选择排序
public static int[] insertSort(int [] array) {
int j;
for (int i = 1; i < array.length; i++) { //insertSort.
int tmp = array[i];
for (j = i - 1; j >= 0; j--) {
if (array[j] > tmp) {
array[j + 1] = array[j];
} else {
break;
}
}
array[j + 1] = tmp;
}
return array;
}
public static int diGuiSearch(int [] array,int key){
int min=0;
int max=array.length;
int mid=(max+min)>>>1;
if(array[mid]==key){
return mid;
}
else if(array[mid]>key){
return diGuiSearch(array, key);
}else if(array[mid]<key){
return diGuiSearch(array, key);
}
return mid;
}
public static void main (String args []){
Scanner scanner=new Scanner(System.in);
String str=scanner.nextLine();
int n= Integer.parseInt(str);
System.out.println(forFeiBoNaQie(n));
System.out.println(diGuiFeiBoNaQieSum(n));
int[] array=new int[]{9,8,7,6,5,4,2,6};
int key=6;
System.out.println(Search(array,key));
int [] array1={9,8,7,6,5,4,2,6};
System.out.println(diGuiSearch((insertSort(array1)),key));
}
}
汉诺塔
public class hannio {
public static void move(char pos1,char pos2) {
System.out.print(pos1+"==>"+pos2 + " ");
}
public static void hanio(int n,char pos1,char pos2,char pos3) {
if(n == 1) {
move(pos1,pos3);
} else {
hanio(n-1,pos1,pos3,pos2);
move(pos1,pos3);
hanio(n-1,pos2,pos1,pos3);
}
}
public static void main(String[] args) {
hanio(1,'A','B','C');
System.out.println();
hanio(2,'A','B','C');
System.out.println();
hanio(3,'A','B','C');
}
}
字符串的左旋和右旋以及字符子串的逆置：
public class Damo {
public static String inversion(String str ,int begin,int end){
char tmp;
char [] ch=str.toCharArray();
while (begin < end){
tmp=ch[begin];
ch[begin]=ch[end];
ch[end]=tmp;
begin++;
end--;
}
return String.copyValueOf(ch);
}
public static char[] inversion1(char[] ch,int begin,int end){
char tmp;
//char [] ch=str.toCharArray();
while (begin < end){
tmp=ch[begin];
ch[begin]=ch[end];
ch[end]=tmp;
begin++;
end--;
}
return ch;
}
public static String left(String str,int n){
str=inversion(str,0,n);
str=inversion(str,n+1,str.length()-1);
str=inversion(str,0,str.length()-1);
return str;
}
public static String right(String str,int n){
str=inversion(str,n,str.length()-1);
str=inversion(str,0,str.length()-1);
str=inversion(str,0,n-1);
return str;
}
public static String fun(String str1){
if(str1==null){
return null;
}
char []ch=str1.toCharArray();
ch=inversion1(ch,0,ch.length-1);
//System.out.println(String.copyValueOf(ch));
int i=0;
int j=0;
while(j<=ch.length) { //这里必须等于，否则最后的子字符串没法逆置；
if(ch[i]==' '){
i++;
j++;
}else if (j == ch.length||ch[j] == ' ') {// 判断的时候，数组越界的选项一定要放前面，并且要双或，
ch = inversion1(ch, i, j - 1);//否则pvm还会判断后面的，这样就会造成数组越界。
j++;
i = j;
} else{
j++;
}
}
return String.copyValueOf(ch);
}
public static void main (String args []){
String str=new String("abcdefg");
int n=1;
System.out.println(right(str,n));
String str1="tulun is here";
System.out.println(fun(str1));
}
}