leetcode -1

001 两数之和：map，一次遍历

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[] { map.get(complement), i };
            }
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

146 LRU缓存机制：LinkedHashMap 覆写removeEldestEntry；HashMap + 链表

//方法1：LinkedHashMap
class LRUCache extends LinkedHashMap<Integer, Integer>{
    private int capacity;
    
    public LRUCache(int capacity) {
        super(capacity, 0.75F, true);
        this.capacity = capacity;
    }

    public int get(int key) {
        return super.getOrDefault(key, -1);
    }

    public void put(int key, int value) {
        super.put(key, value);
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size() > capacity; 
    }
}

//方法2：
public class LRUCache {
    class DLinkedNode {
        int key;
        int value;
        DLinkedNode prev;
        DLinkedNode next;
        public DLinkedNode() {}
        public DLinkedNode(int _key, int _value) {key = _key; value = _value;}
    }

    private Map<Integer, DLinkedNode> cache = new HashMap<Integer, DLinkedNode>();
    private int size;
    private int capacity;
    private DLinkedNode head, tail;

    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        // 使用伪头部和伪尾部节点
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        DLinkedNode node = cache.get(key);
        if (node == null) {
            return -1;
        }
        // 如果 key 存在，先通过哈希表定位，再移到头部
        moveToHead(node);
        return node.value;
    }

    public void put(int key, int value) {
        DLinkedNode node = cache.get(key);
        if (node == null) {
            // 如果 key 不存在，创建一个新的节点
            DLinkedNode newNode = new DLinkedNode(key, value);
            // 添加进哈希表
            cache.put(key, newNode);
            // 添加至双向链表的头部
            addToHead(newNode);
            ++size;
            if (size > capacity) {
                // 如果超出容量，删除双向链表的尾部节点
                DLinkedNode tail = removeTail();
                // 删除哈希表中对应的项
                cache.remove(tail.key);
                --size;
            }
        }
        else {
            // 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
            node.value = value;
            moveToHead(node);
        }
    }

    private void addToHead(DLinkedNode node) {
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }

    private void removeNode(DLinkedNode node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void moveToHead(DLinkedNode node) {
        removeNode(node);
        addToHead(node);
    }

    private DLinkedNode removeTail() {
        DLinkedNode res = tail.prev;
        removeNode(res);
        return res;
    }
}

004 寻找两个正序数组的中位数：Arrays.sort()；…… ；
005 最长回文子串：中心扩散法，注意s.substring(left, right)表示包含left不包含right的子串

class Solution {
 public String longestPalindrome(String s) {

        int  len = s.length();
        String ans = "";

        for (int i = 0; i < len; i++) {
            String odd = maxLengthPalidrome(s, i, i);
            String edd = maxLengthPalidrome(s, i, i + 1);

            String tmp = odd.length() > edd.length() ? odd : edd;
            ans = ans.length() > tmp.length() ? ans : tmp;
        }
        return ans;
    }

    private String maxLengthPalidrome(String s, int i, int j) {
        int left = i;
        int right = j;
        while (left >= 0 && right < s.length()) {
            if(s.charAt(left) == s.charAt(right)){
                left--;
                right++;
            }else {
                break;
            }
        }
        return s.substring(left+1, right);

    }

}

206 翻转链表：声明 pre=null, current= head, while(curr!=null){ tmp = curr.next; curr.next = pre; pre = current; current = tmp;} return prev;

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        
        if(head == null) {
            return head;
        }

        ListNode curr = head;
        ListNode prev = null;
        while (curr != null) {
            ListNode tmp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = tmp;
        }
        
        return prev;
    }
}

021 合并两个有序链表：循环迭代，声明 head = new ListNode(0); curr = head,循环curr，避免无法返回的问题，因为需要返回头指针，即 head.next

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode head = new ListNode(0);
        ListNode curr = head;
        while (l1 != null && l2 != null){
            if (l1.val < l2.val) {
                curr.next = l1;
                l1 = l1.next;
            } else {
                curr.next = l2;
                l2 = l2.next;
            }
            curr = curr.next;
        }

        curr.next = l1 == null? l2 : l1;
        return head.next;
    }

}

015 三数之和：先排序，双指针+循环，注意结果去重（3个地方），防止越界，Arrays.asList(^)

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        int length = nums.length;
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<List<Integer>>();

        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) {
                continue;
            }
            if (i >= 1 && nums[i] == nums[ i- 1]) {
                continue;
            }
            int left = i +1;
            int right = length -1;
            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum == 0) {

                    ans.add(Arrays.asList(nums[i], nums[left],nums[right]));
                    
                    while (left < right && nums[left] == nums[left + 1]){
                        left++;
                    }
                    while (left < right && nums[right] == nums[right - 1]){
                        right--;
                    }
                    left++;
                    right--;
                } else if (sum > 0) {
                    right--;
                } else {
                    left++;
                }
            }
        }
        return ans;

    }
}

　

