Java实现栈和队列

* top:栈顶指针，初始化top=-1
* 入栈：data[++top]=e
* 出栈：(E)data[top--]
* 得到栈顶元素：(E)data[top]
* 空：top=-1

 1 package com.myutil.stack;
 2 
 3 /**
 4  * 基于数组实现的顺序栈
 5  * @param <E>
 6  * 
 7  * top:栈顶指针，初始化top=-1
 8  * 入栈：data[++top]=e
 9  * 出栈：(E)data[top--]
10  * 得到栈顶元素：(E)data[top]
11  * 空：top=-1
12  */
13 public class Stack<E> {
14     private Object[] data = null;
15     private int maxSize=0;   //栈容量
16     private int top =-1;  //栈顶指针
17     
18     /**
19      * 构造函数：根据给定的size初始化栈
20      */
21     Stack(){
22         this(10);   //默认栈大小为10
23     }
24     
25     Stack(int initialSize){
26         if(initialSize >=0){
27             this.maxSize = initialSize;
28             data = new Object[initialSize];
29             top = -1;
30         }else{
31             throw new RuntimeException("初始化大小不能小于0：" + initialSize);
32         }
33     }
34     
35     
36     
37     //进栈,第一个元素top=0；
38     public boolean push(E e){
39         if(top == maxSize -1){
40             throw new RuntimeException("栈已满，无法将元素入栈！");
41         }else{
42             data[++top]=e;
43             return true;
44         }    
45     }
46     
47     //查看栈顶元素但不移除
48     public E peek(){
49         if(top == -1){
50             throw new RuntimeException("栈为空！");
51         }else{
52             return (E)data[top];
53         }
54     }
55     
56     //弹出栈顶元素
57     public E pop(){
58         if(top == -1){
59             throw new RuntimeException("栈为空！");
60         }else{
61             return (E)data[top--];
62         }
63     }
64     
65     //判空
66     public boolean empty(){
67         return top==-1 ? true : false;
68     }
69     
70     //返回对象在堆栈中的位置，以 1 为基数
71     public int search(E e){
72         int i=top;
73         while(top != -1){
74             if(peek() != e){
75                 top --;
76             }else{
77                 break;
78             }
79         }
80         int result = top+1;
81         top = i;
82         return result;      
83     }
84     
85     public static void main(String[] args) {
86         Stack<Integer> stack=new Stack<>();
87         for (int i = 0; i < 5; i++) {
88             stack.push(i);
89         }
90         for (int i = 0; i < 5; i++) {
91             System.out.print(stack.pop()+" ");
92         }
93     }
94 }

 1 package com.myutil.stack;
 2 
 3 public class LinkStack<E> {
 4     //链栈的节点
 5     private class Node<E>{
 6         E e;
 7         Node<E> next;
 8         
 9         public Node(){}
10         public Node(E e, Node next){
11             this.e = e;
12             this.next = next;
13         }
14     }
15     
16     private Node<E> top;   //栈顶元素
17     private int size;  //当前栈大小
18     
19     public LinkStack(){
20         top = null;
21     }
22     
23     
24     
25     //入栈：让top指向新创建的元素，新元素的next引用指向原来的栈顶元素
26     public boolean push(E e){
27         top = new Node(e,top);
28         size ++;
29         return true;
30     }
31     
32     //查看栈顶元素但不删除
33     public Node<E> peek(){
34         if(empty()){
35             throw new RuntimeException("空栈异常！");
36         }else{
37             return top;
38         }
39     }
40     
41     //出栈
42     public Node<E> pop(){
43         if(empty()){
44             throw new RuntimeException("空栈异常！");
45         }else{
46             Node<E> value = top; //得到栈顶元素
47             top = top.next; //让top引用指向原栈顶元素的下一个元素 
48             value.next = null;  //释放原栈顶元素的next引用
49             size --;
50             return value;
51         }
52     }
53     
54   //当前栈大小
55     public int length(){
56         return size;
57     }
58     
59     //判空
60     public boolean empty(){
61         return size==0;
62     }
63     
64     public static void main(String[] args) {
65         LinkStack<Integer> stack=new LinkStack<>();
66         for (int i = 0; i < 5; i++) {
67             stack.push(i);
68         }
69         for (int i = 0; i < 5; i++) {
70             System.out.print(stack.pop().e+" ");
71         }
72     }
73 }

 * push-----addFirst()
 * pop------removeFirst()
 * peek-----getFirst()
 * empty----isEmpty()

 1 package com.myutil.stack;
 2 
 3 import java.util.LinkedList;
 4 
 5 /**
 6  * 基于LinkedList实现栈
 7  * 在LinkedList实力中只选择部分基于栈实现的接口
 8  * 
 9  * push-----addFirst()
10  * pop------removeFirst()
11  * peek-----getFirst()
12  * empty----isEmpty()
13  */
14 public class StackList<E> {
15     private LinkedList<E> ll = new LinkedList<E>();
16     
17     //入栈
18     public void push(E e){
19         ll.addFirst(e);
20     }
21     
22     //查看栈顶元素但不移除
23     public E peek(){
24         return ll.getFirst();
25     }
26     
27     //出栈
28     public E pop(){
29         return ll.removeFirst();
30     }
31     
32     //判空
33     public boolean empty(){
34         return ll.isEmpty();
35     }
36     
37     //打印栈元素
38     public String toString(){
39         return ll.toString();
40     }
41     
42     public static void main(String[] args) {
43         StackList<Integer> stack=new StackList<>();
44         for (int i = 0; i < 5; i++) {
45             stack.push(i);
46         }
47         System.out.println(stack.toString());
48         for (int i = 0; i < 5; i++) {
49             System.out.print(stack.pop()+" ");
50         }
51     }
52 }

 * 入队：rear=rear+1，data[rear]=e
 * 出队：front=front+1,E value=(E)data[front],data[front]=null
 * 得到对首元素：(E)data[front+1];
 * 判断对空：rear==front
 * 对长：rear-front

 1 package com.myutil.queue;
 2 
 3 /*
 4  * 设置两个指针，头指针front和尾指针rear
 5  * 规定front总是指向当前队头元素的前一个位置，rear指向当前队尾元素的位置
 6  * 初始化front=rear=-1
 7  * 
 8  * 入队：rear=rear+1，data[rear]=e
 9  * 出队：front=front+1,E value=(E)data[front],data[front]=null
10  * 得到对首元素：(E)data[front+1];
11  * 判断对空：rear==front
12  * 对长：rear-front
13  */
14 
15 public class Queue<E> {
16     private Object[] data=null;
17     private int maxSize; //队列容量
18     private int front;  //队列头，允许删除
19     private int rear;   //队列尾，允许插入
20 
21     //构造函数
22     public Queue(){
23         this(10);
24     }
25     
26     public Queue(int initialSize){
27         if(initialSize >=0){
28             this.maxSize = initialSize;
29             data = new Object[initialSize];
30             front = rear =-1;
31         }else{
32             throw new RuntimeException("初始化大小不能小于0：" + initialSize);
33         }
34     }
35     
36     
37     
38     //插入
39     public boolean add(E e){
40         if(rear== maxSize-1){
41             throw new RuntimeException("队列已满，无法插入新的元素！");
42         }else{
43             data[++rear]=e;
44             return true;
45         }
46     }
47     
48     //返回队首元素，但不删除
49     public E peek(){
50         if(empty()){
51             throw new RuntimeException("空队列异常！");
52         }else{
53             
54             return (E) data[front+1];
55         }    
56     }
57     
58     //出队
59     public E poll(){
60         if(empty()){
61             throw new RuntimeException("空队列异常！");
62         }else{
63             E value = (E) data[++front];  //保留队列的front端的元素的值
64             data[front] = null;     //释放队列的front端的元素                
65             return value;
66             
67             /*front=front+1;
68             E value=(E) data[front];
69             return value;*/
70         }            
71     }
72     
73     //队列长度
74     public int length(){
75         return rear-front;
76     }
77     
78   //判空
79     public boolean empty(){
80         return rear==front?true:false;
81     }
82     
83     public static void main(String[] args) {
84         Queue<Integer> queue=new Queue<>();
85         for (int i = 0; i < 5; i++) {
86             queue.add(i);
87         }
88         for (int i = 0; i < queue.length(); i++) {
89             System.out.print(queue.peek()+" ");
90         }
91         System.out.println();
92         int size=queue.length();
93         for (int i = 0; i < size; i++) {
94             System.out.print(queue.poll()+" ");
95         }
96     }
97 }

 * 入队：rear=(rear+1)%maxSize，data[rear]=e
 * 出队：front = (front+1)%maxSize; E value =(E)data[front]; data[front] = null; 
 * 得到对首元素：(E)data[front+1];
 * 判断对空：rear==front
 * 对长：rear-front

 1 package com.myutil.queue;
 2 
 3 /*
 4  * 入队：rear=(rear+1)%maxSize，data[rear]=e
 5  * 出队：front = (front+1)%maxSize; E value =(E)data[front]; data[front] = null; 
 6  * 得到对首元素：(E)data[front+1];
 7  * 判断对空：rear==front
 8  * 对长：rear-front
 9  */
