栈涉及的问题

question：内存中的堆栈和数据结构的堆栈

answer：

1.内存中的堆栈是真实存在的物理区，数据结构中的堆栈是抽象的数据存储结构；

内存空间逻辑上分为：代码区、静态数据区、动态数据区（栈区+堆区）；

代码区存储二进制代码。作业调度，内存调度，进程调度，控制代码区执行代码切换；

静态数据区：存储全局变量、静态变量、常量，常量包括final修饰的Sting常量。系统自动分配和回收；

栈区：存储运行方法的形参、局部变量、返回值。由系统自动分配和回收；

堆区：new一个对象的引用或地址存储在栈区，指向该对象存储在堆区中的真实数据；

2.为什么函数调用要用栈来保存临时变量？

符合后进先出的特性；

leetcode：20,155,232,844,224,682,496.

Leetcode20：

class Leetcode20{
	private HashMap<Character,Character>mappings;
	
	public Leetcode20() {
		this.mappings = new HashMap<Character,Character>();
		this.mappings.put(')', '(');
		this.mappings.put('}', '{');
		this.mappings.put(']', '[');
	}
	
	public boolean isValid(String s) {
		Stack<Character> store = new Stack<Character>();
		
		for(int i=0;i<s.length();i++) {
			char c=s.charAt(i);
			//当时一个closing bracket
			if(this.mappings.containsKey(c)) {
				char topElement = store.empty()?'#':store.pop();
				//判断顶元素和输入元素是否相等
				if(topElement != this.mappings.get(c)) {
					return false;
				}
			}else {
				//当是一个opening bracket
				store.push(c);
			}
		}
		return store.empty();
	}
	
	//思想一样但语法更加优秀的版本
	public boolean isValidWay2(String s) {
		Stack<Character> stack = new Stack<Character>();
		
		for(char c:s.toCharArray()) {
			if(c=='(')
				stack.push(')');
			else if(c=='[')
				stack.push(']');
			else if(c=='{')
				stack.push('}');
			else if(stack.isEmpty() || stack.pop() != c){
				return false;
			}
		}
		return stack.isEmpty();
	}
}

class solution:
    def isValid(self):
        stack = []
        mapping = {")":"(","]":"[","}":"{"}

        for char in s:
            if char in mapping:
                top_element = stack.pop() if stack else '#'

                if mapping[char] != top_element:
                    return False
            else:
                stack.append(char)
        return not stack

s = "()()"
if solution.isValid(s):
    print("good")
else:
    print("bad")

LeetCode155：

//弹出 LeetCode155
//算法思想：每次min更新的时候，前一次的min被压入栈，弹出的时候需要注意弹出的是否为min，如果是则更新min为前一次min
class MinStack{
	int min = Integer.MAX_VALUE;
	Stack<Integer> stack = new Stack<Integer>();
	
	public void push(int x) {
		if(x <= min) {
			stack.push(min);//如果最小值更新的话，则将前一次的min压入栈；
			min = x;
		}
		stack.push(x);//随后继续将新的值压入栈
	}
	
	public void pop() {
		if(stack.pop() == min)
			min = stack.pop();
	}
	
	public int top() {
		return stack.peek();
	}
	
	public int getMin() {
		return min;
	}
}
//算法思想：将push值与min的差值压入栈，差值为负，当前值为最小值
class MinStackWay2{
	long min;
	Stack<Long> stack = new Stack<Long>();
	
	public void push(int x) {
		if(stack.isEmpty()) {
			stack.push(0L);//栈为空时差值为0压入栈
			min = x;
		}else {
			stack.push(x-min);//不为空将差值压入栈
			if(x < min) min = x;
		}
	}
	public void pop() {
		if(stack.isEmpty()) return;
		long pop = stack.pop();//这里已经执行了弹栈
		
		if(pop < 0) min = min - pop;//如果弹出值小于0则弹出了min；
	}
	
	public int top() {
		long top = stack.peek();
		if(top < 0) {
			return (int)(min);
		}else {
			return (int)(min+top);
		}
	}
	
	public int getMin() {
		return (int)min;
	}
}

LeetCode232：

猜你喜欢