java冒泡排序，递归函数与递归排序面试

本文希望通过简单的，关键点进行记忆，书写冒泡排序

冒泡排序思想

/双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数
每进行一趟排序，就会少比较一次，因为每进行一趟排序都会找出一个较大值
如果遇到相等的值不进行交换，那这种排序方式是稳定的排序方式。

原理：比较两个相邻的元素，将值大的元素交换到右边
比如一个数组int arr[]={5,3,1,6,7,9,2,4,8}
第一次循环：
5和3比较，交换
5和1比较，交换
5和6比较，不交换
6和7比较，不交换
7和9比较，不交换
9和2比较，交换
9和4比较，交换
9和8比较，交换
最后，第一次循环结果：{3,1,5,6,7,2,4,8,9}，最大的到了右边

由此可见： N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数

简单标准代码实现：

public class 冒泡排序 {

        public int[] Bubbelsort(int arr[]) {
            for (int i = 0; i < arr.length; i++) {
                int tmp = 0;
                //这个j的循环有几种写的方式，个人觉得下面的比较好记
                for (int j = i + 1; j < arr.length; j++) {
                    if (arr[i] > arr[j]) {
                        tmp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = tmp;
                    }
                }
            }
            return arr;
        }
        public static void main(String[] args) {
            冒泡排序 sort=new 冒泡排序();
            int arr[]={5,3,1,6,7,9,2,4,8};
            int result[]=sort.Bubbelsort(arr);
            for (int item:result) {
                System.out.println(item);

            }
        }
}

用随机数生成随机数组再排序：

public class RandomBubble {
    public static int len ;
    public static int max;
    public static int[] genner(int len,int max){
        int[] arr2 = new int[len];
        for (int j=0;j<arr2.length;j++) {
            arr2[j]=(int)(Math.random()*max);
        }
        return arr2;
    }
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int a=scanner.nextInt();
        int b=scanner.nextInt();
        int[] arr = genner(a, b);
        for (int ar:arr) {
            System.out.print(ar+"\t");
        }
        System.out.print("-------------------------------");
        for (int i=0;i<arr.length;i++) {
            int tmp=0;
            for (int j=i+1;j<arr.length;j++) {
                if (arr[i]>arr[j]) {
                    tmp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = tmp;
                }
            }
        }
        
        for (int i:arr) {
            System.out.print(i+"\t");
        }
        
    }
}

递归函数：

递归函数就是在函数体内部调用自己的函数
递归函数就是在一个函数通过名字调用自身的情况下构成的，
递归策略只需要少量的程序就可以描述出解题过程所需要的多次重复计算，
减少了程序的代码量
实现递归的三要素：
1.方法中出现自己调用自己
2.要有分支
3.要有结束条件

public int dg(int i){
    if (i == 1) {
        return 1;
    } else {
        System.out.println("这是i"+i);
        int tmp=i*dg(i-1);
        System.out.println("这是计算"+tmp);
        return tmp;
    }
}
public static void main(String[] args) {
    Recursiveaddition r=new Recursiveaddition();
    int num=r.dg(10);
    System.out.println(num);
}

斐波纳契数列，又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、……

这个数列从第三项开始，每一项都等于前两项之和。

public class digui2 {
    public static int fun(int m){
        if(m<2){
            return 1;
        }else{
            return fun(m - 1)+fun(m-2);
        }
    }
    public static void main(String[] args) {

        System.out.println(fun(12));
    }

}

使用递归排序：

1.先确定一个key值（也就是参考值），初状态定义如下
2.实现key的左边都是小于key的值，右边都是大于key的值
3.用递归实现左右排序
QuickSort(arr,copyStart,start);//左递归
QuickSort(arr,start+1,copyEnd);//右递归

public class RecursiveSort {

        private static int Partition(int[] arr, int start, int end) {
            int key = arr[start];
            while (start < end) {
                while (arr[end] >= key && end > start)
                    end--;
                arr[start] = arr[end];
                while (arr[start] <= key && end > start)
                    start++;
                arr[end] = arr[start];
            }
            arr[start] = key;
            return start;
        }
        public static void quickSort(int[] arr, int start, int end) {
            if (start < end) {
                int index = Partition(arr, start, end);
                quickSort(arr, start, index - 1);
                quickSort(arr, index + 1, end);
            }
        }
        public static void main(String[] args) {
            int[] data = new int[]{1,3,2,9,7,4,6,8,20,17,25,21};
            quickSort(data,0,data.length-1);
            for (int temp : data) {
                System.out.print(temp+"、");
            }
        }
    }