tc_LeetCode

1.两数相加

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

package LeetCode.tc;
//我们使用变量来跟踪进位，并从包含最低有效位的表头开始模拟逐位相加的过程。
//        就像你在纸上计算两个数字的和那样，我们首先从最低有效位也就是列表 l1l1 和 l2l2 的表头开始相加。
//        由于每位数字都应当处于 0…9 的范围内，我们计算两个数字的和时可能会出现“溢出”。
//        例如，5+7=12。在这种情况下，我们会将当前位的数值设置为 22，
//        并将进位 carry = 1carry=1 带入下一次迭代。进位 carrycarry 必定是 00 或 11，
//        这是因为两个数字相加（考虑到进位）可能出现的最大和为9+9+1=19.
//伪代码如下：
//
//将当前结点初始化为返回列表的哑结点。
//将进位 carrycarry 初始化为 00。
//将 pp 和 qq 分别初始化为列表 l1l1 和 l2l2 的头部。
//遍历列表 l1l1 和 l2l2 直至到达它们的尾端。
//将 xx 设为结点 pp 的值。如果 pp 已经到达 l1l1 的末尾，则将其值设置为 00。
//将 yy 设为结点 qq 的值。如果 qq 已经到达 l2l2 的末尾，则将其值设置为 00。
//设定 sum = x + y + carrysum=x+y+carry。
//更新进位的值，carry = sum / 10carry=sum/10。
//创建一个数值为 (sum \bmod 10)(summod10) 的新结点，并将其设置为当前结点的下一个结点，然后将当前结点前进到下一个结点。
//同时，将 pp 和 qq 前进到下一个结点。
//检查 carry = 1carry=1 是否成立，如果成立，则向返回列表追加一个含有数字 11 的新结点。
//返回哑结点的下一个结点。
//请注意，我们使用哑结点来简化代码。如果没有哑结点，则必须编写额外的条件语句来初始化表头的值
public class _1两数相加 {

    public  static class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }

    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummyHead=new ListNode(0);
        ListNode p=l1,q=l2,curr=dummyHead;
        int carry=0;
        while(p!=null||q!=null){

         int x=(p!=null)?p.val:0;
         int y=(q!=null)?q.val:0;

         int sum=x+y+carry;
         carry=sum/10;
         curr.next=new ListNode(sum%10);
         curr=curr.next;
         if (p!=null) p=p.next;
         if (q!=null) q=q.next;
        }

        if (carry>0){
            curr.next=new ListNode(carry);
        }
        return dummyHead.next;

    }

}

2.寻找两个有序数组的中位数

给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。

请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

nums1 = [1, 3]
nums2 = [2]

则中位数是 2.0
示例 2:

nums1 = [1, 2]
nums2 = [3, 4]

则中位数是 (2 + 3)/2 = 2.5

