LeetCode刷题系列（十一）Data Structure
来源：互联网 发布：js 如何取list 编辑：程序博客网 时间：2024/04/28 06:48
本篇给出了几种考察一些数据结构的理解的题型。
Min Stack
Min Stack除了能实现普通stack的操作之外，还要求能返回stack中的最小值，所有的操作都要在O(1)的时间内完成。看到题目也许能想到stack本身的所有操作也是可以在O(1)的时间内完成的。那么这道题目其实使用了两个stack，其中一个保存当前数组中最小的数，每存入一个数，两个stack都push进一个，这样就不用保存最小数是前几个数的最小数了，而pop时，两个stack都进行pop即可。并且这样就可以使求最小值的操作的事件复杂度也为O(1)了。
public class MinStack { private Stack<Integer> stack; private Stack<Integer> minStack; public MinStack() { stack = new Stack<Integer>(); minStack = new Stack<Integer>(); } public void push(int number) { stack.push(number); if (minStack.isEmpty()) { minStack.push(number); } else { minStack.push(Math.min(number, minStack.peek())); } } public int pop() { minStack.pop(); return stack.pop(); } public int min() { return minStack.peek(); }}Implement Queue by Two Stacks
题目要求使用两个stack来实现一个queue，并且时间复杂度为O(1)。相信不用我介绍，大家也明白stack与queue的区别是，stack是先进后出而queue是先进先出，用两个stack可以很轻松的实现一个queue，难点在于时间复杂度。如果想操作的均摊复杂度为O(1)，我们当进行push操作时使用stack1，而pop时使用stack2，然后当stack2为空时，我们才把stack1中的元素push到stack2中，如此并不影响元素按先进先出顺序出队列，同时，每个元素只被“倒”了一次，所以符合题目的均摊时间复杂度为O(1)。
public class Queue { private Stack<Integer> stack1; private Stack<Integer> stack2; public Queue() { stack1 = new Stack<Integer>(); stack2 = new Stack<Integer>(); } private void stack2ToStack1() { while (! stack2.empty()) { stack1.push(stack2.pop()); } } public void push(int number) { stack2.push(number); } public int pop() { if (stack1.empty() == true) { this.stack2ToStack1(); } return stack1.pop(); } public int top() { if (stack1.empty() == true) { this.stack2ToStack1(); } return stack1.peek(); }}Word Search
题目为给出一个二维board板（可以看成是词典）上，判定某个字符串（单词）是否在其中出现。其实这道题不是考察的对数据结构的理解，而是搜索，按题目很容易就能看出来，使用DFS是最容易的。
public class Solution { public boolean exist(char[][] board, String word) { if(board == null || board.length == 0) return false; if(word.length() == 0) return true; for(int i = 0; i< board.length; i++){ for(int j=0; j< board[0].length; j++){ if(board[i][j] == word.charAt(0)){ boolean rst = find(board, i, j, word, 0); if(rst) return true; } } } return false; } private boolean find(char[][] board, int i, int j, String word, int start){ if(start == word.length()) return true; if (i < 0 || i>= board.length || j < 0 || j >= board[0].length || board[i][j] != word.charAt(start)){ return false; } board[i][j] = '#'; // should remember to mark it boolean rst = find(board, i-1, j, word, start+1) || find(board, i, j-1, word, start+1) || find(board, i+1, j, word, start+1) || find(board, i, j+1, word, start+1)); board[i][j] = word.charAt(start); return rst; }}Word Search II
这道题其实的考察是trie树，trie树定义其实并不是很难，它的每个节点下面都有可能有n个子节点，但是最多只能由26个节点（这道题中），它将所有的信息按照一定规律保存起来，然后我们需要对其中内容进行搜索的时候，就可以较快速的得到答案，类似于hash表。需要注意的是trie树的查找的时间复杂度为O(1)而不是O(n)。在我们这道题中，创建一个trie树，将词典中的单词逐一插入到trie树中，其中每个单词的结尾字母做一个标记，并且标注是哪个单词的。这样做可以减少创建trie树的复杂度和时间，如果使用broad词典中信息来创建trie树则会花费大量的时间，因为trie树本身就是适合于查找的。然后从broad词典的起点开始每个点都进行“上下左右”的深搜，找到单词则保存到结果中即可。
class TrieNode { String s; boolean isString; HashMap<Character, TrieNode> subtree; public TrieNode() { // TODO Auto-generated constructor stub isString = false; subtree = new HashMap<Character, TrieNode>(); s = ""; }};class TrieTree{ TrieNode root ; public TrieTree(TrieNode TrieNode) { root = TrieNode; } public void insert(String s) { TrieNode now = root; for (int i = 0; i < s.length(); i++) { if (!now.subtree.containsKey(s.charAt(i))) { now.subtree.put(s.charAt(i), new TrieNode()); } now = now.subtree.get(s.charAt(i)); } now.s = s; now.isString = true; } public boolean find(String s){ TrieNode now = root; for (int i = 0; i < s.length(); i++) { if (!now.subtree.containsKey(s.charAt(i))) { return false; } now = now.subtree.get(s.charAt(i)); } return now.isString ; }};public int []dx = {1, 0, -1, 0};public int []dy = {0, 1, 0, -1};public void search(char[][] board, int x, int y, TrieNode root, ArrayList<String> ans, String res) { if(root.isString == true) { if(!ans.contains(root.s)){ ans.add(root.s); } } if(x < 0 || x >= board.length || y < 0 || y >= board[0].length || board[x][y]==0 || root == null) return ; if(root.subtree.containsKey(board[x][y])){ for(int i = 0; i < 4; i++){ char now = board[x][y]; board[x][y] = 0; search(board, x+dx[i], y+dy[i], root.subtree.get(now), ans, res); board[x][y] = now; } }}public ArrayList<String> wordSearchII(char[][] board, ArrayList<String> words) { ArrayList<String> ans = new ArrayList<String>(); TrieTree tree = new TrieTree(new TrieNode()); for(String word : words){ tree.insert(word); } String res = ""; for(int i = 0; i < board.length; i++){ for(int j = 0; j < board[i].length; j++){ search(board, i, j, tree.root, ans, res); } } return ans;}LRU Cache
LRU缓存是最近最少使用原则，这个缓存机制是当缓存块不够使用时将最近最少使用的数据从缓存中删除。所以，我们使用一个链表来保存数据的访问顺序，这样当缓存不够用时就可以知道需要直接删掉哪些数据了。链表我们并不用经常的维护，所以并不是很费时间，而我们使用一个HashMap来保存缓存数据。
public class LRUCache { private class Node{ Node prev; Node next; int key; int value; public Node(int key, int value) { this.key = key; this.value = value; this.prev = null; this.next = null; } } private int capacity; private HashMap<Integer, Node> hs = new HashMap<Integer, Node>(); private Node head = new Node(-1, -1); private Node tail = new Node(-1, -1); public LRUCache(int capacity) { this.capacity = capacity; tail.prev = head; head.next = tail; } public int get(int key) { if( !hs.containsKey(key)) { return -1; } // remove current Node current = hs.get(key); current.prev.next = current.next; current.next.prev = current.prev; // move current to tail move_to_tail(current); return hs.get(key).value; } public void set(int key, int value) { if( get(key) != -1) { hs.get(key).value = value; return; } if (hs.size() == capacity) { hs.remove(head.next.key); head.next = head.next.next; head.next.prev = head; } Node insert = new Node(key, value); hs.put(key, insert); move_to_tail(insert); } private void move_to_tail(Node current) { current.prev = tail.prev; tail.prev = current; current.prev.next = current; current.next = tail; }}Max Tree
Max Tree类似于最大堆，最大的元素在上面。而左右子树的根为被父节点分成两部分中的最大元素。怎么取最大的元素是这道题的难点。如果递归去找，时间复杂度会达到O(n^2)，那我们使用一个栈来解决，画出栈分析可以看出，一个元素被插入到的父节点是它左边最大值和右边最大值中的较小者。那么按栈来保存需要被插入的节点即可。
public static TreeNode maxTree(int[] A) { Stack<TreeNode> stack = new Stack<TreeNode>(); TreeNode root = null; for (int i = 0; i <= A.length; i++) { TreeNode right = i == A.length ? new TreeNode(Integer.MAX_VALUE) : new TreeNode(A[i]); while (!stack.isEmpty()) { if (right.val > stack.peek().val) { TreeNode nodeNow = stack.pop(); if (stack.isEmpty()) { right.left = nodeNow; } else { TreeNode left = stack.peek(); if (left.val > right.val) { right.left = nodeNow; } else { left.right = nodeNow; } } } else break; } stack.push(right); } return stack.peek().left;}Largest Rectangle in Histogram
这道题给定一组高度值，以这组高度值宽度为1画出柱状图，求图中矩形面积最大的值。能形成矩形，矩形的高一定是图中“最矮”的高度值，宽度为能“够到”的数组的index连续个数。类似于上道题的思路，我们使用一个栈来寻找一个数左边的最小值，查看现有能形成的最大矩形，但是我们并不是对每个值都进行这个操作，而是对一个数的右边的数如果小于它本身，那么他就该计算了，此时计算矩形可以得到目前的最大矩形值。
public int largestRectangleArea(int[] height) { if (height == null || height.length == 0) { return 0; } Stack<Integer> stack = new Stack<Integer>(); int max = 0; for (int i = 0; i <= height.length; i++) { int curt = (i == height.length) ? -1 : height[i]; while (!stack.isEmpty() && curt <= height[stack.peek()]) { int h = height[stack.pop()]; int w = stack.isEmpty() ? i : i - stack.peek() - 1; max = Math.max(max, h * w); } stack.push(i); } return max;} 0 0
- LeetCode刷题系列（十一）Data Structure
- Basic Data Structure（弱校联盟十一专场）
- Leetcode 题解系列（十一）
- Data Structure?（hdu4217）
- LeetCode Summary of Data Structure & Algorithms
- LeetCode Two Sum III - Data structure design
- LeetCode-Two Sum III - Data structure design
- [Leetcode] Two Sum III - Data structure design
- LeetCode - Two Sum III - Data structure design
- Leetcode|Two Sum III - Data structure design
- leetcode 432. All O`one Data Structure
- LeetCode 432. All O`one Data Structure
- [LeetCode]432. All O`one Data Structure
- leetcode 432. All O`one Data Structure
- [LeetCode] All O`one Data Structure
- leetcode 432. All O`one Data Structure
- Data Structure
- Data structure
- javascript小记——变量和函数的声明提前
- 图片上文字
- springMVC数据绑定之日期属性编辑器（最好用）
- android-Manifest
- CSS 下拉菜单
- LeetCode刷题系列（十一）Data Structure
- 双系统：win7 系统中添加ubuntu 启动引导
- Android开发基础复习zhi2
- iOS_二维码名片vCard
- Regex
- PHP实例化对象
- 微信对接
- [疯狂Java]正则表达式：捕获组、反向引用、捕获组命名
- Nodejs 发送HTTP POST请求实例
