当前位置: 首页>后端>正文

leetcode上栈和队列的用法 java版

问题由leetcode上20号问题引入
20. 有效的括号
给定一个只包括 '(',')','{','}','[',']' 的字符串,判断字符串是否有效。

有效字符串需满足:

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

示例 1:
输入: "()"
输出: true
示例 2:
输入: "()[]{}"
输出: true
示例 3:
输入: "(]"
输出: false
示例 4:
输入: "([)]"
输出: false

class Solution {
    public boolean isValid(String s) {
        char[] a=s.toCharArray() ;
        Stack<Character> stack = new Stack<>();
        for(int i=0;i<a.length;i++)  
        {if(a[i]=='('||a[i]=='{'||a[i]=='[')
               stack.push(a[i]);
        else {
                      if(stack.size()==0)
                      return false;
                      char c=stack.peek();
                      stack.pop();
                      char match=' ';
                      if(c=='(')
                      match=')';
                      if(c=='[')
                      match=']';
                      if(c=='{')
                      match='}';
                    if(a[i]!=match)
                    return false;
              }  
        }
            if(stack.size()!=0)
              return false;//防止一个左括号那种
              return true;
    }
}

接下来讲一讲栈和递归的紧密关系

问题来自leetcode144号问题
前序中序后序遍历均可以用递归实现

给定一个二叉树,返回它的 前序 遍历。

示例:

输入: [1,null,2,3]
1

2
/
3

输出: [1,2,3]

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res=new ArrayList<Integer>();
          if(root==null)
             return res;
        Stack<TreeNode> stack=new Stack<>();
           stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            res.add(node.val);
            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }
        }
        return res;        



    }
}

接下来聊一聊队列
队列的基本应用- 广度优先遍历(BFS)
树:层序遍历
图:无权图的最短路径
题目来自于leetcode102
给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)。

例如:
给定二叉树: [3,9,20,null,null,15,7],
3
/ \
9 20
-- / \
15 7
返回其层次遍历结果:

[
[3],
[9,20],
[15,7]
]


class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res=new ArrayList<>();
        if(root==null)
        return res;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);//队列先进先出
        while(!queue.isEmpty())
           {
            int count=queue.size();
            List<Integer> ls=new ArrayList<>();
             for(int i=0;i<count;i++)
                {
                     TreeNode node=queue.poll();//poll相当于先get再remove掉
                     ls.add(node.val);
                     if(node.left!=null)
                     queue.add(node.left);
                     if(node.right!=null)
                     queue.add(node.right);
                }
                res.add(ls);
           }
        return res;

    }
}

BFS和图的最短路径
leetcode279
给定正整数 n,找到若干个完全平方数(比如 1, 4, 9, 16, ...)使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

示例 1:

输入: n = 12
输出: 3
解释: 12 = 4 + 4 + 4.
示例 2:

输入: n = 13
输出: 2
解释: 13 = 4 + 9.

这里直觉使用贪心,但是不能成功
比如12=9+1+1+1
12=4+4+4
对问题建模
对整个问题转化为一个图论问题
从n到0,每个数字表示一个节点
如果两个数字x到y相差一个完全平方数,则连接一条边
我们得到了一个无权图
原问题转化为,求这个无权图从n到0的最短路径。

思路:
当每一次都可以判断出多种情况,有多次的时候就适合用BFS-广度优先遍历
使用BFS应注意:
队列:用来存储每一轮遍历得到的节点;
标记:对于遍历过的节点,应该将它标记,防止重复遍历。

我们将它第一个平方数可能出现的情况做分析 只要 i * i < n 就行
再在此基础上进行二次可能出现的平方数分析
注意:为了节省遍历的时间,曾经( n - 以前出现的平方数) 这个值出现过,则在此出现这样的数时直接忽略。

public class NumSquares {
    private class Node {
        int val;
        int step;

        public Node(int val, int step) {
            this.val = val;
            this.step = step;
        }
    }

    public int numSquares(int n) {
        Queue<Node> queue = new LinkedList<>();
        queue.add(new Node(n, 1));
        boolean record[] = new boolean[n];
        while (!queue.isEmpty()) {
            int val = queue.peek().val;
            int step = queue.peek().step;
            queue.remove();
            // 每一层的广度遍历
            for (int i = 1;; i++) {
                int nextVal = val - i * i;
                // 说明已到最大平方数
                if (nextVal < 0)
                    break;

                // 由于是广度遍历,所以当遍历到0时,肯定是最短路径
                if(nextVal == 0)
                    return step;
                
                // 当再次出现时没有必要加入,因为在该节点的路径长度肯定不小于第一次出现的路径长
                if(!record[nextVal]){
                queue.add(new Node(nextVal,step + 1));
                record[nextVal] = true;
                }
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        System.out.println(new NumSquares().numSquares(13));
    }

}

上述代码来源于leetcode的图解
链接:https://leetcode-cn.com/problems/perfect-squares/solution/yan-du-you-xian-sou-suo-java-by-1874-14/
来源:力扣(LeetCode)

优先队列
优先队列也是队列
普通队列是先进先出,优先队列是最大值先出
优先队列的底层实现:堆
java中的优先队列
优先队列PriorityQueue是Queue接口的实现,可以对其中元素进行排序,
可以放基本数据类型的包装类(如:Integer,Long等)或自定义的类
对于基本数据类型的包装器类,优先队列中元素默认排列顺序是升序排列
但对于自己定义的类来说,需要自己定义比较器
常用方法
peek()//返回队首元素
poll()//返回队首元素,队首元素出队列
add()//添加元素
size()//返回队列元素个数
isEmpty()//判断队列是否为空,为空返回true,不空返回false
优先队列示例
Queue<Integer> integerPriorityQueue = new PriorityQueue<>(7);
Queue<Customer> customerPriorityQueue = new PriorityQueue<>(7, idComparator);
接下来看例题

347. 前 K 个高频元素
给定一个非空的整数数组,返回其中出现频率前 k高的元素。

示例 1:

输入:nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

示例 2:

输入: nums = [1], k = 1
输出: [1]

维护一个含有k个元素的优先队列。如果遍历到的元素比队列中的最小频率元素的频率高,则取出队列中最小频率的元素,将新元素入队。最终,队列中剩下的,就是前k个出现频率最高的元素

class Solution {
    public List<Integer> topKFrequent(int[] nums, int k) {
        
        // 使用字典,统计每个元素出现的次数,元素为键,元素出现的次数为值
        HashMap<Integer,Integer> map = new HashMap();
        for(int num : nums){
            if (map.containsKey(num)) {
               map.put(num, map.get(num) + 1);
             } else {
                map.put(num, 1);
             }
        }
        // 遍历map,用最小堆保存频率最大的k个元素
        PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer a, Integer b) {
                return map.get(a) - map.get(b);
            }
        });
        for (Integer key : map.keySet()) {
            if (pq.size() < k) {
                pq.add(key);
            } else if (map.get(key) > map.get(pq.peek())) {
                pq.remove();
                pq.add(key);
            }
        }
        // 取出最小堆中的元素
        List<Integer> res = new ArrayList<>();
        while (!pq.isEmpty()) {
            res.add(pq.remove());
        }
        return res;
    }

    }

详解
https://leetcode-cn.com/problems/top-k-frequent-elements/solution/leetcode-di-347-hao-wen-ti-qian-k-ge-gao-pin-yuan-/


https://www.xamrdz.com/backend/3kz1929307.html

相关文章: