棧的結構比較簡單，跟連結串列差不多底層還是一個數組，程式碼實現也比較容易，主要利用的就是他的先進後出的特點，java程式碼如下：

<span style="font-size:14px;">package Stack;
/*
 * 棧的實現
 * 基本思路還是利用陣列來做實現
 */
public class MyStack {
	private static final int DEFUALT_LENGTH=10;
	private int theLength=0;
	private Object[] theItems;
	
	/*
	 * 構造一個空棧
	 */
	public MyStack(){
		clearStack();
	}
	
	/*
	 * 銷燬一個棧
	 */
	public void destroyStack(){}
	
	/*
	 * 清空一個棧
	 */
	public void clearStack(){
		theLength=0;
		ensureCapacity(DEFUALT_LENGTH);
	}
	
	/*
	 * 判斷一個棧是否為空
	 */
	public boolean isEmpty(){
		return theLength==0;
	}
	
	/*
	 * 返回棧的長度
	 */
	public int stackLength(){
		
		return theLength;
	}
	
	/*
	 * 返回棧頂元素
	 */
	public Object geTop(){
		if(isEmpty()){
			throw new IndexOutOfBoundsException();
		}
		Object obj=theItems[theLength-1];
		//theLength--;
		return obj;
	}
	
	/*
	 * 壓棧
	 */
	public void push(Object obj){
		if(theLength>=theItems.length){
			ensureCapacity(theLength*2+1);
		}
		theItems[theLength]=obj;
		theLength++;
	}
	
	/*
	 * 出棧
	 */
	public Object pop(){
		if(isEmpty()){
			return null;
		}
		Object obj=theItems[theLength-1];
		theLength--;
		//ensureCapacity(theLength);
		return obj;
	}
	
	/*
	 *陣列的擴充套件
	 */
	public void ensureCapacity(int newCapaciyty){
		if(theLength>newCapaciyty){
			return;
		}
		Object [] old=theItems;
		theItems=new Object[newCapaciyty];
		for(int i=0;i<theLength;i++){
			theItems[i]=old[i];
		}
	}
}
</span>
 

1  十進位制數轉換成其他任意進位制的數，這個原理很簡單，將迭代的餘數倒過來輸出即可

程式碼如下：

<span style="font-size:14px;">///十進位制數轉換成其他任意進位制的數
	private static String toOther(int tenNum, int otherNum) {
		// TODO Auto-generated method stub
		MyStack ms=new MyStack();
		int result=0;
		String results="";
		while(tenNum!=0){
			result=tenNum%otherNum;
			ms.push(result);
			tenNum=tenNum/otherNum;
		}
		result=0;
		while(!ms.isEmpty()){
			results+=ms.pop()+"";
		}
		return results;
	}</span>
 

    System.out.println("請輸入一個十進位制的數");
    int tenNum=sc.nextInt();
    System.out.println("請輸入要轉換的進位制數");
    int otherNum=sc.nextInt();
    String resultnum=toOther(tenNum,otherNum);
    System.out.println(resultnum);

請輸入一個十進位制的數
12
請輸入要轉換的進位制數
8
14

2 表示式的求值   ，直接上程式碼

