Java日志——2016.6.3

1)二维数组的静态初始化：

               int[][] arr = new int[][] { {1,2,3}, {4,5}, {6,7}}

2)杨辉三角：

/**
*    需求：计算并模拟杨辉三角
*    如：
*        1
*       1 1
*      1 2 1
*     1 3 3 1
*/
public class PascalTriangle {

    // 打算模拟的行数
    public static int row = 10;

    public static void main(String[] args) {

        int[][] arr = new int[row][];
        for(int i = 0; i < arr.length; i++) {
            int len = i + 1;
            arr[i] = new int[len];
            for(int j = 0; j < len; j++) {
                if(j == 0 || j == i) {
                    arr[i][j] = 1;            // head and tail number
                } else {                       
                    arr[i][j] = arr[i-1][j] //    middle number
                        + arr[i-1][j-1];   
                }
            }
        }

//        验证数值模拟的正确性
//        for(int[] ele : arr) {
//            System.out.println(java.util.Arrays.toString(ele));
//        }
       
        // 打印杨辉三角
        printPascalTriangle(arr);

    }

    /**
     *    需求：按照原始形式打印杨辉三角
     *    如：            1
     *                1        1
     *            1        2        1
     *        1        3        3        1
     *    1        4        6        4        1
     */
    public static void printPascalTriangle(int[][] arr) {
        if(arr == null || arr.length == 0) return;
       
        int rows = arr.length;
       
        for(int i = 0; i < arr.length; i++) {
            if(arr[i] == null || arr[i].length == 0) return;
           
            int left = row -  i;
           
            while(true) {
                if(left-- == 0) break;
                System.out.print("\t");
            }
           
            for(int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
                System.out.print("\t\t");
            }
           
            System.out.println("\n");
        }
    }
}

3)汉诺塔：

private void hannuo(int n, char from,
          char to, char depend) {
      if(n==1) {
          move(n, from, to);
      } else {
          hannuo(n-1, from, depend, to);
          move(n, from, to);
          hannuo(n-1, depend, to, from);
      }
  }
 
  private void move(int n, char from, char to) {
        System.out.println(……);
  }
4) for each循环的陷阱：对于基本类型的数组，在循环内部无法改变数组内容，但是对于引用（对象）数组或多维数组，循环内部是可以修改原始内容的。

5）排序算法：

              1.选择排序：直接选择与堆排序

             2.交换排序：冒泡排序、快速排序

             3.插入排序：直接插入、二分法排序、Shell排序

             4.归并排序

6）冒泡排序的思考模型(Bubble Sort)：

           这是最简单的排序法，基本思路：

           对未排序的各元素从头到尾依次比较相邻的两个元素大小关系，若大于则交换位置，经过第一轮比较排序后可得出最大值，然后使用同样的方法把剩下的元素逐个比较即可。

           可以看出若有N个元素，那么一共要进行N-1轮比较，第M轮要进行N-M次比较。（若6个元素，要进行6-1轮比较，第一轮比较6-1次，第三轮比较6-3次）。

7）选择排序(Selection Sort)：

           基本思路：选择某个索引位置的元素，然后和后面元素依次比较，若大于则交换位置，经过第一轮比较排序后可得出最小值，然后使用同样的方法把剩下的元素逐个比较即可。

           可以看出选择排序，第一轮会选出最小值，第二轮会选出第二小的值，直到最后。

           第一轮从arr[0]和后面元素相比较，第二轮从arr[1]和后面的元素相比较，依次类推。N个数要进行N-1轮。选择排序每一轮只进行一次交换，相对于冒泡排序效率高一些。

8）搜索方法：

        1）顺序搜素：效率低

         2）二分法搜索：效率高，但只能在有序序列中进行搜索