java中的算法的一些总结

一、背景

1.最近刷了一会儿题目，感觉对自己很有帮助的，然后就记录下自己的学习，这个主要是算法的题目，感觉大佬们的思路很开阔，然后自己也跟着学习了一下。

二、题目一（有效的括号）

1.实现思路：

1.1.初始化栈 S。
1.2.一次处理表达式的每个括号。
1.3.如果遇到开括号，我们只需将其推到栈上即可。这意味着我们将稍后处理它，让我们简单地转到前面的子表达式。
1.4.如果我们遇到一个闭括号，那么我们检查栈顶的元素。如果栈顶的元素是一个 相同类型的 左括号，那么我们将它从栈中弹出并继续处理。否则，这意味着表达式无效。
1.5.如果到最后我们剩下的栈中仍然有元素，那么这意味着表达式无效。

2.代码演示

private static HashMap<Character, Character> mappings;
    public static void main(String[] args) {
        String str = "(()){{]}";
        boolean valid = isValid(str);
        System.out.println(valid);
    }
    static {
        mappings = new HashMap<Character, Character>();
        mappings.put(')', '(');
        mappings.put('}', '{');
        mappings.put(']', '[');
    }
    public static boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            //返回字符串指定位置的值
            char c = s.charAt(i);
            if (mappings.containsKey(c)) {
                //如果包含key数值，弹栈
                char topElement = stack.empty() ? '#' : stack.pop();
                //比对数值与栈中的是否一致
                if (topElement != mappings.get(c)) {
                    return false;
                }
            }else{
                //压栈
                stack.push(c);
            }
        }
        return stack.isEmpty();
    }

3.运行结果

false

三、题目二（两数之和）

1.第一中实现思路

public static void main(String[] args) {
       int[] nums = new int[]{2,7,11,15};
       int target = 9;
        int[] ints = twoSum(nums, target);
        for (int n = 0;n<ints.length;n++){
            System.out.println(ints[n]);
        }
    }
    public static int[] twoSum(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[j] == target - nums[i]) {
                    return new int[] { i, j };
                }
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }

1.2.结果

0
1

2.第二种实现思路（一遍哈希表）

 public static void main(String[] args) {
       int[] nums = new int[]{2,7,11,15};
       int target = 9;
        int[] ints = twoSum(nums, target);
        for (int n = 0;n<ints.length;n++){
            System.out.println(ints[n]);
        }
    }
    public static int[] twoSum(int[] nums, int target) {
        //注意范型，和下面的有关系，初始值是0,0
        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");
    }

2.1.结果同上面

四、题目三(最大子序和)
1.动态规划的是首先对数组进行遍历，当前最大连续子序列和为 sum，结果为 ans
2.如果 sum > 0，则说明 sum 对结果有增益效果，则 sum 保留并加上当前遍历数字
   如果 sum <= 0，则说明 sum 对结果无增益效果，需要舍弃，则 sum 直接更新为当前遍历数字
   每次比较 sum 和 ans的大小，将最大值置为ans，遍历结束返回结果

3.代码分析

 public static void main(String[] args) {
       int[] nums = new int[]{-2,1,-3,4,-1,2,1,-5,4};
       int ints = maxSubArray(nums);
       System.out.println(ints);
    }
    public static int maxSubArray(int[] nums) {
        //临时变量返回最大值
        int ans = nums[0];
        int sum = 0;
        for(int num: nums) {
            //参加计算的都是正数
            if(sum > 0) {
                sum += num;
            } else {
                sum = num;
            }
            //比较大小进行赋值，返回最大的值
            ans = Math.max(ans, sum);
        }
        return ans;
    }

五、结束

1.每天一道算法题，共勉！！！