算法题存档20191223

题目描述

删除给出链表中的重复元素，使链表中的所有元素都只出现一次

例如：

给出的链表为1->1->2,返回1->2.

给出的链表为1->1->2->3->3,返回1->2->3.

public class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode first = new ListNode(-1);
        first.next = head;
        ListNode pre = first;
        ListNode now = head;
        while(now != null && now.next != null){
            pre = now;
            if(now.val == now.next.val){
                while(now.next != null && now.val == now.next.val) {
                    now = now.next;
                }
                pre.next = now.next;
            }
            now = now.next;
        }
        return first.next;
    }
}

题目描述

给出一个二维字符数组和一个单词，判断单词是否在数组中出现，

单词由相邻单元格的字母连接而成，相邻单元指的是上下左右相邻。同一单元格的字母不能多次使用。

例如：

给出的字符数组=

[↵  ["ABCE"],↵  ["SFCS"],↵  ["ADEE"]↵]

public class Solution {
    public boolean exist(char[][] board, String word) {
        int m = board.length;
        int n = board[0].length;

        boolean[][] visited = new boolean[m][n];

        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j ++ ) {
                if(deep(board, word, visited, i, j, 0, m, n)) {
                    return true;
                }
            }
        }

        return false;
    }
    
    private boolean deep(char[][] board, String word,  boolean[][] visited, int i, int j, int count, int m, int n) {
        if(count == word.length()) {
            return true;
        }
        if(i < 0 || i >= m || j < 0 || j >= n || board[i][j] != word.charAt(count) || visited[i][j]) {
            return false;
        }
        visited[i][j] = true;
        boolean res = deep(board, word, visited, i - 1, j, count + 1, m, n) ||
                deep(board, word, visited, i + 1, j, count + 1, m, n) ||
                deep(board, word, visited, i, j - 1, count + 1, m, n) ||
                deep(board, word, visited, i, j + 1, count + 1, m, n);
        visited[i][j] = false;

        return res;
    }
}

题目描述

给出两个整数n和k，返回从1到n中取k个数字的所有可能的组合

例如：

如果n=4，k=2，结果为

[↵  [2,4],↵  [3,4],↵  [2,3],↵  [1,2],↵  [1,3],↵  [1,4],↵]

public class Solution {
    ArrayList<ArrayList<Integer>> result;

    public ArrayList<ArrayList<Integer>> combine(int n, int k) {
        result = new ArrayList<ArrayList<Integer>>();
        ArrayList<Integer> temp = new ArrayList<Integer>();

        if(n < 1 || k < 1 || n < k) {
            return result;
        }

        combine(n, k, 1, temp);

        return result;
    }

    private void combine(int n, int k, int index, ArrayList<Integer> tem) {
        if(tem.size() == k) {
            result.add(new ArrayList<>(tem));
            return;
        }

        if(index > n) {
            return;
        } else {
            int left = k - tem.size() - 1;
            for (int i = index; i <= n - left; i++) {
                tem.add(i);
                combine(n, k, i + 1, tem);
                tem.remove(tem.size() - 1);
            }
        }

    }
}

题目描述

给出两个字符串S和T，要求在O（n）的时间复杂度内在S中找出最短的包含T中所有字符的子串。

例如：

S ="ADOBECODEBANC"
T ="ABC"

找出的最短子串为"BANC".

注意：

如果S中没有包含T中所有字符的子串，返回空字符串 “”；

满足条件的子串可能有很多，但是题目保证满足条件的最短的子串唯一。

public class Solution {
    public String minWindow(String S, String T) {
        int[] map = new int[128];
        for(int i = 0; i < T.length(); i++) {
            map[T.charAt(i)]++;
        }

        int left = 0;
        int right = 0;
        int result = Integer.MAX_VALUE;
        int counter = T.length();
        int head = 0;
        while(right < S.length()) {
            if(map[S.charAt(right++)]-- > 0) {
                counter--;
            }
            while (counter == 0) {
                if(right - left < result) {
                    head = left;
                    result = right - left;
                }
                if(map[S.charAt(left++)]++ == 0) {  
                    counter++;                     
                }
            }
        }
        return result == Integer.MAX_VALUE ? "" : S.substring(head, head + result);
    }
}

题目描述

现在有一个包含n个物体的数组，其中物体颜色为颜色为红色、白色或蓝色，请对这个数组进行排序，让相同颜色的物体相邻，颜色的顺序为红色，白色，蓝色。

我们用0,1,2分别代表颜色红，白，蓝

注意：

本题要求你不能使用排序库函数

扩展：

一个非常直接的解法是两步的计数排序的算法

首先：遍历一遍数组，记录0,1,2的数量，然后重写这个数组，先将0写入，再将1写入，再将2写入

你能给出一个只用一步，并且能在常数级空间复杂度解决这个问题的算法吗？

public class Solution {
    public void sortColors(int[] A) {
        int zero = 0;
        int two = A.length - 1;

        for(int i = 0; i <= two; i++) {
            if(A[i] == 0) {
                A[i] = A[zero];
                A[zero++] = 0;
            } else if(A[i] == 2) {
                A[i] = A[two];
                A[two] = 2;
                i--;
                two--;
            }
        }
    }
}

题目描述

请写出一个高效的在m*n矩阵中判断目标值是否存在的算法，矩阵具有如下特征：

每一行的数字都从左到右排序

每一行的第一个数字都比上一行最后一个数字大

例如：

对于下面的矩阵：

[↵  [1,   3,  5,  7],↵  [10, 11, 16, 20],↵  [23, 30, 34, 50]↵]

要搜索的目标值为3，返回true；

public class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int m = matrix.length;
        int n = matrix[0].length;
        int i = 0;
        for(; i < m; i++) {
            if(matrix[i][0] == target) {
                return true;
            } else if(matrix[i][0] > target) {
                break;
            }
        }
        if(i == 0) {
            return false;
        }
        for(int j = 0; j < n; j++) {
            if(matrix[i - 1][j] == target) {
                return true;
            } else if(matrix[i - 1][j] > target) {
                return false;
            }
        }
        return false;
    }
}

题目描述

给定一个m*n的矩阵，如果有一个元素是0，就把该元素所在的行和列上的元素全置为0，要求使用原地算法。

拓展：

你的算法有使用额外的空间吗？

一种比较直接的算法是利用O(m,n)的空间，但是这不是一个好的解法

使用简单的改进可以在O(m+n)的空间解决这个问题，但是还不是最佳的解法

你能在常量级的空间复杂度内解决这个问题吗？

public class Solution {
    public void setZeroes(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;

        boolean nZero = false;
        boolean mZero = false;
        for(int i = 0; i < n; i++) {
           if(matrix[0][i] == 0) {
               nZero = true;
               break;
           }
        }
        for(int i = 0; i < m; i++) {
            if(matrix[i][0] == 0) {
                mZero = true;
                break;
            }
        }

        for(int i = 1; i < m; i++) {
            for(int j = 1; j < n; j++) {
                if(matrix[i][j] == 0) {
                    matrix[i][0] = 0;
                    matrix[0][j] = 0;
                }
            }
        }

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (0 == matrix[i][0] || 0 == matrix[0][j]) {
                    matrix[i][j] = 0;
                }
            }
        }

        if (nZero)
            for (int i = 0; i < n; i++) {
                matrix[0][i] = 0;
            }
        if (mZero)
            for (int i = 0; i < m; i++)
                matrix[i][0] = 0;
    }
}