String的应用及递归

1.String的应用

(1).字符串的左旋和右旋

public static String reverse0(String str,int begin,int end) {
        char[] ch = str.toCharArray();
        char tmp;
        while(begin < end) {
            tmp = ch[begin];
            ch[begin] = ch[end];
            ch[end] = tmp;
            begin++;
            end--;
        }
        return String.copyValueOf(ch);
    }

这是一个逆置函数，然后左旋就是先进行部分逆置，然后在整体逆置；

而右旋则相反，先进行整体逆置，在部分逆置；

左旋：

 public static void reverseLeft(String str,int n){
       if(str==null||n<0||n>=str.length()){
           return;
       }
       int left=0;
       int leftend=n-1;
       int right=n;
       int rightend=str.length()-1;
        str=reverse0(str,left,leftend);
        str=reverse0(str,right,rightend);
        str=reverse0(str,left,rightend);
        System.out.println(str);
    }

右旋：

 public static void reverseRight(String str,int n){
        if(str==null||n<0||n>=str.length()){
            return;
        }
        int left=0;
        int leftend=n-1;
        int right=n;
        int rightend=str.length()-1;
        str=reverse0(str,left,rightend);
        str=reverse0(str,left,leftend);
        str=reverse0(str,right,rightend);
        System.out.println(str);
    }

递归算法

1.递归的介绍：

递归做为一种算法在程序设计语言中广泛应用。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

2.递归的使用：

最常见的斐波那契数列求第N项的值如果用for循环写：

 public static int fibona(int n){
        int[] array =new int[n];
        int sum=0;
        if(n>=2){
            array[0]=1;
            array[1]=1;
            for(int i=2;i<n;i++){
                array[i]=array[i-1]+array[i-2];
            }
        }else{
            return 1;
        }
        return array[n-1];
    }

如果用递归写：

 public static int fibonac(int n) {
        if(n==1||n==2) {
            return 1;
        } else{
            return fibonac(n-1)+fibonac(n-2);
        }
    }

对于这个题，可以看出，用for循环的写的话，代码长而复杂，而且不容易理解；

而用递归去写，代码只有一个if else判断，相对代码较少，而且容易理解；

对于比较熟悉的二分查找来说

用循环写：

 public static int binnary(int[] array,int key){
        int a=0;
        int b=array.length-1;
        int middie=(a+b)/2;
        if(key<array[a]||key>array[b]) {
            return -1;
        }
        while(a<=b){
            if(array[middie]==key){
                return middie;
            }else{
                if(array[middie]>key){
                    b=middie-1;
                }
                else{
                    a=middie+1;
                }
            }
        }
        return -1;
    }

而用递归去写：

public static int binnary1(int[]array,int begin,int end,int key){
        if(begin<end) {
            int middle = (begin + end) / 2;
            if (array[middle] == key) {
                return middle;
            }else{
                if (array[middle] > key) {
                    return binnary1(array, begin, middle - 1, key);
                } else {
                    return binnary1(array, begin + 1, middle, key);
                }
            }
        }
        return -1;
    }

两者代码量看起来差不多，我个人觉得对于二分查找来说，递归和循环思想都是一样的，都是要用带查找的值去和数组中间值去比较然后继续找区间比较，递归比循坏看起来更复杂，和难以理解。

递归好处：代码更简洁清晰，可读性更好

递归坏处：由于递归需要系统堆栈，所以空间消耗要比非递归代码要大很多。而且，如果递归深度太大，可能系统撑不住。

栈如果溢出，异常信息是什么？
在这里插入图片描述