```java
package LeetCode.tc;
//给定两个有序数组，要求找到两个有序数组的中位数，最直观的思路有以下两种：
//
//使用归并的方式，合并两个有序数组，得到一个大的有序数组。大的有序数组的中间位置的元素，即为中位数。
//
//不需要合并两个有序数组，只要找到中位数的位置即可。由于两个数组的长度已知，因此中位数对应的两个数组的下标之和也是已知的。维护两个指针，初始时分别指向两个数组的下标 00 的位置，每次将指向较小值的指针后移一位（如果一个指针已经到达数组末尾，则只需要移动另一个数组的指针），直到到达中位数的位置。
//
//假设两个有序数组的长度分别为 mm 和 nn，上述两种思路的复杂度如何？
//
//第一种思路的时间复杂度是 O(m+n)O(m+n)，空间复杂度是 O(m+n)O(m+n)。第二种思路虽然可以将空间复杂度降到 O(1)O(1)，但是时间复杂度仍是 O(m+n)O(m+n)。题目要求时间复杂度是 O(\log(m+n))O(log(m+n))，因此上述两种思路都不满足题目要求的时间复杂度。
//
//如何把时间复杂度降低到 O(\log(m+n))O(log(m+n)) 呢？如果对时间复杂度的要求有 \loglog，通常都需要用到二分查找，这道题也可以通过二分查找实现。
public class _2寻找两个有序数组的中位数 {
    //https://leetcode-cn.com/problems/median-of-two-sorted-arrays/solution/xun-zhao-liang-ge-you-xu-shu-zu-de-zhong-wei-s-114/

    class Solution {
        public double findMedianSortedArrays(int[] nums1, int[] nums2) {
            int length1 = nums1.length, length2 = nums2.length;
            int totalLength = length1 + length2;
            if (totalLength % 2 == 1) {
                int midIndex = totalLength / 2;
                double median = getKthElement(nums1, nums2, midIndex + 1);
                return median;
            } else {
                int midIndex1 = totalLength / 2 - 1, midIndex2 = totalLength / 2;
                double median = (getKthElement(nums1, nums2, midIndex1 + 1) + getKthElement(nums1, nums2, midIndex2 + 1)) / 2.0;
                return median;
            }
        }

        public int getKthElement(int[] nums1, int[] nums2, int k) {
            /* 主要思路：要找到第 k (k>1) 小的元素，那么就取 pivot1 = nums1[k/2-1] 和 pivot2 = nums2[k/2-1] 进行比较
             * 这里的 "/" 表示整除
             * nums1 中小于等于 pivot1 的元素有 nums1[0 .. k/2-2] 共计 k/2-1 个
             * nums2 中小于等于 pivot2 的元素有 nums2[0 .. k/2-2] 共计 k/2-1 个
             * 取 pivot = min(pivot1, pivot2)，两个数组中小于等于 pivot 的元素共计不会超过 (k/2-1) + (k/2-1) <= k-2 个
             * 这样 pivot 本身最大也只能是第 k-1 小的元素
             * 如果 pivot = pivot1，那么 nums1[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums1 数组
             * 如果 pivot = pivot2，那么 nums2[0 .. k/2-1] 都不可能是第 k 小的元素。把这些元素全部 "删除"，剩下的作为新的 nums2 数组
             * 由于我们 "删除" 了一些元素（这些元素都比第 k 小的元素要小），因此需要修改 k 的值，减去删除的数的个数
             */

            int length1 = nums1.length, length2 = nums2.length;
            int index1 = 0, index2 = 0;
            int kthElement = 0;

            while (true) {
                // 边界情况
                if (index1 == length1) {
                    return nums2[index2 + k - 1];
                }
                if (index2 == length2) {
                    return nums1[index1 + k - 1];
                }
                if (k == 1) {
                    return Math.min(nums1[index1], nums2[index2]);
                }

                // 正常情况
                int half = k / 2;
                int newIndex1 = Math.min(index1 + half, length1) - 1;
                int newIndex2 = Math.min(index2 + half, length2) - 1;
                int pivot1 = nums1[newIndex1], pivot2 = nums2[newIndex2];
                if (pivot1 <= pivot2) {
                    k -= (newIndex1 - index1 + 1);
                    index1 = newIndex1 + 1;
                } else {
                    k -= (newIndex2 - index2 + 1);
                    index2 = newIndex2 + 1;
                }
            }
        }
    }


}

# 3.最长回文子串
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
示例 2：

输入: "cbbd"
输出: "bb"

```java
package LeetCode.tc;

public class _3最长回文串 {
//https://leetcode-cn.com/problems/longest-palindromic-substring/solution/zui-chang-hui-wen-zi-chuan-by-leetcode-solution/
    //中心扩展算法
    //从回文串的中心向两边延展
    // 中心也就是边界  1.就是中心只有一个数子那就是回文串  2.就是i，i+1 要求s[i]==s[i+1]才是回文串
    //有了中心向两边扩展就行  两边扩展的值相等就行
    //复杂度 时间O(n2)    空间O(1)
    class Solution {
        public String longestPalindrome(String s) {
            if (s == null || s.length() < 1) return "";
            int start = 0, end = 0;
            for (int i = 0; i < s.length(); i++) {
                int len1 = expandAroundCenter(s, i, i);
                int len2 = expandAroundCenter(s, i, i + 1);
                int len = Math.max(len1, len2);
                if (len > end - start) {
                    start = i - (len - 1) / 2;
                    end = i + len / 2;
                }
            }
            return s.substring(start, end + 1);
        }

        private int expandAroundCenter(String s, int left, int right) {
            int L = left, R = right;
            while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
                L--;
                R++;
            }
            return R - L - 1;
        }
    }

}

4.整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321
示例 2:

输入: -123
输出: -321
示例 3:

输入: 120
输出: 21

package LeetCode.tc;