10 import java.util.Arrays;
11 
12 public class LoopQueue<E> {
13     public Object[] data = null;
14     private int maxSize; // 队列容量
15     private int rear;// 队列尾，允许插入
16     private int front;// 队列头，允许删除
17     //private int size=0; //队列当前长度
18 
19     public LoopQueue() {
20         this(10);
21     }
22 
23     public LoopQueue(int initialSize) {
24         if (initialSize >= 0) {
25             this.maxSize = initialSize;
26             data = new Object[initialSize];
27             front = rear = -1;
28         } else {
29             throw new RuntimeException("初始化大小不能小于0：" + initialSize);
30         }
31     }
32 
33     
34     // 插入
35     public boolean add(E e) {
36         if ((rear+1)%maxSize==front) {
37             throw new RuntimeException("队列已满，无法插入新的元素！");
38         } else {
39             rear = (rear + 1)%maxSize;
40             data[rear] = e;
41             return true;
42         }
43     }
44 
45     // 返回队首元素，但不删除
46     public E peek() {
47         if (empty()) {
48             throw new RuntimeException("空队列异常！");
49         } else {
50             return (E) data[front+1];
51         }
52     }
53 
54     // 出队
55     public E poll() {
56         if (empty()) {
57             throw new RuntimeException("空队列异常！");
58         } else {
59             front = (front+1)%maxSize;  //队首指针加1
60             E value = (E) data[front]; // 保留队列的front端的元素的值
61             data[front] = null; // 释放队列的front端的元素
62             return value;
63         }
64     }
65 
66     // 队列长度
67     public int length() {
68         return rear-front;
69     }
70     
71  // 判空
72     public boolean empty() {
73         return rear==front;
74     }
75 
76 
77     //清空循环队列
78     public void clear(){
79         Arrays.fill(data, null);
80         front = -1;
81         rear = -1;
82     }
83     
84     public static void main(String[] args) {
85         LoopQueue<Integer> queue=new LoopQueue<>();
86         for (int i = 0; i < 5; i++) {
87             queue.add(i);
88         }
89         for (int i = 0; i < queue.length(); i++) {
90             System.out.print(queue.peek()+" ");
91         }
92         System.out.println();
93         int size=queue.length();
94         for (int i = 0; i < size; i++) {
95             System.out.print(queue.poll()+" ");
96         }
97     }
98 }

 1 package com.myutil.queue;
 2 
 3 public class LinkQueue<E> {
 4     // 链栈的节点
 5     private class Node<E> {
 6         E e;
 7         Node<E> next;
 8 
 9         public Node() {
10         }
11 
12         public Node(E e, Node next) {
13             this.e = e;
14             this.next = next;
15         }
16         
17     }
18     
19     private Node front;// 队列头，允许删除  
20     private Node rear;// 队列尾，允许插入  
21     private int size; //队列当前长度 
22     
23     public LinkQueue() {
24         front = null;
25         rear = null;
26     }
27     
28     //判空
29       public boolean empty(){
30           return size==0;
31       }
32       
33       //插入
34       public boolean add(E e){
35           if(empty()){    //如果队列为空
36               front = new Node(e,null);//只有一个节点，front、rear都指向该节点
37               rear = front;
38           }else{
39               Node<E> newNode = new Node<E>(e, null);
40               rear.next = newNode; //让尾节点的next指向新增的节点
41               rear = newNode; //以新节点作为新的尾节点
42           }
43           size ++;
44           return true;
45       }
46       
47       //返回队首元素，但不删除
48       public Node<E> peek(){
49           if(empty()){
50               throw new RuntimeException("空队列异常！");
51           }else{
52               return front;
53           }
54       }
55       
56       //出队
57       public Node<E> poll(){
58           if(empty()){
59               throw new RuntimeException("空队列异常！");
60           }else{
61               Node<E> value = front; //得到队列头元素
62               front = front.next;//让front引用指向原队列头元素的下一个元素
63               value.next = null; //释放原队列头元素的next引用
64               size --;
65               return value;
66           }        
67       }
68       
69       //队列长度
70       public int length(){
71           return size;
72       }
73       
74       public static void main(String[] args) {
75           LinkQueue<Integer> queue=new LinkQueue<>();
76           for (int i = 0; i < 5; i++) {
77               queue.add(i);
78           }
79           for (int i = 0; i < queue.length(); i++) {
80               System.out.print(queue.peek().e+" ");
81           }
82           System.out.println();
83           int size=queue.length();
84           for (int i = 0; i < size; i++) {
85               System.out.print(queue.poll().e+" ");
86           }
87       }
88 }

 * 使用java.util.Queue接口,其底层关联到一个LinkedList（双端队列）实例.
 * 
 * add----add()            会抛出异常
 * offer-----offer()
 * 
 * element-----element() 对为空，返回异常
 * peek------peek()
 * 
 * remove----remove() 对为空，返回异常
 * poll------poll()
 * 
 * empty-----isEmpty()

 1 package com.myutil.queue;
 2 
 3 /**
 4  * 使用java.util.Queue接口,其底层关联到一个LinkedList（双端队列）实例.
 5  * 
 6  * add----add()            会抛出异常
 7  * offer-----offer()
 8  * 
 9  * element-----element() 对为空，返回异常
10  * peek------peek()
11  * 
12  * remove----remove() 对为空，返回异常
13  * poll------poll()
14  * 
15  * empty-----isEmpty()
16  */
17 import java.util.LinkedList;
18 import java.util.Queue;
19 
20 public class QueueList<E> {
21     private Queue<E> queue = new LinkedList<E>();
22     
23     // 将指定的元素插入此队列（如果立即可行且不会违反容量限制），在成功时返回 true，
24     //如果当前没有可用的空间，则抛出 IllegalStateException。
25     public boolean add(E e){
26         return queue.add(e);
27     }
28     
29     //获取，但是不移除此队列的头。
30     public E element(){
31         return queue.element();
32     }
33     
34     //将指定的元素插入此队列（如果立即可行且不会违反容量限制），当使用有容量限制的队列时，
35     //此方法通常要优于 add(E)，后者可能无法插入元素，而只是抛出一个异常。
36     public boolean offer(E e){
37         return queue.offer(e);
38     }
39     
40     //获取但不移除此队列的头；如果此队列为空，则返回 null
41     public E peek(){
42         return queue.peek();
43     }
44     
45     //获取并移除此队列的头，如果此队列为空，则返回 null
46     public E poll(){
47         return queue.poll();
48     }
49     
50     //获取并移除此队列的头
51     public E remove(){
52         return queue.remove();
53     }
54     
55     //判空
56     public boolean empty() {
57         return queue.isEmpty();
58     }
59     public static void main(String[] args) {
60           QueueList<Integer> queueList=new QueueList<>();
61           for (int i = 0; i < 5; i++) {
62               queueList.add(i);
63           }
64           /*while (!queueList.empty()) {
65             System.out.println(queueList.peek());
66         }
67           System.out.println();
68           */
69           while (!queueList.empty()) {
70             System.out.print(queueList.poll()+" ");
71         }
72       }
73 }