Java日志——2016.6.3

Posted 2020-07-23

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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次）。