public class _4整数反转 {
   
    //leetcode-cn.com/problems/reverse-integer/solution/tu-wen-xiang-jie-javadai-ma-de-2chong-shi-xian-fan/
    //翻转每一位数字即可
    public int reverse(int x) {
   
        int res = 0;
        while (x != 0) {
   
            int t = x % 10;
            int newRes = res * 10 + t;
            //如果数字溢出，直接返回0
            if ((newRes - t) / 10 != res)
                return 0;
            res = newRes;
            x = x / 10;
        }
        return res;
    }

}

5.字符串转换整数 (atoi)

请你来实现一个 atoi 函数，使其能将字符串转换成整数。

首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。接下来的转化规则如下：

如果第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字字符组合起来，形成一个有符号整数。
假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成一个整数。
该字符串在有效的整数部分之后也可能会存在多余的字符，那么这些字符可以被忽略，它们对函数不应该造成影响。
注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换，即无法进行有效转换。

在任何情况下，若函数不能进行有效的转换时，请返回 0 。

提示：

本题中的空白字符只包括空格字符 ’ ’ 。
假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231, 231 − 1]。如果数值超过这个范围，请返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。

示例 1:

输入: “42”
输出: 42
示例 2:

输入: " -42"
输出: -42
解释: 第一个非空白字符为 ‘-’, 它是一个负号。
我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。
示例 3:

输入: “4193 with words”
输出: 4193
解释: 转换截止于数字 ‘3’ ，因为它的下一个字符不为数字。
示例 4:

输入: “words and 987”
输出: 0
解释: 第一个非空字符是 ‘w’, 但它不是数字或正、负号。
因此无法执行有效的转换。
示例 5:

输入: “-91283472332”
输出: -2147483648
解释: 数字 “-91283472332” 超过 32 位有符号整数范围。
因此返回 INT_MIN (−231) 。

package LeetCode.tc;

public class _5字符串转换整数 {
   
    //leetcode-cn.com/problems/string-to-integer-atoi/solution/san-chong-fang-fa-zheng-chang-bian-li-you-xian-zhu/
//根据题目思路，我们先去掉空格，然后判断是否有正负号，利用flag标记，最后开始匹配数字并将数字记录在ans里面，并结合flag返回值；时间复杂度O（n），空间复杂度O（1）
class Solution {
   
        public int myAtoi(String str) {
   

            int i=0,n=str.length();
            while(i<n&&str.charAt(i)==' ')i++;
            if(i==n)return 0;
            int flag=1;
            if(str.charAt(i)=='+'||str.charAt(i)=='-'){
   
                if(str.charAt(i)=='-')flag=-1;
                i++;
            }

            int ans=0;
            while(i<n&&Character.isDigit(str.charAt(i))) {
   
                int temp=str.charAt(i)-'0';
                if (flag == 1 && (ans > Integer.MAX_VALUE / 10 || (ans == Integer.MAX_VALUE / 10 && temp > 7)))
                    return Integer.MAX_VALUE ;
                //以正数为列，考虑稳大于和加temp才大于的情况
                if (flag == -1 && (ans > -(Integer.MIN_VALUE / 10) || (ans == -(Integer.MIN_VALUE / 10) && temp > 8)))
                    return Integer.MIN_VALUE;
                ans=ans*10+temp;
                i++;
            }
            return ans*flag;
        }
    }

}

6.回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:

输入: 121
输出: true
示例 2:

输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:

输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

package LeetCode.tc;

public class _6回文数 {
   
    //https://leetcode-cn.com/problems/palindrome-number/solution/hui-wen-shu-by-leetcode-solution/
    //反转一半的数
    class Solution {
   
        public boolean isPalindrome(int x) {
   
            // 特殊情况：
            // 如上所述，当 x < 0 时，x 不是回文数。
            // 同样地，如果数字的最后一位是 0，为了使该数字为回文，
            // 则其第一位数字也应该是 0
            // 只有 0 满足这一属性
            if (x < 0 || (x % 10 == 0 && x != 0)) {
   
                return false;
            }

            int revertedNumber = 0;
            while (x > revertedNumber) {
   
                revertedNumber = revertedNumber * 10 + x % 10;
                x /= 10;
            }

            // 当数字长度为奇数时，我们可以通过 revertedNumber/10 去除处于中位的数字。
            // 例如，当输入为 12321 时，在 while 循环的末尾我们可以得到 x = 12，revertedNumber = 123，
            // 由于处于中位的数字不影响回文（它总是与自己相等），所以我们可以简单地将其去除。
            return x == revertedNumber || x == revertedNumber / 10;
        }
    }
}

