關於棧與隊列
棧與隊列是特殊的線性表。
訪問，插入，刪除等操作只能在棧頂進行；對於隊列，元素只能從隊尾插入，從隊頭刪除和訪問。
換句話說，棧和隊列是有操作限制的線性表。
順序存儲的棧稱為順序棧；鏈式存儲的棧稱為鏈式棧。
基於數組實現棧
package com.company;
public class StackOperation<T> {
private T data[];
private int maxSize;
private int top;
//初始化棧
public StackOperation(int maxSize) {
this.maxSize=maxSize;
data=(T[])new Object[maxSize]; //泛型數組不能直接new創建，需要使用Object來創建
this.top=-1;
}
//判斷棧是否為空
public boolean isEmpty() {
return (top==-1);
}
//判斷棧是否已經滿了
public boolean isFull() {
return (top==maxSize-1);
}
//壓棧
public boolean push(T value) {
if(isFull()) {
return false;
}
top++;
data[top]=value;
return true;
}
//取出棧頂元素
public T pop() {
if(isEmpty()) {
return null;
}
T tmp=data[top];
data[top]=null;
top--;
return tmp;
}
//============測試代碼============
public static void main(String[] args) {
StackOperation<String> stackOperation=new StackOperation<String>(10);
stackOperation.push("AAA");
stackOperation.push("BBB");
stackOperation.push("CCC");
stackOperation.push("DDD");
stackOperation.push("EEE");
stackOperation.push("XXX");
stackOperation.push("YYY");
stackOperation.push("ZZZ");
while(!stackOperation.isEmpty())
{
System.out.println(stackOperation.pop());
}
}
}
基於鏈表實現棧
package com.company;
class Node<T>{
protected T data;//數據
private Node<T> next;//指向下一個節點的指針
//初始化鏈表
public Node(T data) {
this.data=data;
}
//獲取下一個節點
public Node<T> getNext(){
return this.next;
}
//設置下一個節點
public void setNext(Node<T> n) {
this.next=n;
}
//獲取節點數據
public T getData() {
return this.data;
}
//設置節點數據
public void setData(T d) {
this.data=d;
}
@Override
public String toString() {
return "Node{" +
"data=" + data +
", next=" + next +
'}';
}
}
public class NodeStack<T> {
private Node<T> top=null;//棧頂
public NodeStack() {
this.top=null;
}
//判斷棧是否為空
public boolean isEmpty() {
if(top!=null) {
return false;
}
return true;
}
//壓棧
public boolean push(T value) {
Node<T> node=new Node<T>(value);
node.setNext(top);
top=node;
return true;
}
//出棧
public T pop() {
if(top==null) {
return null;
}
T tmp=top.data;
top=top.getNext();
return tmp;
}
//取出棧頂的值
public T peek() {
if(isEmpty()) {
return null;
}
return top.data;
}
public static void main(String[] args) {
System.out.println("實例化一個棧：");
NodeStack<String> ns=new NodeStack<String>();
System.out.println("判斷是否為空："+ns.isEmpty());
System.out.println();
System.out.println("開始壓棧：");
ns.push("AAA");
ns.push("BBB");
ns.push("CCC");
ns.push("DDD");
System.out.println("判斷是否為空："+ns.isEmpty());
System.out.println();
System.out.println("開始出棧：");
System.out.println(ns.pop());
System.out.println(ns.pop());
System.out.println(ns.pop());
System.out.println(ns.pop());
}
}
基於數組實現隊列
package com.company;
public class QueueOperation<T> {
private T data[];
private int front=0;//隊列頭
private int rear=0;//隊列尾
private int size;//隊列大小
public QueueOperation(int size) {
this.size = size;
data = (T[])new Object[size];
}
/**
* 是否為空隊列
* @return
*/
public boolean isEmpty(){
return front == rear;
}
/**
* 入隊
* @param value
*/
public void in(T value) throws Exception {
if(rear == size){
throw new Exception("隊列已滿異常");
}
data[rear ++] = value;
}
/**
* 出隊
*/
public Object out() throws Exception {
if(isEmpty()){
throw new Exception("空隊列異常");
}
T value = data[front];
data[front++] = null;
return value;
}
public static void main(String[] args) throws Exception {
QueueOperation<String> queueOperation= new QueueOperation<>(10);
queueOperation.in("AAA");
queueOperation.in("BBB");
queueOperation.in("CCC");
queueOperation.in("DDD");
queueOperation.in("EEE");
queueOperation.in("XXX");
queueOperation.in("YYY");
queueOperation.in("ZZZ");
while (!queueOperation.isEmpty())
{
System.out.println(queueOperation.out());
}
}
}
基於鏈表實現隊列
package com.company;
class Node<T> {
// 存儲的數據
private T data;
// 下一個節點的引用
private Node<T> next;
public Node(T data) {
this.data = data;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public Node<T> getNext() {
return next;
}
public void setNext(Node<T> next) {
this.next = next;
}
}
public class LinkQueue<T> {
// 隊頭
private Node<T> front;
// 隊尾
private Node<T> rear;
// 元素個數
private int size;
/**
* 初始化
*/
public LinkQueue() {
rear = front = null;
}
/**
* 入隊
* @param data
*/
public void in(T data) {
Node<T> node = new Node<T>(data);
if (isEmputy()) {
front = rear = node;
} else {
rear.setNext(node);
rear = node;
}
size++;
}
/**
* 出隊
*/
public T out() {
if (isEmputy()) {
throw new RuntimeException("隊列為空");
}
Node<T> delete = front;
front = delete.getNext();
delete.setNext(null);;
size--;
if (size == 0) {
// 刪除掉最后一個元素時，front值已經為null，但rear還是指向該節點，需要將rear置為null
// 最后一個結點front和rear兩個引用都沒指向它，幫助GC處理該節點對象
rear = front;
}
return (T) delete.getData();
}
/**
* 判斷隊列是否為空
* @return
*/
public boolean isEmputy() {
return (front == null && rear == null) ? true : false;
}
/**
* 獲取隊列的元素個數
* @return
*/
public int size() {
return this.size;
}
public static void main(String[] args) {
LinkQueue<String> linkQueue = new LinkQueue<>();
linkQueue.in("AAA");
linkQueue.in("BBB");
linkQueue.in("CCC");
linkQueue.in("DDD");
while (!linkQueue.isEmputy())
{
System.out.println(linkQueue.out());
}
}
}