面试常问算法题

1.有一只兔子，从出生后第3个月起每个月都生只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问每个月的兔子总数为多少？（不死神兔问题/递归）

   分析：规律为：1，1，2，3，5，8，13，21，34，55，89，144

a.不使用递归解决方法

 /**
     * 不死神兔算法
     * 不使用递归
     */
    @Test
    public void countRabbit(){
        //要计算的月数，默认算一年的
        int month = 12;
        //兔子总数量
        int count = 0;
        //上个月的兔子数量，初始化为2月的，有1只
        int num1 = 1;
        //上上个月的兔子数量，初始化为1月的，有1只
        int num2 = 1;
        for (int i = 3; i <=12 ; i++) {
            count = num1 + num2;
            num2 = num1;
            num1 = count;
            System.out.println("第"+i+"个月有"+count+"只兔子！");
        }
    }

b.使用递归

public class bsst{
	public static void main(String args[]){
		int i=0;
		for(i=1;i<=20;i++)
			System.out.println(f(i));
	}
	public static int f(int x)
	{
		if(x==1 || x==2)
			return 1;
		else
			return f(x-1)+f(x-2);
	}
}

2.排序算法

/**
 * 快速排序：通过一次排序将要排序的记录分割成两个独立的部分，
 * 其中一部分的所有记录 关键字值都比另外一部分的关键字值小，
 * 然后再按此方法分别对两个部分进行快速排序，整个排序可以使用递归进行 步骤：
 * 1：设置两个变量i,j，初值分别为low,high，分别表示
 * 待排序序列的起始下标和终点下标
 * 2：将第i个记录暂存到temp中，即temp = r[i]
 * 3：从下标为j的位置依次从后往前搜索，当找到第一个比temp的值小的记录时，
 * 则将该记录向前移动到i的位置上，并且i=i+1
 * 4：从下标为i的位置依次从前往后搜索，当找到第一个比temp的值大的记录时，
 * 则将该记录向后移动到j的位置上，并且j=j-1 5：重复第三步，第四步
 * 6：r[i] = temp
 * 
 */

 //快速排序
    public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp存储基准数
        temp = arr[low];
        while (i<j) {
        //先从右边开发判断，条件成立，high向左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            arr[i]=arr[j];
            //再从左边开始，low依次向右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            arr[j]=arr[i];
            arr[i]=temp;
        }
        //递归调用左边内容进行排序
        quickSort(arr, low, j-1);
        //递归调用右边内容进行排序
        quickSort(arr, j+1, high);
    }

    /**
     * 冒泡排序
     *
     * @param array
     * @return
     */
    public static String bubbingSort(int[] array) {
        System.out.println(Arrays.toString(array));
        for (int i = 0; i < array.length - 1; i++) {//外层循环的次数
            System.out.println("外层循环的次数--" + i);
            for (int j = 0; j < array.length - 1 - i; j++) {//依次循环的次数
                if (array[j + 1] < array[j]) {
                    Integer a = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = a;
                }
                System.out.println("内层一次层循环的次数--" + j);
            }
        }
        for (int ar : array) {
            System.out.print(ar + ",");
        }
        return "";
    }


 //二分排序
    public  static void sort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int temp = array[i];
            int low = 0, high = i - 1;
            int mid = -1;
            while (low <= high) {
                mid = low + (high - low) / 2;
                if (array[mid] > temp) {
                    high = mid - 1;
                } else { // 元素相同时，也插入在后面的位置
                    low = mid + 1;
                }
            }
            for(int j = i - 1; j >= low; j--) {
                array[j + 1] = array[j];
            }
            array[low] = temp;
        }
        for (int ar : array) {
            System.out.println(ar + ",");
        }
    }




    public static void main(String[] args) {
        //递归
        //不死神兔问题   规律  1，1，2，3，5，8，13，21，34，55，89，144
        System.out.println("不死神兔（递归）");
        int i=0;
        for(i=1;i<=20;i++) {
            System.out.println(f(i));
        }

        System.out.println("快速排序");
        //快速排序
        int[] arr = {15,23,7,87,34,56};
        quickSort(arr, 0, arr.length-1);
        for (int y = 0; y < arr.length; y++) {
            System.out.println(arr[y]);
        }

        System.out.println("冒泡排序");
        //冒泡排序
        int[] arr2 = {15,23,7,87,34,56};
        bubbingSort(arr2);

        System.out.println("二分排序");
        //二分排序
        int[] arr3= {15,23,7,87,34,56};
        sort(arr3);
    }