java 版剑指 offer 不定期更新

编程3:在一个二维整数数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数， 输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

解决思路：
从二维数组的右上角的元素开始判断，因为此元素是它所在行的最大数，是它所在的列的最小数。如果它等于要查找的数字，则查找过程结束。如果它大于要查找的数字，则可以排除它所在的列。如果它小于要查找的数字，则可排除它所在的行。这样如果要查找的数字不在数组的右上角，则每次判断都可以排除一行或一列以缩小查找范围，直到找到要查找的数字，或者查找范围为空

private static void suzhu1() {
        int[][] arr = {{1, 2, 8, 9}, {2, 4, 9, 12}, {4, 7, 10, 13}, {6, 8, 11, 15}};
        int target = 7;
        int rows = arr.length;
        int columns = arr[0].length;
        int row = 0;
        int column = columns - 1;

        while (row <= rows && column >= 0) {
            if (target == arr[row][column]) {
                System.out.println(target + "在第" + row + "行，第" + column + "列");
                break;
            }
            if (target > arr[row][column]) {
                row++;
            }
            if (target < arr[row][column]) {
                column--;
            }
        }
    }

请实现一个函数，将一个字符串中的空格替换成“%20”。

例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。如果从前往后走，每次替换一个空格，后面的字符串均要往后诺两位，假设字符串的长度为n，对每个空格字符串，需要挪动后面O(n)字符串，因此对含有O（n）个空格字符的字符串而言总的时间效率是O(n^2)

解题思路：是 从字符串的后面往前替换（时间复杂度是O(n)，可以先遍历一个字符串，这样就能统计字符串中空格的总数，可以计算替换之后字符串的总数。每替换一个空格，长度增加了2，因此替换以后字符串的长度等于原来的长度加上2乘以空格数。

 public static void test() {
        String str = "we are happy";
        char[] charOld = str.toCharArray();
        char[] charNew = new char[100];
        for (int j = 0; j < charOld.length; j++) {
            charNew[j] = charOld[j];
        }
        int blank = 0;
        for (int i = 0; i < charNew.length; i++) {
            if (charNew[i] == ' ') {
                blank++;
            }
        }
        int lengthFront = charOld.length - 1;

        int lengthBack = charOld.length + 2 * blank - 1;

        while (lengthFront >= 0 && lengthBack >= 0) {
            if (charNew[lengthFront] != ' ') {
                charNew[lengthBack--] = charNew[lengthFront];
            } else {
                charNew[lengthBack--] = '0';
                charNew[lengthBack--] = '2';
                charNew[lengthBack--] = '%';
                lengthFront--;
            }
            lengthFront--;
        }
        System.out.println(charNew);
    }

从尾到头打印链表

通常我们打印是一个只读操作，不希望打印时修改内容。
解决思路，用栈来处理，后进先出的思想
另一种用递归来操作，但不利于层级太深

public class ListNode {
    private int value;
    private ListNode next;

    public ListNode(int value) {
        this.value = value;
    }

    public ListNode(int value, ListNode next) {
        this.value = value;
        this.next = next;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setNext(ListNode next) {
        this.next = next;
    }

    public ListNode getNext() {
        return this.next;
    }

}

    public static void test1(ListNode node) {
        Stack mStack = new Stack<>();
        while (node != null) {
            mStack.push(node);
            node = node.getNext();
        }
        while (!mStack.empty()) {
            System.out.print(mStack.pop());
        }
    }
     
    public static void test2(ListNode node) {
        if (node != null) {
            if (node.getNext() != null) {
                test2(node);
            }
            System.out.print(node);
        }
    }

二叉树的遍历常见方式

• 前序遍历，先访问跟节点，在访问子结点，最后访问右子结点顺序是abdefgc
• 中序遍历，先访问左子结点，再访问根结点，最后访问右子结点debgfac
• 后序遍历，先访问左子结点，在访问右子结点，最后访问更结点edgfbca
• 宽度优先遍历，先访问树的第一层结点，再访问树的第二层结点，一致到访问到最下面一层结点，同一层结点，从左到右一次遍历abcdfeg