栈的实现(JAVA)

Posted 小人物702

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了栈的实现(JAVA)相关的知识，希望对你有一定的参考价值。

  栈定义

                    栈(stack):是一种特殊的串行形式的数据结构，其特殊之处在于只允许在链接串行或者阵列的

              一端进行插入、删除操作。其实现方式可以通过一维阵列和链接串行来实现。

                   Tips：简单的来说栈其实也是一种操作受限的线性表。是一种后进先出的数据结构可以使用数

                               组或者链表的形式来实现。

                    栈的操作表现形式:

                            技术分享

        栈实现

                     知道了栈的定义，我们来看看栈的实现吧。首先我们需要明白的的是栈具有哪些操作。

                通过一个接口定义其操作。       

[java] view plain copy
 
  1. package com.kiritor;  
  2. /** 
  3.  * 栈操作定义 
  4.  * @author Kiritor*/  
  5. public interface Stack<T> {  
  6.     /*判空*/  
  7.     boolean isEmpty();  
  8.     /*清空栈*/  
  9.     void clear();  
  10.     /*弹栈*/  
  11.     T pop();  
  12.     /*入栈*/  
  13.     boolean push(T data);  
  14.     /*栈的长度*/  
  15.     int length();  
  16.     /*查看栈顶的元素，但不移除它*/  
  17.     T peek();  
  18.     /*返回对象在栈中的位置*/  
  19.     int search(T t);  
  20. }  

 

           栈的数组实现

                     栈的数组实现，底层使用数组             

[java] view plain copy
 
  1. package com.kiritor;  
  2. /** 
  3.  * 栈的数组实现 
  4.  * @author Kiritor*/  
  5. public class ArrayStack<T> implements Stack<T>{  
  6.       
  7.     private T[] t = (T[]) new Object[16];//栈空间默认为16  
  8.     private int size = 0;  
  9.     @Override  
  10.     public boolean isEmpty() {  
  11.         return size==0;  
  12.     }  
  13.   
  14.     @Override  
  15.     public void clear() {  
  16.         for(int i = 0;i<t.length;i++)  
  17.             t[i]=null;//将其引用只为null，方便gc进行回收  
  18.         size = 0;//栈的大小置0  
  19.     }  
  20.   
  21.     /*弹栈操作*/  
  22.     @Override  
  23.     public T pop() {  
  24.         if(size==0)  
  25.            return null;  
  26.         else  
  27.         {  
  28.             T tmp = t[size-1];  
  29.             t[size-1]=null;//便于gc回收  
  30.             size--;  
  31.             return tmp;  
  32.         }  
  33.     }  
  34.   
  35.     @Override  
  36.     public boolean push(T data) {  
  37.         if(size>=t.length)  
  38.         {  
  39.             //栈空间已满，需要扩容  
  40.             resize();  
  41.         }  
  42.         t[size++]=data;  
  43.         return true;  
  44.     }  
  45.   
  46.     public void resize()  
  47.     {  
  48.         T[] tmp = (T[]) new Object[t.length*2];  
  49.         for(int i = 0;i<t.length;i++){  
  50.             tmp[i]=t[i];  
  51.             t[i]=null;//便于gc处理  
  52.         }  
  53.         t = tmp;  
  54.         tmp = null;//便于gc处理，提高程序效率  
  55.     }  
  56.     @Override  
  57.     public int length() {  
  58.         return size;  
  59.     }  
  60.   
  61.     /*查看栈顶元素，但是并不删除*/  
  62.     @Override  
  63.     public T peek() {  
  64.         if(size==0)  
  65.                return null;  
  66.             else  
  67.             {  
  68.                 return t[size-1];  
  69.             }  
  70.     }  
  71.     /*下表从1开始*/  
  72.     @Override  
  73.     public int search(T t) {  
  74.         for(int i= 0;i<size;i++)  
  75.             if(t.equals(this.t[i]))  
  76.                 return i+1;  
  77.         return 0;  
  78.     }  
  79.       
  80.     @Override  
  81.     public String toString() {  
  82.          StringBuilder sb = new StringBuilder();    
  83.             sb.append("ArrayStack:\n[\n");    
  84.             for (int i = size-1; i >=0; i--) {    
  85.                 sb.append("   "+t[i].toString());    
  86.                 if (i != size + 1) {    
  87.                     sb.append("\n");    
  88.                 }    
  89.             }    
  90.             sb.append("]");    
  91.             return sb.toString();    
  92.     }  
  93.       
  94.     
  95. }  

                 测试代码：

