排序算法，查找和递归的学习

1. 冒泡排序算法 ##

冒泡排序算法的中心思想

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一个相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
   4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

/**
 1. 
 2. @param array
 3. 
 4. 冒泡排序算法
 5. 
 */

    public static void bubbleSort(int array[]) {

        for(int i=0;i<array.length-1;i++) {
            for(int j=0;j<array.length-1-i;j++) {
                if(array[j]>array[j+1]) {
                    array[j]=array[j]+array[j+1];
                    array[j+1]=array[j]-array[j+1];
                    array[j]=array[j]-array[j+1];
                }
            }
        }
        for(int i=0;i<array.length;i++) {

            if(i!=4) {
                System.out.print(array[i]+",");
            }else {
                System.out.println(array[i]);
            }
        }
    }

仔细研究了下书中的例子，发现自己写的冒泡算法很low，并没有达到这个算法的最优化，真正的冒泡算法应该在每轮比较后所需要比较的数字都应该少一个。但是我写的算法没有达到这个要求，经过改良后代码如下

/**
     * 改良版本
     * 每轮比较后，最大的数字就会到达数组的末尾，所以每轮比较过后数组的总数字应该少一个
     */
    public static void bubbleSort2(int [] array) {
        //外循环确定需要比较多少轮，每轮比较完后，总数少一个，没有数字需要比较
        for (int out = array.length-1; out>0 ; out--) {
            for(int in=0;in<out;in++) {
                //内循环  两数交换
                if(array[in]>array[in+1]) {
                    array[in]=array[in+1]+array[in];
                    array[in+1]=array[in]-array[in+1];
                    array[in]=array[in]-array[in+1];
                }
            }

        }
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

2.简单选择排序

简单选择排序算法的中心思想

1. 取出数组中的排在第一位的数字与之后的每一个数字进行比较，若后面的数字比前面的数字小，则两者交换位置
2. 对数组的数字逐个执行第一步操作，每一轮操作之后，最小的数字会被排到数组的首部。
3. 这样数组会从小到大逐个排序

/**
 * 
 * 简单选择排序
 */
    //两数交换
    public static void exchangeNumber(int array[],int i,int j) {
        array[i]=array[i]+array[j];
        array[j]=array[i]-array[j];
        array[i]=array[i]-array[j];
    }
    //打印数组
    public static void printArray(int array[]) {
        for(int i=0;i<array.length;i++) {

            if(i!=4) {
                System.out.print(array[i]+",");
            }else {
                System.out.println(array[i]);
            }
        }

    }
    //简单选择排序算法
    public static void selectSort(int array[]) {
        for(int i=0;i<array.length-1;i++) {
            for(int j=i+1;j<array.length;j++) {
                if(array[i]>array[j]) {
                    exchangeNumber(array, i, j);

                }
            }
        }
        printArray(array);

    }

在需要排序的数字比较少的时候，简单排序算法比冒泡排序算法更快

3.二分查找

/**
 * 
 * @param array
 * 二分法查找
 * 取数组的中间索引的数（mid）去与要查询的数字比较
 * 若mid比该数字小，则取mid索引作为min继续取中间值与要查询的数字进行比较
 * 若mid比该数字大，则取mid索引作为max继续取中间值与该数字比较
 * 若mid与该数相等则跳出循环，找到要查询的数字
 * min=array[0]
 * max=array[array.length-1]
 * mid=array[(0+array.length-1)/2]
 */
    public static void binarySearch(int[] array,int num) {
        int minIndex=0;
        int maxIndex=array.length-1;
        int midIndex;
        if(num<array[0]||num>array[array.length-1]) {
            System.out.println("您要查找的数字不存在");
        }
        for(int i=0;i<array.length-1;i++) {
            midIndex =(minIndex+maxIndex)/2;  
            if(array[midIndex]<num) {
                minIndex=midIndex;
            }else if(array[midIndex]>num) {
                maxIndex=midIndex;
            }else if(array[midIndex]==num) {
                System.out.println("第"+(i+1)+"次循环"+"找到要查找的数字"+array[midIndex]);
                break;
            }else {
                System.out.println();
                break;
            }

        }

    }

4.递归（Recursion）

程序调用自身的编程技巧称为递归

构成递归需要具备的条件

• 子问题需与原始问题为同样的事，且更为简单
• 不能无限制的调用本身，需有个出口，化简为非递归状况处理

package com.hwadee.day14;


public class Recursion {
    public static void main(String[] args) {
        int num=10;
        System.out.println(num+"的阶乘为"+factorialImpl(num));
        for (int i = 0; i <= num; i++) {
            System.out.println("第"+(i+1)+"个斐波那契数为："+fibonacciImpl(i));

        }
    }
    /**
     * 
     *使用递归完成阶乘
     *n！=1*2*3*4...*n
     *0！=1  n！=(n-1)!*n
     *
     */
    public static int  factorialImpl(int num) {
        return(num==0)?1:num*factorialImpl(num-1); 
    }
    /**
     * 
     * 使用递归完成斐波那契数列
     * 斐波那契数列：由0和1开始，之后的每个数都是前两个数的和
     */
    public static int fibonacciImpl (int num) {
        if(num==0) {
            return 0;
        }else if(num==1) {
            return 1;
        }else {
            return fibonacciImpl(num-1)+fibonacciImpl(num-2);
        }


    } 
}
//程序执行结果
10的阶乘为3628800
第1个斐波那契数为：0
第2个斐波那契数为：1
第3个斐波那契数为：1
第4个斐波那契数为：2
第5个斐波那契数为：3
第6个斐波那契数为：5
第7个斐波那契数为：8
第8个斐波那契数为：13
第9个斐波那契数为：21
第10个斐波那契数为：34
第11个斐波那契数为：55