046 全排列：回溯法

public static List<List<Integer>> permute(int[] nums) {

    List<List<Integer>> res = new ArrayList<List<Integer>>();
    int[] visited = new int[nums.length];
    backtrack(res, nums, new ArrayList<Integer>(), visited);
    return res;

}

private static void backtrack(List<List<Integer>> res, int[] nums, ArrayList<Integer> tmp, int[] visited) {
    //tmp 用来临时保存一次全排列的结果
    if (tmp.size() == nums.length) {
        res.add(new ArrayList<Integer>(tmp));
        return;
    }
    for (int i = 0; i < nums.length; i++) {
        if (visited[i] == 1) {
            continue;
        }
        visited[i] = 1;
        tmp.add(nums[i]);
        backtrack(res, nums, tmp, visited);
        //回溯结束之后，更新tmp，还原
        visited[i] = 0;
        tmp.remove(tmp.size() - 1);
    }
}

384 打乱数组：

public int[] reset() {
　　array = original;
　　//记得再复制一份original
　　original = original.clone();
　　return original;
}
public int[] shuffle() {
　　// i只能与后面未交换的位置进行交换
　　for (int i = 0; i < array.length; i++) {
　　　　swapAt(i, rand.nextInt(array.length - i) + i);
　　}
　　return array;
}

053 最大子序列和：

public static int maxSubArray(int[] nums) {
    int sum = 0;
    int ans = nums[0];
    for (int num : nums) {
        if (sum > 0) {
            sum += num;
        } else {
            sum = num;
        }
        ans = Math.max(sum, ans);
    }
    return ans;
}                    

253 会议室II，VIP
289 生命游戏：特殊值，使用-1和2代表生命状态的转化；遍历的边界问题，使用数组{-1,0,1}来简化代码

class Solution {
static int[] location = new int[]{-1,0,1};

    public static void gameOfLife(int[][] board) {
        if (board == null ){
            return ;
        }
        int row = board.length;
        int col = board[0].length;

        for (int i = 0; i < row;i++) {
            for (int j = 0; j < col; j++) {
                int sum = statistic(board, i, j, row, col);
                //统计活的个数
                if (board[i][j] == 0 && sum == 3){
                    board[i][j] = 2;
                } else if (board[i][j] == 1 && sum < 2){
                    board[i][j] = -1;
                } else if (board[i][j] == 1 && sum > 3){
                    board[i][j] = -1;
                }
            }
        }

        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (board[i][j] == 2){
                    board[i][j] = 1;
                }else if (board[i][j] == -1){
                    board[i][j] = 0;
                }
            }
        }
    }

    private static int statistic(int[][] board, int row, int col, int maxRow, int maxCol) {
        int total = 0;
        for (int i = 0; i< location.length; i++) {
            for (int j = 0; j < location.length; j++) {
                if (!(location[i] == 0 && location[j] == 0)) {
                    // 相邻位置的坐标,注意是 location【i】而不是i
                    int r = (row + location[i]);
                    int c = (col + location[j]);

                    // 查看相邻的细胞是否是活细胞
                    if ((r < maxRow && r >= 0) && (c < maxCol && c >= 0) ) {
                        if((Math.abs(board[r][c]) == 1)){
                        total++;
                        }
                    }
                }
                }
            }
        return total;
    }
}

　　

128 最长连续序列：set+Math.max: 输入:[100,4,200,1,3,2],输出: 4,最长连续序列是[1,2,3,4]。它的长度为4。

class Solution {
 public static int longestConsecutive(int[] nums) {

        if(nums == null || nums.length == 0){
            return 0;
        }
        Set<Integer> set = new HashSet<Integer>();

        for(int i = 0; i< nums.length; i++) {
            set.add(nums[i]);
        }

        int ans = 0;
        for (int i = 0; i< nums.length; i++) {
            if (set.contains(nums[i] - 1)){
                continue;
            }
            int tmp = nums[i];
            int tmpLength = 0;
            while (set.contains(tmp)){
                tmpLength += 1;
                tmp += 1;
                ans = Math.max(tmpLength, ans);
            }
        }
        return ans;
    }
}

148 排序链表：归并排序+递归:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
 public ListNode sortList(ListNode head) {

        if(head == null || head.next == null){
            return head;
        }
        
        ListNode  fast = head.next;
        ListNode slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
        }
        
        ListNode tmp = slow.next;
        slow.next = null;
        
        ListNode left = sortList(head);
        ListNode right = sortList(tmp);

        ListNode h = new ListNode(0);
        ListNode res = h;
        
        while(left!= null && right != null){
            if (left.val < right.val){
                h.next = left;
                left = left.next;
            }else {
                h.next = right;
                right = right.next;
            }
            h = h.next;
        }

        h.next = left == null? right : left;
        return res.next;
    }
}

　　