[java] view plain copy
 
  1. public static void main(String[] args) {  
  2.         ArrayStack<String> arrayStack = new ArrayStack<>();  
  3.         arrayStack.push("C语言");  
  4.         arrayStack.push("C++");  
  5.         arrayStack.push("JAVA");  
  6.         arrayStack.push("数据结构");  
  7.         arrayStack.pop();  
  8.         arrayStack.peek();  
  9.         arrayStack.pop();  
  10.         System.out.println(arrayStack.toString());  
  11.     }  

              输出结果：

 

                      技术分享

           栈的链表实现

             

[java] view plain copy
 
  1. package com.kiritor;  
  2. /** 
  3.  * 栈的链表实现 
  4.  * @author Kiritor*/  
  5. public class LinkStack<T> implements Stack<T>{  
  6.       
  7.     /*将数据封装成结点*/  
  8.     class Node  
  9.     {  
  10.         private Node pre;  
  11.         private T data;  
  12.     }  
  13.       
  14.     /*栈顶指针*/  
  15.     private Node top;  
  16.     private int size;//栈的大小  
  17.     public LinkStack() {  
  18.         this.top = null;  
  19.         this.size = 0;  
  20.     }  
  21.     @Override  
  22.     public boolean isEmpty() {  
  23.         return size==0;  
  24.     }  
  25.   
  26.     @Override  
  27.     public void clear() {  
  28.         top = null;  
  29.         size = 0;  
  30.           
  31.     }  
  32.   
  33.     @Override  
  34.     public T pop() {  
  35.         if (top != null) {    
  36.             T t = top.data;  
  37.             // 改变栈顶指针    
  38.             top = top.pre;    
  39.             size--;    
  40.             return t;    
  41.         }    
  42.         return null;   
  43.     }  
  44.   
  45.     @Override  
  46.     public boolean push(T data) {  
  47.          Node node = new Node();    
  48.          node.data = data;    
  49.          node.pre = top;    
  50.             // 改变栈顶指针    
  51.         top = node;    
  52.         size++;    
  53.         return true;    
  54.     }  
  55.   
  56.     @Override  
  57.     public int length() {  
  58.         return size;  
  59.     }  
  60.   
  61.     @Override  
  62.     public T peek() {  
  63.         return top.data;  
  64.     }  
  65.      /*下表从1开始*/  
  66.     @Override  
  67.     public int search(T t) {  
  68.         int count=0;  
  69.         for(Node node= top;node.pre!=null;node = node.pre)  
  70.         {  
  71.             count++;  
  72.             if(t.equals(node.data))  
  73.                 return size - count;  
  74.         }  
  75.         return 0;  
  76.     }  
  77.     @Override  
  78.     public String toString() {  
  79.          StringBuilder sb = new StringBuilder();    
  80.             sb.append("LinkStack:"+length()+"\n[\n");    
  81.             int count=0;  
  82.             for (Node node = top;node!=null;node=node.pre) {    
  83.                 count++;  
  84.                 sb.append("   "+node.data.toString());    
  85.                 if (count != size + 1) {    
  86.                     sb.append("\n");    
  87.                 }    
  88.             }    
  89.             sb.append("]");   
  90.             System.out.println(count);  
  91.             return sb.toString();    
  92.     }  
  93.   
  94.       
  95. }  

                测试代码：

[java] view plain copy
 
  1. public static void main(String[] args) {  
  2.      LinkStack<String> arrayStack = new LinkStack<>();  
  3.         arrayStack.push("C语言");  
  4.         arrayStack.push("C++");  
  5.         arrayStack.push("JAVA");  
  6.         arrayStack.push("数据结构");  
  7.           
  8.         System.out.println(arrayStack.toString());  
  9. }  

                       结果就不贴出了
                       因为栈操作的特殊性，一般来说以数组方式实现的栈的效率是要高于链表实现的，

 

                  原因在于：其一数组的访问更快。其二由于只在栈顶进行操作并未涉及太大的元素移动

                  但是使用链式实现将数据包装成Node，在从其中取数据，还的维护栈顶指针和前驱指针。

以上是关于栈的实现(JAVA)的主要内容，如果未能解决你的问题，请参考以下文章

java Stack(栈)

Java实现栈的顺序存储

Java中有没有像C++中那种包含一个栈的头文件< stack >就可以用栈的一些出栈入栈的函数的做法？

算法Java手写实现栈

算法Java手写实现栈

数据结构（Java语言）——Stack简单实现