数据结构实现（一）栈

转载：https://www.cnblogs.com/CherishFX/p/4608880.html

1、基于数组实现栈

 1 package dataStructures;
 2 
 3 public class StackArray<E> {
 4 
 5     private Object[] data = null;
 6     private int maxSize; //栈容量
 7     private int top = -1; //栈顶指针
 8     
 9     /**
10      * 无参构造函数
11      */
12     StackArray(){
13         this(10); //默认栈大小为10         
14     }
15     
16     /**
17      * 有参构造函数
18      */
19     StackArray(int initialSize){
20         if(initialSize >= 0){
21             this.maxSize = initialSize;
22             data = new Object[initialSize];
23             top = -1;
24         }else{
25             throw new RuntimeException("初始化大小不能小于0：" + initialSize);
26         }
27     }
28     
29     //进栈，第一个元素top=0；
30     public boolean push(E e){
31         if(top == maxSize - 1){
32             throw new RuntimeException("栈已满，无法将元素入栈！");
33         }else{
34             data[++top] = e;
35             return true;
36         }
37     }
38     
39     //弹出栈顶元素
40     public E pop(){
41         if(top == -1){
42             throw new RuntimeException("栈为空！");
43         }else{
44             return (E)data[top--];
45         }
46     }
47     
48     //查看栈顶元素但不移除
49     public E peek(){
50         if(top == -1){
51             throw new RuntimeException("栈为空！");
52         }else{
53             return (E)data[top];
54         }
55     }
56     
57     //判空
58     public boolean empty(){
59         return top == -1 ? true : false;
60     }
61     
62     //返回对象在栈中的位置，以1为基数
63     public int search(E e){
64         int i = top;
65         while(top != -1){
66             if(peek() != e){
67                 top--;
68             }else{
69                 break;
70             }
71         }
72         int result = top + 1;
73         top = i;
74         return result;
75     }
76 }

2、基于链表实现栈

 1 package dataStructures;
 2 
 3 // 链栈的节点
 4 class Node<E> {
 5     E e; // 节点的值
 6     Node<E> next; // 该节点指向的下一个节点
 7     
 8     // 构造函数
 9     public Node(E e, Node next) {
10         this.e = e;
11         this.next = next;
12     }
13 }
14 
15 public class StackLink<E> {
16 
17     private Node<E> top = null; // 栈顶元素
18     private int size = 0; // 当前栈大小
19 
20     // 当前栈大小
21     public int length() {
22         return size;
23     }
24 
25     // 判空
26     public boolean empty() {
27         return size == 0;
28     }
29 
30     /**
31      * 入栈：让top句柄指向新创建的节点，新节点的next引用指向原来的栈顶元素top
32      * Node的有参构造器就直接完成了新节点指向原栈顶节点的任务，然后top句柄指向新节点即可,这样就不用新建个句柄oldTop来暂存旧栈顶节点
33      * 
34      * @param e
35      */
36     public boolean push(E e) {
37         top = new Node(e, top);
38         size++;
39         return true;
40     }
41 
42     // 查看栈顶元素但不删除
43     public Node<E> peek() {
44         if (empty()) {
45             throw new RuntimeException("空栈异常！");
46         } else {
47             return top;
48         }
49     }
50 
51     /**
52      * 出栈：新建个temp句柄指向top节点，top句柄指向top的下一个节点，现在就是 temp -> top ->
53      * 让temp.next=null释放即可
54      */
55     public Node<E> pop() {
56         if (empty()) {
57             throw new RuntimeException("空栈异常！");
58         } else {
59             Node<E> temp = top; // 得到栈顶元素
60             top = top.next; // 让top引用指向原栈顶元素的下一个元素
61             temp.next = null; // 释放原栈顶元素的next引用
62             size--;
63             return temp;
64         }
65     }
66 }

3、基于java.util.LinkedList实现

 1 package dataStructures;
 2 
 3 import java.util.LinkedList;
 4 
 5 public class StackLinkedList<E> {
 6     private LinkedList<E> ll = new LinkedList<E>();
 7 
 8     // 入栈
 9     public void push(E e) {
10         ll.addFirst(e);
11     }
12 
13     // 查看栈顶元素但不移除
14     public E peek() {
15         return ll.getFirst();
16     }
17 
18     // 出栈
19     public E pop() {
20         return ll.removeFirst();
21     }
22 
23     // 判空
24     public boolean empty() {
25         return ll.isEmpty();
26     }
27 
28     // 打印栈元素
29     public String toString() {
30         return ll.toString();
31     }
32 }