栈和队列的Java实现

一、  栈

1、概念

栈是一种特殊的线性表，它只能在栈顶(top)进行插入(push)和删除(pop)操作。

　　栈的常用操作：

　　　　入栈(push)：向栈顶插入元素

　　　　出栈(pop):从栈顶删除元素

　　　　访问栈顶元素(peek)：访问栈顶元素

2、 栈的顺序结构的实现

 public class SequenceStack<T> {

     private Object[] elementData; //数组用于承装元素
     private int DEFAULT_SIZE = 20; //初始数组默认大小
     private int capacity;
     private int capacityIncrement = 5;
     private int size = 0; //栈中当前容量
     public SequenceStack(){
         capacity = DEFAULT_SIZE;
         elementData = new Object[capacity];
     }
     public SequenceStack(T element){
         this();
         elementData[0] = element;
         size++;
     }
     //返回栈的长度
     public int length(){
         return this.size;
     }

     //入栈操作
     public void push(T element){
         this.ensureCapacity();
         elementData[size] = element;
         size++;
     }

     //出栈操作
     public T pop(){
         T popElement = (T)elementData[size-1];
         size--;
         return popElement;
     }

     //访问栈顶元素
     public T peek(){
         return (T)elementData[size-1];
     }

     //判断是否为空
     public boolean isEmpty(){
         boolean b = false;
         if(size == 0){
             b = true;
         }
         return b;
     }

     //清空栈
     public void clear(){
         for(Object o:elementData){
             o = null;
         }
         size = 0;
     }

     //遍历栈
     public void view(){
         System.out.print("当前栈中元素为：");
         for(int i = 0;i < size;i++){
             System.out.print(elementData[i] + " ");
         }
         System.out.println();
     }

     //栈容量检测与扩充
     public void ensureCapacity(){
         if(capacityIncrement > 0){
             while((size+1) > capacity){
                 capacity+=capacityIncrement;
             }
         }
         else{
             while((size+1) > capacity){
                 capacity = capacity * 2;
             }
         }
     }

     public static void main(String[] args) {
         SequenceStack<String> sequenceStack = new SequenceStack<> ();
         sequenceStack.push("hello");
         sequenceStack.push("world");
         sequenceStack.push("perfect");
         System.out.print("入栈操作后，");
         sequenceStack.view();
         sequenceStack.pop();
         System.out.print("出栈操作后，");
         sequenceStack.view();
         System.out.println("当前栈顶元素为：" + sequenceStack.peek());
         sequenceStack.clear();
         System.out.println("clear之后，栈是否为空：" + sequenceStack.isEmpty());
     }
 }

3、栈的链式结构的实现：

 public class LinkedStack<T> {

     private class Node{
         private T data;
         private Node next;
         public Node(){

         }
         public Node(T element,Node next){
             this.data = element;
             this.next = next;
         }
     }

     private Node top;
     private int size = 0;

     public LinkedStack(){

     } 

     public LinkedStack(T element){
         top = new Node(element,null);
         size++;
     }
     //获取栈大小
     public int length(){
         return size;
     }
     //入栈操作
     public void push(T element){
         Node newNode;
         newNode = new Node(element, top);
         top = newNode;
         size++;
     }
     //出栈操作
     public T pop(){
         Node oldNode = top;
         top = top.next;
         oldNode.next = null;
         size--;
         return oldNode.data;
     }

     //获取栈顶元素
     public T peek(){
         return top.data;
     }

     //清空栈
     public void clear(){
         top = null;
         size = 0;
     }

     public boolean isEmpty(){
         if(size == 0){
             return true;
         }
         return false;
     }

     //遍历栈中元素
     public void view(){
         Node currentNode = top;
         System.out.print("栈中元素为：");
         while(currentNode != null){
             System.out.print(currentNode.data + " ");
             currentNode = currentNode.next;
         }
         System.out.println();
     }

     public static void main(String[] args) {
         LinkedStack<String> linkedStack = new LinkedStack<>();
         linkedStack.push("hello");
         linkedStack.push("world");
         linkedStack.push("perfect");
         System.out.print("入栈操作后，");
         linkedStack.view();
         linkedStack.pop();
         System.out.print("出栈操作后，");
         linkedStack.view();
         System.out.println("当前栈顶元素为：" + linkedStack.peek());
         linkedStack.clear();
         System.out.println("clear之后，栈是否为空：" + linkedStack.isEmpty());
     }
 }

三、               队列

1、概念

队列是一种被限制的线性表，它只允许在表的前端(front，即队尾)进行删除操作，只允许在表的后端(rear，即队头)进行插入操作

常用操作：

　　加入元素：向队列rear端插入元素

　　删除元素：从队列的front端删除元素

　　访问队列front端元素：