//表示式的的求值
	/*
	 * 基本的原理是，構建兩個棧，一個用來存放運算元，一個用來存放運算子
	 * 依次輸入表示式中的每一個字元，
	 * 若是數字則直接將數字壓入存放運算元的那個棧
	 * 若是運算子則與運算子的棧頂元素進行比較，
	 * 如果運算子的優先順序低於棧頂元素，就要彈出兩個運算元和一個運算子進行運算操作
	 * 如果運算子的優先順序高於棧頂元素，就直接將運算子壓棧
	 * 如果是等於（在次規定只有”（“與“）”是想等的其他的相等取大於）
	 */
	
	/*
	 * 運算操作，根據兩個運算元和傳入的運算子來進行計算
	 */
	private static double operate(double x,double y,char operator){
		double result=0.0;
		switch (operator){
		case '+':
			result=x+y;
			break;
		case '-':
			result=x-y;
			break;
		case '*':
			result=x*y;
			break;
		case '/':
			result=x/y;
			break;
		}
		
		return result;
	}

	/*
	 * 比較兩個運算子的優先順序，第一個引數是存放運算子的棧頂元素，第二個引數是要壓入的元素。
	 * 正數表示大於，0表示等於，負數表示小於
	 */
	private static int precede(char stackTop,char toPush){
		int result=-1;
		if(stackTop=='-')
			stackTop='+';//這裡是比較優先順序，所以同一個優先順序的運算子可以看作是一樣的，方便與下面的陣列操作
		if(stackTop=='/')
			stackTop='*';
		if(toPush=='-')
			toPush='+';
		if(toPush=='/')
			toPush='*';
		char [] operators=new char[]{'#',')','+','*','('};
		if((stackTop=='('&&toPush==')')||(stackTop=='#'&&toPush=='#')){///這裡面只有這一種情況，因為運算子的棧必須是先有（，而且一旦遇到）除非出錯否則就會立刻彈出兩個括號
			result=0;
		}else{
			int inOfTop=getIndex(stackTop, operators);//得到棧頂元素的下標
			int inOfPush=getIndex(toPush, operators);
			if(inOfPush==-1||inOfTop==-1){
				throw new IndexOutOfBoundsException();//如果返回值是-1則表示不存在，這是出錯的情況，先丟擲異常。
			}else{
				if(inOfTop>=inOfPush){//相等或者大於軍則返回正值
					result=1;
				}else{
					result=-1;
				}
			}
		}
		return result;
	}
	
	//用於返回字元在再付陣列中的位置
	private static int getIndex(char ele,char[] chars){
		int index=-1;
		for(int i=0;i<chars.length;i++){
			if(chars[i]==ele){
				index=i;
				break;
			}
				
		}
		return index;
	}
	
	//判斷是不是字元
	private static boolean isChar(char ele){
		boolean flage=true;
		if(ele>='0'&&ele<='9')
			flage=false;
		return flage;
	}
	/*
	 * 真正開始操作
	 */
	private static double getResult(String evalueExpression){
		double result=0.0;
		//構建兩個棧
		MyStack Optr=new MyStack();//存放運算子的棧
		Optr.push('#');
		MyStack Opnd=new MyStack();//存放數字的棧
		int i=0;
		char[] chars=evalueExpression.toCharArray();//轉換成字元陣列
		char operOrType=' ';
		while(!Optr.isEmpty()){
			if(i<chars.length){
				operOrType=chars[i++];
			}
			char typeTop=(char) Optr.geTop();
			if(!isChar(operOrType))//不是運算子就直接壓入數字棧
				Opnd.push(operOrType);
			else{
				if(typeTop=='('&&operOrType!=')'){//但棧頂是（就得另說
					Optr.push(operOrType);
				}else{
					switch(precede(typeTop, operOrType)){
					case -1:
						Optr.push(operOrType);
						break;
					case 0://相等就意味著是一對括號或者#相遇，那麼必然的括號裡面的運算操作已經完成，所以要脫去括號
						Optr.pop();
						break;
					case 1://棧頂的優先順序高就先計算,
						double num1=Double.parseDouble(Opnd.pop()+"") ;
						double num2=Double.parseDouble(Opnd.pop()+"");
						char opType=(char) Optr.pop();
						result=operate(num2, num1, opType);
						Opnd.push(result);
						i--;//計算完成之後當前的操作符不能丟，因為前面的計算完成之後還要將其壓棧判斷
						break;
					}
				}
			}
		}
		return result;
	}
 

  System.out.println("請輸入一個算術表示式以#結尾");
  String evalueExpression=sc.nextLine();
  System.out.println(getResult(evalueExpression));

請輸入一個算術表示式以#結尾
3*(3+2/4)+9*6/2#
37.5