7.盛最多水的容器

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水

package LeetCode.tc;

public class _7盛水最多的容器 {
   
    //https://leetcode-cn.com/problems/container-with-most-water/solution/sheng-zui-duo-shui-de-rong-qi-by-leetcode-solution/
//为什么双指针的做法是正确的？
//
//双指针代表了什么？
//
//双指针代表的是 可以作为容器边界的所有位置的范围。在一开始，双指针指向数组的左右边界，表示 数组中所有的位置都可以作为容器的边界，
// 因为我们还没有进行过任何尝试。在这之后，我们每次将 对应的数字较小的那个指针 往 另一个指针 的方向移动一个位置，就表示我们认为
// 这个指针不可能再作为容器的边界了。
//
//为什么对应的数字较小的那个指针不可能再作为容器的边界了？
//
//在上面的分析部分，我们对这个问题有了一点初步的想法。这里我们定量地进行证明。
//
//考虑第一步，假设当前左指针和右指针指向的数分别为 x 和 y，不失一般性，我们假设 x≤y。同时，两个指针之间的距离为 t。那么，
// 它们组成的容器的容量为：
//
//min(x, y) * t = x * t
//
//我们可以断定，如果我们保持左指针的位置不变，那么无论右指针在哪里，这个容器的容量都不会超过 x * t 了。注意这里右指针只能向左移动，
// 因为 我们考虑的是第一步，也就是 指针还指向数组的左右边界的时候。
    public class Solution {
   
        public int maxArea(int[] height) {
   
            int l = 0, r = height.length - 1;
            int ans = 0;
            while (l < r) {
   
                int area = Math.min(height[l], height[r]) * (r - l);
                ans = Math.max(ans, area);
                if (height[l] <= height[r]) {
   
                    ++l;
                }
                else {
   
                    --r;
                }
            }
            return ans;
        }
    }

}

8.最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1:

输入: [“flower”,“flow”,“flight”]
输出: “fl”
示例 2:

输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。

package LeetCode.tc;

//解法2：垂直扫描法（见下代码）
//
//        另外一种方法是，我们不像刚刚的方法一样将最长公共子串由长变短，而是由短变长。我们从0开始迭代，
//        对于每次迭代，我们验证index=i的位置上的所有字符串是否都为同一字符，以此类推，从而得到最长公共子串
public class _8最长公共前缀 {
   
    public static String longestCommonPrefix(String[] strs) {
   
        if (strs.length==0){
   
            return "";
        }
        Boolean flag=true;
        int current=0;
        StringBuilder stringBuilder=new StringBuilder();
        while (flag){
   
            Character character=null;
            for (String s:strs){
   
                if (current<s.length()){
   
                    if (character==null){
   
                        character=s.charAt(current);
                    }else {
   
                        if (!character.equals(s.charAt(current))){
   
                            flag=false;
                            break;
                        }
                    }
                }else {
   
                    flag=false;
                }
            }
            if (flag&&character!=null){
   
                stringBuilder.append(character);
            }
            current++;
        }
        return stringBuilder.toString();
    }

    public static void main(String[] args) {
   
        String[]  s ={
   "dog","racecar","car"};
        System.out.println(longestCommonPrefix(s));
    }
}

9.三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

package LeetCode.tc;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
//单纯的暴力解法包含大量的重复运算（重复的求和计算），我们通过对数组的排序，减少这种重复计算；
//        具体来讲：我们首先将数组排序，然后遍历数组的每一个index=i，对于每个值（我们记这个指为a），
//        我们需要找到另外找到数组中的两个数，使得他们的和等于一个定值（sum-a）。
//        为了寻找这个定值和，我们从数组的其余部分寻找，我们初始化左指针为index=i+1，右指针为index=length-1；
//        由于数组是排序过的，所以如果nums[i+1]+nums[length-1]<sum-a，我们可以知道，nums[i+1]和
//        index=i+2~length-1区间内的任何数的和都不可能等于sum-a。由此我们可以大大简化计算。
public class _9三数之和 {
   
