java 最基础算法（1）插入、选择、冒泡、递归

先定义swap（）方法：

 
    /**
     * 交换数组元素
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int []arr,int a,int b) {
        arr[a] = arr[a]+arr[b];
        arr[b] = arr[a]-arr[b];
        arr[a] = arr[a]-arr[b];
    }

1.    选择排序

       核心思想：遍历arr.length-1次，每次得到一个最值， 与第i次循环第一位交换位置。

 @Test
    /**
     * 选择排序
     * 核心思想：遍历arr.length-1次，每次得到一个最值，
     * 与第i次循环第一位交换位置。
     */
    public void test03() {
        int []arr= {1,2,5,8,6,3,4};
        System.out.print("排序前:");
        for(int i:arr) {
            System.out.print(i);
        }
        for (int i = 0; i < arr.length-1; i++) {
            int min=i;
            for (int j = i+1; j < arr.length; j++) {
                if(arr[j]<arr[min]) {
                    min=j;
                }
            }
          //进行交换，如果min发生变化，则进行交换
            if (min != i) {
                swap(arr,min,i);
            }
        }
        System.out.print("\n排序后:");
        for(int i:arr) {
            System.out.print(i);
        }
    }

2.冒泡排序
  核心思想：对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端，最终达到完全有序.

  @Test
    /**
     * 冒泡排序
     * 核心思想：对相邻的元素进行两两比较，顺序相反则进行交换，
     * 这样，每一趟会将最小或最大的元素“浮”到顶端，最终达到完全有序
     */
    public void test04() {
        int []arr= {1,2,5,8,6,3,4};
        System.out.print("排序前:");
        for(int i:arr) {
            System.out.print(i);
        }
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if(arr[i]>arr[j]) {
                    swap(arr,i, j);
                }
            }
        }
        System.out.print("\n排序后:");
        for(int i:arr) {
            System.out.print(i);
        }
    }

3.插入排序
   核心思想：先将第一位当做有序序列，序列后一位与序列中值比较插入。 新插入的值与原有序列形成的新的有序序列，继续如此循环。

@Test
    /**
     * 插入排序
     * 核心思想：先将第一位当做有序序列，序列后一位与序列中值比较插入。
     * 新插入的值与原有序列形成的新的有序序列，继续如此循环。
     */
    public void test05() {
        int []arr= {1,2,5,8,6,3,4};
        System.out.print("排序前:");
        for(int i:arr) {
            System.out.print(i);
        }
        for (int i = 1; i < arr.length; i++) {
           int j=i;
           while (j>0&&arr[j]<arr[j-1]) {
               swap(arr, j, j-1);
               j--;
           }
        }
        System.out.print("\n排序后:");
        for(int i:arr) {
            System.out.print(i);
        }
    }

4.递归算法
   核心思想：自身调用自身，设置出口，满足条件跳出调用。

 @Test
    /**
     * 递归算法
     * 核心思想：自身调用自身，设置出口，满足条件跳出调用。
     */
    public void test06() {
        //-------------------阶乘---n!------------------
        System.out.println("递归阶乘："+SumNum(5));
        //-------------------斐波纳契数列---------------------
        System.out.println("斐波纳契数列："+FBNQ(6));
        //-------------------杨辉三角---------------------
        System.out.println("杨辉三角："+getValue(4,3));
        //-------------------阶乘---------------------
        
    }
    //递归阶乘
    int SumNum(int n) {
        if(n<=1) {
            return 1;
        }
        return n*SumNum(n-1);
    }
    //斐波纳契数列,又称黄金分割数列，
    //指的是这样一个数列：1、1、2、3、5、8、13、21、…… 
    int FBNQ(int n) {
        if(n>=0) {
            if(n==1||n==0) {
                return 1;
            }
            return FBNQ(n-1)+FBNQ(n-2);
        }
        return -1;
    }
    /* *杨辉三角的取值 
    *    1 
    *   1 1
    *  1 2 1
    * 1 3 3 1
    * @x  指定行
    * @y  指定列  
    */
    int getValue(int x,int y) {
        if(y<=x&&y>0) {
            if (y==0||x==y) {
                return 1;
            }else {
                return getValue(x-1, y-1)+getValue(x-1, y);
            }
        }
        return 0;
    }