劍指offer-第2章

參考：https://blog.csdn.net/baiye_xing/article/details/78428561

賦值運算子函式

public class P25_AssignmentOperator {
    public static class MyString{
        private String data;
        
        public MyString(String data) {
            this.data = data;
        }
        
        public MyString assign(final MyString another){
            if(this==another || this.data.equals(another.data))
                return this;
            else{
                this.data = another.data;
                return this;
            }
        }
    }
}

實現Singletion模式

public class Singleton {
    private static class SingletonHolder {
        private static final Singleton ourInstance = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHodler.ourInstance;
    }

    private Singleton() {}
}

靜態內部類：
屬於外部類本身，但是不屬於外部類的任何物件。
靜態內部類不能訪問外部類的例項成員，只能訪問外部類的類成員。
外部類可以使用靜態內部類的類名作為呼叫者來訪問靜態內部類的類成員，也可以使用靜態內部類物件訪問其例項成員。

陣列中重複數字

二維陣列中查詢

在一個二維陣列中，每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個函式，輸入這樣的一個二維陣列和一個整數，判斷陣列中是否含有該整數。

    public boolean find(int[][] array,int target) {
        if (array == null) {
            return false;
        }
        int row = 0;
        int column = array[0].length-1;

        while (row < array.length && column >= 0) {
            if(array[row][column] == target) {
                return true;
            }
            if(array[row][column] > target) {
                column--;
            } else {
                row++;
            }
        }
        return false;
    }

替換空格

當字串為We Are Happy.則經過替換之後的字串為We%20Are%20Happy。

陣列角度：
空格替換為"%20"，從一個位置變為3個，從前往後調整，每次都要變動空格後的字元，時間複雜度為O(n*n)
先計算出空格數量，從後往前調整位置，時間複雜度為O(n)，推薦

使用StringBuffer,StringBuilder，推薦

    public String replaceSpace(String str) {
        if (str == null)
            return null;
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < str.length(); i++) {
            if (String.valueOf(str.charAt(i)).equals(" ")) {
                sb.append("%20");
            }else {
                sb.append(str.charAt(i));
            }
        }
        return String.valueOf(sb);
    }

從尾到頭列印連結串列

輸入一個連結串列的頭節點，從尾到頭反過來列印每個節點的值。

class ListNode {
	int val;
	ListNode next;
}

    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<>();
        if (listNode == null)
            return list;
        Stack<ListNode> stack = new Stack<>();
        while (listNode != null) {
            stack.push(listNode);
            listNode = listNode.next;
        }

        while (!stack.isEmpty()) {
            list.add(stack.pop().val);
        }
        return list;
    }

重建二叉樹

輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重複的數字。例如輸入前序遍歷序列{1,2,4,7,3,5,6,8}和中序遍歷序列{4,7,2,1,5,3,8,6}，則重建二叉樹並返回。
先找出根節點，然後利用遞迴方法構造二叉樹

    public static class TreeNode {
         int val;
         TreeNode left;
         TreeNode right;
         TreeNode(int x) { val = x; }
     }
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if (pre == null || in == null) {
            return null;
        }
        if (pre.length == 0 || in.length == 0) {
            return null;
        }
        if (pre.length != in.length) {
            return null;
        }
        TreeNode root = new TreeNode(pre[0]);
        for (int i = 0; i < pre.length; i++) {
            if (pre[0] == in[i]) {
                root.left = reConstructBinaryTree(
                                Arrays.copyOfRange(pre,1,i+1),Arrays.copyOfRange(in,0,i));
                root.right = reConstructBinaryTree(
                Arrays.copyOfRange(pre,i+1,pre.length),Arrays.copyOfRange(in,i+1,in.length));
            }
        }
        return root;
    }

兩個棧實現佇列

用兩個棧來實現一個佇列，完成佇列的Push和Pop操作。 佇列中的元素為int型別。
思路：一個棧壓入元素，而另一個棧作為緩衝，將棧1的元素出棧後壓入棧2中。也可以將棧1中的最後一個元素直接出棧，而不用壓入棧2中再出棧。

    public void push(int node) {
        stack1.push(node);
    }

    public int pop() throws Exception {
        if (stack1.isEmpty() && stack2.isEmpty()) {
            throw new Exception("棧為空！");
        }

        if (stack2.isEmpty()) {
            while(!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        }
        return stack2.pop();
    }

二進位制中1的個數

    public int NumberOf1(int n) {
        int count = 0;
        while (n != 0) {
            count++;
            n = (n-1) & n;
        }
        return count;
    }