Java数据结构——栈的应用

栈的应用(目前只写了两个，剩余的可以自己尝试)

1. 进制转换

1.1 原理

• 十进制数N，其他进制数d，满足：N = (N div d)*d + (N mod d)，div为整除, mod为求余。
• 图例：

1.2 实现代码

	/**
	 * 这是一个栈的应用：进制转换
	 * @param N 十进制数
	 * @param T 所要转换成的进制数
	 * @return 进制数
	 */
	public void Conversion(int N, int T) {
		int temp  = N;
		SqStack S = new SqStack();
		while(N!=0) {
			S.Push(N%T);
			N /= T;
		}
		System.out.print("十进制数"+temp+"的"+T+"进制数：");
		while(!S.StackEmpty()) {
			System.out.print(+S.Pop());
		}
	}

---

2. 括号匹配的检验

2.1 原理

• 描述题意：假设表达式允许两种括号：圆括号和方括号，其中嵌套的顺序随意。该程序保证表达式括号顺序正确。
• 原理：期待的急迫程度。
• 原理描述：

• 如图：

  当计算机接受了第一个括号后,它期待着与其匹配的第八个括号的出现,然而等来的却是第二个括号,此时第一个括号“[”只能暂时靠边,而迫切等待与第二个括号相匹配的、第七个括号“)”的出现，类似地,因等来的是第三个括号“[”,其期待匹配的程度较第二个括号更急迫,则第二个括号也只能靠边,让位于第三个括号,显然第二个括号的期待急迫性高于第一个括号;在接受了第四个括号之后,第三个括号的期待得到满足,消解之后,第二个括号的期待匹配就成为当前最急迫的任务了.依次类推。可见，这个处理过程恰与栈的特点相吻合。

2.2 实现代码

	/**
	 * 这是一个栈的应用：括号匹配
	 * @author 己千之
	 */
	public boolean Matching(String line) {
		StackApp SA = new StackApp();
		SA.push('#');
		char tempChar; char temp_pop;
		for(int i=0; i<line.length(); i++) {
			tempChar = line.charAt(i);
			
			switch(tempChar) {
			case '(':
			case '[':
				SA.push(tempChar);
				break;
			case ')':
				temp_pop = SA.pop();
				if(temp_pop != '(') {
					return false;
				}
				break;
			case ']':
				temp_pop = SA.pop();
				if(temp_pop != '[') {
					return false;
				}
				break;
			default:		
			}// of switch
		}// of for
		temp_pop = SA.pop();
		if(temp_pop != '#') {
			return false;
		}
		return true;
	}// of Matching

---

3. 行编辑程序

3.1 原理

3.1 实现代码

4. 表达式求值

4.1 原理

4.1 实现代码

5. Java源码

5.1 StackApp类

/**
 * 这是一个栈的应用类，入栈，出栈类型是char
 * @author NoBug
 * @version 2.0
 */
public class StackApp extends SqStack {

	/**
	* stacksize,data都是每个类私有的
	*/
	private int stacksize;
	private char[] data;
	
	/**
	 * 构造一个空栈,初始化，STACK_SIZE是继承自父类
	 */
	StackApp() {
		this.stacksize = 0;
		this.data = new char[STACK_SIZE];
	}//of StackApp
	
	/**
	 * 入栈push,不是重写父类,是重载
	 * @param elem 表示待入栈的char型元素
	 * @return 成功或失败
	 */
	public boolean push(char elem) {
		if(this.stacksize==STACK_SIZE) {
			System.out.println("Stack full.");
			return false;
		}//Stack full
		this.data[this.stacksize] = elem;
		this.stacksize++;
		
		return true;
	}//of push
	
	/**
	 * 出栈pop，不是重写父类
	 * @return 
	 * @return elem 删除栈顶，并返回删除值
	 */
	public char pop() {
		if(this.stacksize==0) {
			System.out.println("StackEmpty.");
			return '0';
		}//of StackEmpty
		
		char elem = data[this.stacksize-1];
		this.stacksize--;
		
		return elem;
	}//of pop	
	
	/**
	 * 便历，输出，重写toString()
	 * @return result data数组里面的值，以字符串形式输出
	 */
	public String toString() {
		String result = "";
		for(int i=0; i<this.stacksize; i++) {
			result += data[i]+" ";
		}
		
		return result;
	}//of toString
	
	/**
	 * 这是一个栈的应用：进制转换
	 * @author NoBug
	 * @param N 十进制数
	 * @param T 所要转换成的进制数
	 */
	public void Conversion(int N, int T) {
		int temp  = N;
		SqStack S = new SqStack();
		while(N!=0) {
			S.Push(N%T);
			N /= T;
		}
		System.out.print("十进制数"+temp+"的"+T+"进制数：");
		while(!S.StackEmpty()) {
			System.out.print(+S.Pop());
		}
		System.out.println();
	}	
	
	/**
	 * 这是一个栈的应用：括号匹配
	 * @author NoBug
	 */
	public boolean Matching(String line) {
		StackApp SA = new StackApp();
		SA.push('#');
		char tempChar; char temp_pop;
		for(int i=0; i<line.length(); i++) {
			tempChar = line.charAt(i);
			
			switch(tempChar) {
			case '(':
			case '[':
				SA.push(tempChar);
				break;
			case ')':
				temp_pop = SA.pop();
				if(temp_pop != '(') {
					return false;
				}
				break;
			case ']':
				temp_pop = SA.pop();
				if(temp_pop != '[') {
					return false;
				}
				break;
			default:		
			}// of switch
		}// of for
		temp_pop = SA.pop();
		if(temp_pop != '#') {
			return false;
		}
		return true;
	}// of Matching
	
} // StackApp