160, 74, 98, 215, 115

 

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
 //一看就是哈希或者双指针，很强了。
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) return null; 

        int headALen = getLength(headA);
        int headBLen = getLength(headB);
        int n = 0;

        if (headALen > headBLen) {
            n = headALen - headBLen;
            for (int i = 0; i < n; i++) {
                headA = headA.next;
            }
        } else if (headALen < headBLen) {
            n = headBLen - headALen;
            for (int i = 0; i < n; i++) {
                headB = headB.next;
            }
        }
        ListNode l1 = headA;
        ListNode l2 = headB;

        while (l1 != null) {
            //链表是可以直接进行判断相等的，不需要判断值
            if (l1 != l2) {
                l1 = l1.next;
                l2 = l2.next;
            } else if (l1 == l2) {
                return l1;
            }
            
        }
        return null;
    }

    public int getLength(ListNode node) {
        int count = 0;
        while (node != null) {
            node = node.next;
            count++;
        }
        return count;
    }
}

 

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {

        if (matrix.length == 0) return false;
        int lenL = matrix.length;
        int lenH = matrix[0].length;

        int row = lenH - 1;
        int column = 0;
        while (row >= 0 && column < lenL) {
            if (target > matrix[column][row]) {
                column++;
            } else if (target < matrix[column][row]) {
                row--;
            } else {
                return true;
            }
        }
        return false;
    }
}

 

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
 //中序遍历本来就是可以改成升序啊
class Solution {
    public boolean isValidBST(TreeNode root) {
        LinkedList<TreeNode> stack = new LinkedList<>();
        long temp = Long.MIN_VALUE;
        while (root != null || !stack.isEmpty()) {
            if (root != null) {
                stack.push(root);
                root = root.left;
            } else {
                root = stack.pop();
                if (root.val <= temp) {
                    return false;
                }
                temp = root.val;
                root = root.right;
            }
        }
        return true;
    }
}
// class Solution {
//     public boolean isValidBST(TreeNode root) {
//         return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE);
//     }

//     public boolean isValidBST(TreeNode node, long lower, long upper) {
//         if (node == null) {
//             return true;
//         }
//         if (node.val <= lower || node.val >= upper) {
//             return false;
//         }
//         return isValidBST(node.left, lower, node.val) && isValidBST(node.right, node.val, upper);
//     }
// }

 

class MinStack {
    Deque<Integer> xStack;
    Deque<Integer> minStack;

    public MinStack() {
        xStack = new LinkedList<Integer>();
        minStack = new LinkedList<Integer>();
        minStack.push(Integer.MAX_VALUE);
    }
    
    public void push(int x) {
        xStack.push(x);
        minStack.push(Math.min(minStack.peek(), x));
    }
    
    public void pop() {
        xStack.pop();
        minStack.pop();
    }
    
    public int top() {
        return xStack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(val);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

 

//先镜像后转置
class Solution {
    public void rotate(int[][] matrix) {
        int lenH = matrix.length;
        int lenL = matrix[0].length;
        //先转置
        for (int i = 0; i < lenH; i++) {
            //注意反转啊，憨逼。。。j < 1对角线左边的就行
            for (int j = 0; j < i; j++) {
                int temp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = temp;
            }
        }
        //后镜像
        for (int i = 0; i < lenH; i++) {
            for (int j = 0; j < lenL / 2; j++) {
                int temp = matrix[i][j];
                matrix[i][j] = matrix[i][lenL - j - 1];
                matrix[i][lenL - j - 1] = temp;
        
            }
        }
    }
}