大话数据结构----栈

Posted Actexpler

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了大话数据结构----栈相关的知识,希望对你有一定的参考价值。

栈的定义:

栈(stack)是限定尽在表尾进行插入和删除操作的线性表。

从定义中可以看出,栈也是线性表,是一个特殊的线性表,之前说线性的表的时候,线性表可以在任意位置进行插入插入,而栈比线性表特殊的地方的就是不能随意的插入和删除了,栈的插入和删除只能在规定的同一端进行,而被允许插入和删除的一端称为栈顶,另一端称为栈底。

栈

从栈的特性中我们能发现:1).栈是一种后进先出的线性表,因为栈只有一个出入口,每次出栈是最后进的那个先出去,后一个才能出去,就像我们出电梯一样,里面的人被阻住,只有外面的人出去,里面的人才能出去。

2)栈的栈顶是在变化的,所以栈还得有一个栈顶指针,新元素入栈的后,栈顶指针要指向新栈顶,栈顶栈顶元素出栈时,栈顶指针也是需要变化指向新的栈顶

栈的 三种状态-----栈空、栈满、栈未满

栈的三种状态

栈空时:栈顶指针(top)=-1

栈满时:栈顶指针(top)=MAXSIZE-1;

栈未满:就是占中存在元素,top指针还未达到MAXSIZE-1.

进栈和出栈操作

进栈

进栈

1).判断栈是否已经满了,如果满了当然就入不了栈。

2)、栈顶指针+1,在新栈顶位置存入要进栈的元素。

 

出栈:

出栈

1).判断栈是否为空,里面没有数据先出栈也没有。

2).将栈顶元素出栈,栈顶指针-1.

Java 实现栈的基本操作

package JavaStack;
import javax.swing.table.TableColumn;

/* 
* 项目名称:JavaStack 
* @author:wzc
* @date 创建时间:2017年9月10日 下午2:22:08
* @Description:数据结构----栈
* @parameter  
*   */
public class Stack<T> {
   public static final int MAXSIZE=10;
private static final int T = 0;
   private T [] date=(T[])new Object[MAXSIZE];
   int top;
   public Stack() {
    top=-1;
   }
   //判断栈是否为空
   public boolean isEmpty(){
       if (top==-1) {
        return true;
       }
        return false;
   }
   //判断栈是否满
   public boolean isFull(){
       if (top==MAXSIZE-1) {
        return true;
    }
       return false;
   }
   /*Method:push
     *Description:入栈操作
     *param:T date  入栈的数据元素
     */
   public void push(T date){
       //1.入栈之前判断是否栈满
       if (isFull()) {
           System.out.println("栈已经满了");
           return;
       }
       top=top+1;
       this.date[top]=date;
       System.out.println(date+"已经入栈");
   }
   /*Method:enclosing_method
     *Description:出栈操作
     *param:
     */
   public T pop(){
       //出栈之前判断呢栈是否为空
       if (isEmpty()) {
        System.out.println("栈为空,无可出栈数据");
        return null;
      }
       T date= this.date[top];
       top=top-1;
       return date;  
   }
   //输出栈 中有多少元素
   public int getLength(){
       return top+1;
   }
   //输出栈中所有元素
   public void getDate(){
       for(int  i=0;i<=top;i++){
           System.out.print(date[i]+" ");
       }
       System.out.println();
   }
   
}

测试一下:

@Test
    public void test() {
        Stack <Integer> stack=new Stack<>();
        int length = stack.getLength();
        System.out.println("栈长:"+length);
        stack.push(2);
        System.out.println("栈长"+stack.getLength());
        stack.push(5);
        stack.push(9);
        System.out.println("栈长"+stack.getLength());
        stack.getDate();
        Integer pop = stack.pop();
        System.out.println(pop+"出栈");
        System.out.println("栈长"+stack.getLength());
        stack.getDate();
        stack.pop();
        stack.pop();
        System.out.println("栈长"+stack.getLength());
        stack.getDate();
        stack.pop();
    }

测试结果::

结果‘

共享栈

共享栈

共享栈 是开辟一块内存空间,两个栈结构共用这一块内存空间,每个栈占领这块空间的一头。

要求:两个栈的数据类型要相同。

栈满:判断栈满的条件是----top1+1=top2

栈满

栈空: 1.第一个栈空的条件:top=-1

          2.第二个栈空的 条件:top2=MAXSIZE

 