300 最长上升子序列：动态规划

class Solution {
public static int lengthOfLIS(int[] nums) {

        if (nums== null || nums.length == 0){
            return 0;
        }

        int[] dp = new int[nums.length];
        dp[0] = 1;
        for (int i  = 0; i < nums.length; i++){
            int maxVal = 0;
            for (int j = 0;j < i; j++){
                if (nums[j] < nums[i]){
                    maxVal = Math.max(maxVal, dp[j]);
                }
            }
            dp[i] = maxVal + 1;
        }
        
        int res = 0;
        for (int i  = 0; i < nums.length; i++){
            res = Math.max(res, dp[i]);
        }
        return res;
    }
}

179 最大数：注意：Comparator，排序之后。0是asStrs的最大值，则返回0，避免多个0

思考：大数据全排列

class Solution {
    private class LargerNumberComparator implements Comparator<String> {
        @Override
        public int compare(String a, String b) {
            String order1 = a + b;
            String order2 = b + a;
           return order2.compareTo(order1);
        }
    }

    public String largestNumber(int[] nums) {
        String[] asStrs = new String[nums.length];
        for (int i = 0; i < nums.length; i++) {
            asStrs[i] = String.valueOf(nums[i]);
        }
        Arrays.sort(asStrs, new LargerNumberComparator());
        String largestNumberStr = new String();
        for (String numAsStr : asStrs) {
            largestNumberStr += numAsStr;
        }
        return largestNumberStr;
    }
}

　

022 括号生成：回溯法

class Solution {

    public List<String> generateParenthesis(int n) {

        List<String> res = new ArrayList<>();

        dfs(res, n, n, "");

        return res;

    }

    private void dfs(List<String> res, int left, int right, String curStr) {

        if (left == 0 && right == 0) { // 左右括号都不剩余了，说明找到了有效的括号

            res.add(curStr);

            return;

        }

        //左括号只有剩余的时候才可以选，如果左括号的数量已经选完了，是不能再选左括号了。

        //如果选完了左括号我们是还可以选择右括号的。

        if (left < 0)

            return;

        // 如果右括号剩余数量小于左括号剩余的数量，说明之前选择的无效

        if (right < left)

            return;

            //选择左括号

            dfs(res, left - 1, right, curStr + "(");

            //选择右括号

            dfs(res, left, right - 1, curStr + ")");

    }

}

200 岛屿数量：BFS，

class Solution {
    public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0){
            return 0;
        }
        int ans = 0;
        int row = grid.length;
        int col = grid[0].length;
        for (int i = 0; i< row; i++) {
            for (int j = 0; j< col; j++){
                if (grid[i][j] == '1'){
                    dfs(grid, i, j);
                    ans++;
                }
            }
        }
        return ans;
    }

    private void dfs(char[][] grid, int i, int j) {
        int row = grid.length;
        int col = grid[0].length;
        if (i < 0 || j < 0 || i >= row || j >= col){
            return;
        }
        if (grid[i][j] == '0'){
            return;
        }
        grid[i][j]='0';
        dfs(grid, i-1, j);
        dfs(grid, i , j-1);
        dfs(grid, i+1, j);
        dfs(grid, i, j+1);
    }
}

　　

287 寻找重复数：二分查找

class Solution {
    public int findDuplicate(int[] nums) {
        int n = nums.length;
        int l = 1, r = n - 1, ans = -1;
        while (l <= r) {
            int mid = (r-l) / 2 + l;
            int cnt = 0;
            for (int i = 0; i < n; ++i) {
                if (nums[i] <= mid) {
                    cnt++;
                }
            }
            if (cnt <= mid) {
                l = mid + 1;
            } else {
                r = mid - 1;
                ans = mid;
            }
        }
        return ans;
    }
}

054 螺旋矩阵

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> list = new ArrayList<Integer>();
        if (matrix == null || matrix.length == 0) {
            return list;
        }
        int m = matrix.length;
        int n = matrix[0].length;
        int i = 0;

        //统计矩阵从外向内的层数，如果矩阵非空，那么它的层数至少为1层
        int count = (Math.min(m, n) + 1) / 2;
        //从外部向内部遍历，逐层打印数据
        while (i < count) {
            for (int j = i; j < n - i; j++) {
                list.add(matrix[i][j]);
            }
            for (int j = i + 1; j < m - i; j++) {
                list.add(matrix[j][(n - 1) - i]);
            }

            for (int j = (n - 1) - (i + 1); j >= i && (m - 1 - i != i); j--) {
                list.add(matrix[(m - 1) - i][j]);
            }
            for (int j = (m - 1) - (i + 1); j >= i + 1 && (n - 1 - i) != i; j--) {
                list.add(matrix[j][i]);
            }
            i++;
        }
        return list;
    }
}