一、栈的基本定义
栈是一种数据结构，它代表一种特殊的线性表，这种线性表只能在固定一端（通常认为是线性表的尾端）进行插入、删除操作的特殊线性表，通常就是在线性表的尾端进行插入、删除操作。
二、顺序栈的实现
顺序栈是利用一组地址连续的存储单元依次存放从栈底到栈顶的数据元素，栈底位置固定不变，它的栈顶元素可以直接通过顺序栈底层数组的数组元素arr[size - 1]来访问。
1 package com.ietree.basic.datastructure.stack; 2 3 import java.util.Arrays; 4 5 /** 6 * 顺序栈 7 * 8 * Created by ietree 9 * 2017/4/29 10 */ 11 public class SequenceStack<T> { 12 13 private int DEFAULT_SIZE = 10; 14 // 保存数组的长度 15 private int capacity; 16 // 定义当底层数组容量不够时，程序每次增加的数组长度 17 private int capacityIncrement = 0; 18 // 定义一个数组用于保存顺序栈的元素 19 private Object[] elementData; 20 // 保存顺序栈中元素的当前个数 21 private int size = 0; 22 23 // 以默认数组长度创建空顺序栈 24 public SequenceStack() { 25 26 capacity = DEFAULT_SIZE; 27 elementData = new Object[capacity]; 28 29 } 30 31 // 以一个初始化元素来创建顺序栈 32 public SequenceStack(T element) { 33 34 this(); 35 elementData[0] = element; 36 size++; 37 38 } 39 40 /** 41 * 以指定长度的数组来创建顺序线性表 42 * 43 * @param element 指定顺序栈中第一个元素 44 * @param initSize 指定顺序栈底层数组的长度 45 */ 46 public SequenceStack(T element, int initSize) { 47 48 this.capacity = initSize; 49 elementData = new Object[capacity]; 50 elementData[0] = element; 51 size++; 52 53 } 54 55 /** 56 * 以指定长度的数组来创建顺序栈 57 * 58 * @param element 指定顺序栈中第一个元素 59 * @param initSize 指定顺序栈底层数组的长度 60 * @param capacityIncrement 指定当顺序栈底层数组的长度不够时，底层数组每次增加的长度 61 */ 62 public SequenceStack(T element, int initSize, int capacityIncrement) { 63 64 this.capacity = initSize; 65 this.capacityIncrement = capacityIncrement; 66 elementData = new Object[capacity]; 67 elementData[0] = element; 68 size++; 69 70 } 71 72 /** 73 * 获取顺序栈的大小 74 * 75 * @return 顺序栈的大小值 76 */ 77 public int length(){ 78 79 return size; 80 81 } 82 83 /** 84 * 入栈 85 * 86 * @param element 入栈的元素 87 */ 88 public void push(T element) { 89 90 ensureCapacity(size + 1); 91 elementData[size++] = element; 92 93 } 94 95 /** 96 * 确认数组的长度是否满足push之后的长度 97 * 98 * @param minCapacity 数组需要的最小长度 99 */ 100 public void ensureCapacity(int minCapacity) { 101 102 // 如果数组的原有长度小于目前所需要的长度 103 if (minCapacity > capacity) { 104 105 if (capacityIncrement > 0) { 106 107 while (capacity < minCapacity) { 108 // 不断地将capacity长度加capacityIncrement 109 // 直到capacity大于minCapacity为止 110 capacity += capacityIncrement; 111 112 } 113 } else { 114 115 // 不断地将capacity * 2，直到capacity大于minCapacity为止 116 while (capacity < minCapacity) { 117 118 capacity <<= 1; 119 120 } 121 122 } 123 elementData = Arrays.copyOf(elementData, capacity); 124 } 125 126 } 127 128 /** 129 * 出栈 130 * 131 * @return 出栈的元素 132 */ 133 public T pop() { 134 135 T oldValue = (T) elementData[size - 1]; 136 // 释放栈顶元素 137 elementData[--size] = null; 138 return oldValue; 139 140 } 141 142 // 返回栈顶元素，但不删除栈顶元素 143 public T peek() { 144 145 return (T) elementData[size - 1]; 146 147 } 148 149 // 判断顺序栈是否为空 150 public boolean empty() { 151 152 return size == 0; 153 154 } 155 156 // 清空顺序栈 157 public void clear() { 158 159 // 将底层数组所有元素赋值为null 160 Arrays.fill(elementData, null); 161 size = 0; 162 163 } 164 165 public String toString() { 166 167 if (size == 0) { 168 169 return "[]"; 170 171 } else { 172 173 StringBuilder sb = new StringBuilder("["); 174 for (int i = size - 1; i > -1; i--) { 175 sb.append(elementData[i].toString() + ", "); 176 } 177 int len = sb.length(); 178 return sb.delete(len - 2, len).append("]").toString(); 179 } 180 181 } 182 183 }
测试类：
1 package com.ietree.basic.datastructure.stack; 2 3 /** 4 * Created by ietree 5 * 2017/4/29 6 */ 7 public class SequenceStackTest { 8 9 public static void main(String[] args) { 10 11 SequenceStack<String> stack = new SequenceStack<String>(); 12 13 stack.push("aaaa"); 14 stack.push("bbbb"); 15 stack.push("cccc"); 16 stack.push("dddd"); 17 System.out.println(stack); 18 19 System.out.println("访问栈顶元素：" + stack.peek()); 20 21 System.out.println("第一次弹出栈顶元素：" + stack.pop()); 22 23 System.out.println("第二次弹出栈顶元素：" + stack.pop()); 24 25 System.out.println("两次pop之后的栈：" + stack); 26 27 } 28 29 }
程序输出：
[dddd, cccc, bbbb, aaaa]
访问栈顶元素：dddd
第一次弹出栈顶元素：dddd
第二次弹出栈顶元素：cccc
两次pop之后的栈：[bbbb, aaaa]