LeetCode练习题

14.最长公共前缀

class Solution {
    public String longestCommonPrefix(String[] strs) {
        //如果输入的strs为空，则返回空字符串""
        if(strs.length==0){
            return "";
        }
        //定义一个ans为strs.[0],获取到strs的第一个字符串为了一下面的循环比较
        String  ans = strs[0];
        for(int i=1; i<strs.length; i++){
            //在这里定义j=0，而不是在for里面定义；是为了ans.substring(0,j)能调用j的值
            int j = 0;
            for(;j<ans.length() && j<strs[i].length(); j++){
                //比较俩个字符串相同的部分，不相同则退出循环
                if(ans.charAt(j) != strs[i].charAt(j))
                    break;
            }
            //获取从0到j相同的字符串
            ans = ans.substring(0,j);
            //如果ans获取的结果为空则返回空字符
            if(ans.equals(" "))
                return ans;      
        }
        //返回最终获取到的ans
        return ans;
        
    }
}

20.有效的括号

public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        char[] charArray = s.toCharArray();

        for (char ch : charArray) {
            //如果是左括号则直接入栈
            if (ch == '(' || ch == '{' || ch == '[') {
                stack.push(ch);
            } else {
               //如果是右括号，并且此时栈不为空
                if (!stack.isEmpty()) {
                    if (ch == ')') {
                        if (stack.pop() != '(')
                            return false;
                    } else if (ch == '}') {
                        if (stack.pop() != '{')
                            return false;
                    } else {
                        if (stack.pop() != '[')
                            return false;
                    }
                }
                else{ //此时栈为空，但却来了个右括号，也直接返回false
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }

class Solution 
{
public:
    bool isValid(string s) 
    {
        stack<char>S;
        for (char ch : s)
        {
            //如果当前栈为空，但是ch是右括号应该返回false
            if (S.empty() && ch == ')' || S.empty() && ch == ']' || S.empty() && ch == '}')
                return false;
            //如果ch是左括号，应该将其入栈，等待匹配
            if (ch == '(' || ch == '[' || ch == '{')
                S.push(ch);
            
            else
            {
                //如果输入的右括号和当前栈顶元素匹配，那么弹出栈顶元素
                if (S.top() == '(' && ch == ')' || S.top() == '[' && ch == ']' || S.top() == '{' && ch == '}')
                    S.pop();
                //当前栈顶元素与ch不匹配，直接返回false
                else
                    return false;
            }
        }
        //如果栈为空，返回true
        if (S.empty())
            return true;
        else
            return false;
    }
};

21.合并两个有序链表

方法二 递归（推荐）

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1 == nullptr) {
            return l2;
        } else if (l2 == nullptr) {
            return l1;
        } else if (l1->val < l2->val) {
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        } else {
            l2->next = mergeTwoLists(l1, l2->next);
            return l2;
        }
    }
};

26.删除有序数组中的重复项

 public int removeDuplicates(int[] nums) {
    if(nums == null || nums.length == 0) return 0;
    int p = 0;
    int q = 1;
    while(q < nums.length){
        if(nums[p] != nums[q]){
            nums[p + 1] = nums[q];
            p++;
        }
        q++;
    }
    return p + 1;
}

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int p=0,q=1;
        while(q<nums.size()) {
            if(nums[q]!=nums[p]) {
                nums[++p]=nums[q];
            }
            q++;
        }
        return p+1;
    }
};

图一 Java

图二 c++