    public static List<List<Integer>> threeSum(int[] nums) {
   
        List<List<Integer>> list = new ArrayList<>();
        int length=nums.length;
        if (length <= 2) {
   

            return list;
        }
        Arrays.sort(nums);
        for (int i=0;i<length-2;i++){
   


            if (i>0&&(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){
   
                    list.add(Arrays.asList(nums[i],nums[left],nums[right]));
                    left++;
                    right--;
                    while (left<right&&nums[left]==nums[left-1]){
   
                        left++;
                    }
                    while (left<right&&nums[right]==nums[right+1]){
   
                        right--;
                    }

                }else if (sum>0){
   
                    right--;
                }else {
   
                    left++;
                }
            }
        }
        return list;
    }

    public static void main(String[] args) {
   
        int[] a =new int[]{
   -1, 0, 1, 2, -1, -4};
        System.out.println(threeSum(a).toString());
    }
}

10.最接近的三数之和

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

package LeetCode.tc;


import java.util.Arrays;
//排序 + 双指针
//先排序 在使用双指针 从i=0开始b=1 c= n-1 指针开始移动计算三数之和若更接近则更新best
//https://leetcode-cn.com/problems/3sum-closest/solution/zui-jie-jin-de-san-shu-zhi-he-by-leetcode-solution/
public class _10最接近的三数之和 {
   
    class Solution {
   
        public int threeSumClosest(int[] nums, int target) {
   
            Arrays.sort(nums);
            int n = nums.length;
            int best = 10000000;

            // 枚举 a
            for (int i = 0; i < n; ++i) {
   
                // 保证和上一次枚举的元素不相等
                if (i > 0 && nums[i] == nums[i - 1]) {
   
                    continue;
                }
                // 使用双指针枚举 b 和 c
                int j = i + 1, k = n - 1;
                while (j < k) {
   
                    int sum = nums[i] + nums[j] + nums[k];
                    // 如果和为 target 直接返回答案
                    if (sum == target) {
   
                        return target;
                    }
                    // 根据差值的绝对值来更新答案
                    if (Math.abs(sum - target) < Math.abs(best - target)) {
   
                        best = sum;
                    }
                    if (sum > target) {
   
                        // 如果和大于 target，移动 c 对应的指针
                        int k0 = k - 1;
                        // 移动到下一个不相等的元素
                        while (j < k0 && nums[k0] == nums[k]) {
   
                            --k0;
                        }
                        k = k0;
                    } else {
   
                        // 如果和小于 target，移动 b 对应的指针
                        int j0 = j + 1;
                        // 移动到下一个不相等的元素
                        while (j0 < k && nums[j0] == nums[j]) {
   
                            ++j0;
                        }
                        j = j0;
                    }
                }
            }
            return best;
        }
    }

}

11.有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1:

输入: “()”
输出: true
示例 2:

输入: “()[]{}”
输出: true
示例 3:

输入: “(]”
输出: false
示例 4:

输入: “([)]”
输出: false
示例 5:

输入: “{[]}”
输出: true

package LeetCode.tc;

import java.util.HashMap;
import java.util.Stack;
//算法
//初始化栈 S。
//一次处理表达式的每个括号。
//如果遇到开括号，我们只需将其推到栈上即可。这意味着我们将稍后处理它，让我们简单地转到前面的 子表达式。
//如果我们遇到一个闭括号，那么我们检查栈顶的元素。如果栈顶的元素是一个 相同类型的 左括号，那么我们将它从栈中弹出并继续处理。否则，这意味着表达式无效。
//如果到最后我们剩下的栈中仍然有元素，那么这意味着表达式无效。
//https://leetcode-cn.com/problems/valid-parentheses/solution/you-xiao-de-gua-hao-by-leetcode/
public class _11有效的括号 {
   
    class Solution {
   

        // Hash table that takes care of the mappings.
        private HashMap<Character, Character> mappings;

        // Initialize hash map with mappings. This simply makes the code easier to read.
        public Solution() {
   
            this.mappings = new HashMap<Character, Character>();
            this.mappings.put(')', '(');
            this.mappings.put('}', '{');
            this.mappings.put(']', '[');
        }

        public boolean isValid(String s) {
   

            // Initialize a stack to be used in the algorithm.
            Stack<Character> stack = new Stack<Character>();

            for (int i = 0; i < s.length(); i++) {
   
                char c = s.charAt