2、队列的顺序存储结构及实现

 public class SequenceQueue<T> {

     private int DEFAULT_SIZE = 20;
     private int capacity;
     private int front = 0;
     private int rear = 0;
     private Object[] elementData;
     public SequenceQueue(){
         capacity = DEFAULT_SIZE;
         elementData = new Object[capacity];
     }
     public SequenceQueue(T element){
         this();
         elementData[0] = element;
         rear++;
     }
     // 获取队列长度
     public int length(){
         return rear-front;
     }

     //向队列尾添加元素
     public void add(T element){
         if(rear > capacity-1){
             throw new IndexOutOfBoundsException("队列已满");
         }
         elementData[rear++] = element;
     }

     //删除队列头元素
     public T remove(){
         if((rear-front) == 0){
             throw new IndexOutOfBoundsException("队列为空，不能删除");
         }
         T remove = (T)elementData[front];
         elementData[front++] = null;
         return remove;
     }

     //获取队列头部元素
     public T getElement(){
         return (T)elementData[front];
     }

     //判断队列是否为空
     public boolean isEmpty(){
         return (rear-front) == 0;
     }

     //清空队列
     public void clear(){
         Arrays.fill(elementData, null);
         front = 0;
         rear = 0;
     }

     //遍历队列
     public void view(){
         System.out.print("队列中元素为：");
         for(int i = front;i < rear; i++){
             System.out.print(elementData[i] + " ");
         }
         System.out.println();
     }

     public static void main(String[] args) {
         SequenceQueue<String> sequenceQueue = new SequenceQueue<> ();
         sequenceQueue.add("hello");
         sequenceQueue.add("world");
         sequenceQueue.add("perfect");
         sequenceQueue.view();
         System.out.println("执行remove删除的元素为：" + sequenceQueue.remove());
         System.out.println("队列头部元素为：" + sequenceQueue.getElement());
         sequenceQueue.clear();
         System.out.println("clear之后队列长度：" + sequenceQueue.length());

     }

 }

3、顺序存储结构的循环队列

 public class LoopSequenceQueue<T> {

     private int DEFAULT_SIZE = 5;
     private int capacity;
     private int front = 0;
     private int rear = 0;
     private Object[] elementData;

     public LoopSequenceQueue(){
         capacity = DEFAULT_SIZE;
         elementData = new Object[capacity];
     }

     public LoopSequenceQueue(T element){
         this();
         elementData[0] = element;
         rear++;
     }

     //获取队列长度
     public int length(){
         if(isEmpty()){
             return 0;
         }
         return rear > front?rear-front:(capacity-(front-rear));
     }

     //向队列中插入元素
     public void add(T element){
         if(rear == front && elementData[front] != null){
             throw new IndexOutOfBoundsException("队列已满");
         }
         elementData[rear] = element;
         rear = (rear+1) > (capacity-1)?0:(++rear);
     }

     //从队列头删除元素
     public T delete(){
         if(isEmpty()){
             throw new IndexOutOfBoundsException("队列为空");
         }
         T del = (T)elementData[front];
         elementData[front] = null;
         front = (front+1) > capacity?0:++front;
         return del;
     }

     //清空队列
     public void clear(){
         Arrays.fill(elementData, null);
         front = 0;
         rear = 0;
     }

     //遍历队列
     public void view(){
         System.out.print("队列中元素为：");
         if(front < rear){
             for(int i = front;i < rear;i++){
                 System.out.print(elementData[i] + " ");
             }
         }
         else{
             for(int i = front;i < capacity;i++)
                 System.out.print(elementData[i] + " ");
             for(int i = 0;i < rear;i++)
                 System.out.print(elementData[i] + " ");
         }
     }

     //判断队列是否为空
     public boolean isEmpty(){
         if(front == rear && elementData[front] == null){
             return true;
         }
         return false;
     }

     public static void main(String[] args) {
         LoopSequenceQueue<String> loopSequenceQueue = new LoopSequenceQueue<>();
         loopSequenceQueue.add("hello");
         loopSequenceQueue.add("world");
         loopSequenceQueue.add("perfect");
         loopSequenceQueue.add("3333333");
         loopSequenceQueue.delete();
         loopSequenceQueue.add("4444444444");
         loopSequenceQueue.add("555555555");
         loopSequenceQueue.view();
         System.out.println("当前队列长度为：" + loopSequenceQueue.length());

     }

 }

4、队列的链式存储结构

 public class LinkedQueue<T> {

     private class Node{
         private T data;
         private Node next;
         public Node(){

         }

         public Node(T element,Node next){
             this.data = element;
             this.next = next;
         }
     }

     private Node front;
     private Node rear;
     private int size = 0;
     public LinkedQueue(){
         this.front = null;
         this.rear = null;
     }

     public LinkedQueue(T element){
         rear = new Node(element,null);
         front = rear;
         size++;
     }
     //获取队列长度
     public int length(){
         return size;
     }

     //从队尾插入元素
     public void add(T element){
         Node newNode = new Node(element,null);
         if(rear == null){
             rear = newNode;
             front = rear;
         }
         else{
             rear.next = newNode;
             rear = newNode;
         }

         size++;
     }
     //删除队头元素
     public T remove(){
         if(size == 0){
             throw new IndexOutOfBoundsException("队列为空，不能删除");
         }
         Node delNode = front;
         front = front.next;
         delNode.next = null;
         size--;
         return delNode.data;
     }

     //清空队列
     public void clear(){
         front = null;
         rear = null;
         size = 0;
     }

     //遍历队列元素
     public void view(){
         System.out.print("队列中元素为：");
         Node currentNode = front;
         while(currentNode != null){
             System.out.print(currentNode.data + " ");
             currentNode = currentNode.next;
         }
         System.out.println();
     }

     public static void main(String[] args) {
         LinkedQueue<String> linkedQueue = new LinkedQueue<> ();
         linkedQueue.add("hello");
         linkedQueue.add("world");
         linkedQueue.add("perfect");
         linkedQueue.add("3333333");
         linkedQueue.remove();
         linkedQueue.add("4444444444");
         linkedQueue.add("555555555");
         linkedQueue.view();
         System.out.println("当前队列长度为：" + linkedQueue.length());

     }

 }

注：本文部分内容参考自《疯狂Java程序员的基本修养》