在两个栈对于空间需求相反的时候,利用共享栈可以有效的节约空间。

package JavaStack;
/* 
* 项目名称:JavaStack 
* @author:wzc
* @date 创建时间:2017年9月10日 下午3:07:28
* @Description:共享栈
* @parameter  
*   */
public class DoubleStack<T> {
    public static final int MAXSIZE=10;
    private T [] date=(T[])new Object[MAXSIZE];
    int top1;
    int top2;
    public DoubleStack() {
        top1=-1;
        top2=MAXSIZE;
    }
     //判断栈1是否为空
       public boolean isEmpty1(){
           if (top1==-1) {
            return true;
           }
            return false;
       }
       //判断栈2是否为空
       public boolean isEmpty2(){
           if (top2==MAXSIZE) {
            return true;
           }
            return false;
       }
       //判断栈是否满
       public boolean isFull(){
           if (top1+1==top2) {
            return true;
        }
           return false;
       }
       /*Method:push
         *Description:入栈操作
         *param:T date  入栈的数据元素,StackNum   哪个栈
         */
       public void push(T date,int StackNum){
           //1.入栈之前判断是否栈满
           if (isFull()) {
               System.out.println("栈已经满了");
               return;
           }
           if (StackNum==1) {
               top1=top1+1;
               this.date[top1]=date;
               System.out.println(date+"已经入栈");
           }else if (StackNum==2) {
               top2=top2-1;
               this.date[top2]=date;
               System.out.println(date+"已经入栈");
           }
           
       }
       /*Method:enclosing_method
         *Description:出栈操作
         *param:StackNum ,哪个栈
         */
       public T pop(int StackNum){
           //第一个栈出栈
           if (StackNum==1) {
             //出栈之前判断呢栈是否为空
               if (isEmpty1()) {
                    System.out.println("栈为空,无可出栈数据");
                    return null;
                  }
                   T date= this.date[top1];
                   top1=top1-1;
                   return date;  
           }else   if (StackNum==2) {//第二个栈出栈
             //出栈之前判断呢栈是否为空
               if (isEmpty2()) {
                    System.out.println("栈为空,无可出栈数据");
                    return null;
                  }
                   T date= this.date[top2];
                   top2=top2+1;
                   return date;  
           }
           //栈错误
           return null;
          
       }
       
       
       
}

栈的链式存储结构

链式

利用单链表的思想,栈中元素在内存中的存储位置是随机的,只需要它的前驱能找到就行,然后对数据的操作仍然是从栈顶操作,依旧是后进先出。

对于进栈、出栈的实现思想还是一样。

入栈:

入栈2

1.入栈元素的指针域指向当前栈顶指针top指向的元素。

2.top指针+1,指向新的栈顶元素。

出栈

出栈2

1.将出栈元素出栈;

2.将top指针-1,指向下一个元素;

package JavaStack;
/* 
* 项目名称:JavaStack 
* @author:wzc
* @date 创建时间:2017年9月10日 下午3:26:54
* @Description:链式存储栈结构
* @parameter  
*   */
public class LinkStack <T>{
    
    private class StackNode{
        T date;
        StackNode next;
    }
    private  StackNode top;
    private  int count;
    public LinkStack() {
        count =0;
        top=null;
    }
    //判读是否为空
    public boolean isEmpty(){
        if (count==0) {
            return true;
        }
        return false;
    }
    /*Method:push
     *Description:入栈操作
     *param:date 入栈元素
     */
    public void push(T date){
        StackNode newNode=new StackNode();
        newNode.date=date;
        newNode.next=top;
        top=newNode;
        count++;
        System.out.println(date+"入栈");
    }
    /*Method:pop
     *Description:出栈操作
     *param:
     */
    public T pop(){
        if (isEmpty()) {
            return null;
        }
        StackNode date=top;
        top=top.next;
        date.next=null;
        System.out.println(date.date+"出栈");
        return  date.date;
    }
    
    public void getDate(){
        StackNode tmp=top;
        while(tmp!=null){
            System.out.print(tmp.date+" ");
            tmp=tmp.next;
        }
        System.out.println();
    }
   
}

以上是关于大话数据结构----栈的主要内容,如果未能解决你的问题,请参考以下文章

大话数据结构——栈

大话数据结构----栈

大话数据结构 栈与队列

Java 大话数据结构 线性表之栈

大话数据结构4之栈与队列

2 链式存储栈