我是一個棧，先來跟你介紹一下我的家族，我的家族是一個很古老的家族，家族成員很多，外界稱呼我們這個家族為數據結構。我們是計算機世界中存儲和組織數據的。數據結構家族在計算機世界中是至關重要的，因為我們家族功能的強大，現代編程語言及其API中都有我們家族成員的身影。

我的家族是一個龐大的家族。家族中也有幾大分支，比如說樹、圖、堆、散列表等。各個分支都有不同的能力，所以很多人選擇適當的數據結構是一項很重要的工作。我們家族和算法家族是世交，基本上所有重要場合兩家都會一起出現。

我叫棧，我的爸爸叫數組，我的媽媽叫鏈表，我的雙胞胎弟弟叫隊列。我們這個家庭是整個數據結構家族中比較重要的家庭。

和你說過了，我們數據結構家族是計算機世界中儲存和組織數據的。我的家族之所以這么強大，就是因為我們要應付各種需求，提供不同的數據存儲方式。我的四個家庭成員分別可以解決不同的數據存取需求。

數組

說起我的爸爸——數組，他是數據結構家族的族長，人們都說他是數據結構大家族的根基。很多編程語言都內置數組。爸爸是個很富有的人，他有很多土地。每當有人找他來存儲數據的時候，他都會預先劃分出一塊連續的土地（連續的內存），然后把別人交給他的數據按順序存儲在這些連續的土地中，當別人來取這些數據的時候，需要提供給數組要取哪塊土地中的數據（數組的位置索引），然后數組就可以直接去那塊土地中把數據取出來，交給需要讀取這個數據的人。并不是所有數據數組都能幫忙存儲的，父親只會幫別人存儲相同類型的數據。

我的家族的所有人都支持幾個基本的操作：插入、刪除、讀取。

因為數組爸爸在存儲數據的時候，是按照順序保存的，他保存數據的土地是一塊一塊相連的。那么，他的特點就是尋址讀取數據比較容易，但是插入和刪除比較困難。這個其實比較好理解。讀取容易的原因是只要你告訴數組你要從哪塊土地讀取數據，他就會直接去那塊土地中把數據取出來給你。插入和刪除比較麻煩，主要是因為這些存儲數據的空間都是連著的，比如編號為0-1-2-3-4這五塊土地中都保存了數據，但是現在你要往1中插入一塊數據，那就意味著從1開始，后面的所有土地中的數據都要往后移一個位置。這是很大的工作量啊。

鏈表

人們都說，男女搭配，干活不累。由于數組爸爸有尋址容易，插入和刪除困難的問題，他在找老婆的時候特意找了一個和自己互補的姑娘——鏈表。鏈表媽媽的特點正好是尋址困難，插入和刪除容易。

在幫助別人存儲數據這件事上，鏈表的方式和數組有很大不同。數組是提前劃分了一大片連續的土地，用來存儲數據。但是鏈表不是這么做的，因為鏈表媽媽家里并沒有數組爸爸家里那么富有。他的數據存儲并不是連續的，能這么做的原因是媽媽存儲數據的土地中有兩塊區域，一塊用來保存數據，一塊用來記錄下一個數據保存在哪塊土地中（指針）。這樣，別人找他存儲數據的時候，她就要根據指示先找到下一塊空余的土地，然后把數據保存在里面。鏈表這樣的數據存儲方式可以把一些碎片空間利用起來。

通過上面的這種保存數據的方式，鏈表在插入和刪除數據的時候比較容易，比如編號為0-1-2-3-4這五塊土地中都保存了數據，但是現在你要往1中插入一塊數據，那么只需要依次更改0號土地和1號土地中記錄下一塊土地地址的值就行了。對于其他的數據存儲沒有任何影響。但是，如果你想從數據中取出一塊數據那可就麻煩了，因為這意味著鏈表媽媽要幫你從第一塊土地開始挨個幫你找。一直找到你要的數據為止。

我和我的胞弟

棧，也就是我，一個英俊瀟灑的數據結構。我和隊列是一堆孿生兄弟。我們兩個都可以用數組和鏈表來實現。雖然是雙胞胎，但是我們兩個都是有性格的，我們要求別人存儲數據和取出數據的順序要按照我們的規矩來。

我的原則是：先進后出（棧）

弟弟的原則是：先進先出（隊列）

我給你舉個例子你就明白了，我和弟弟每個人都有一個管子，用來幫你們保存數據，當然這個管子可能是用數組爸爸是實現的也可能是鏈表媽媽實現的。我們握住管子的兩頭，我的這個管子只能通過管子左面的口子放入東西，也只能從左面的口子取出東西。右面的口子是不開的。而弟弟隊列呢，他的管子的左面的口子放東西，管子的右面的口子取東西。

爸爸媽媽是如何生出我和弟弟的

上面說過了，棧和隊列都是可以通過數組或者鏈表實現的。當然了，父母創造孩子，天經地義嘛。那么，先來看看我是如何實現的。作為一種數據結構，我接口有isEmpty()、size()、push()、pop()、peek()以及迭代。

先來看看如何通過數組實現棧：

public class Stack<Item> implements Iterable<Item> {private Item[] a; // 數組表示棧，棧頂在最大的下標。private int n; // 棧內元素的個數/*** 初始化一個空棧*/public Stack() {a = (Item[]) new Object[2];n = 0;}/*** 判斷棧內是否有元素*/public boolean isEmpty() {return n == 0;}/*** 返回棧內元素個數*/public int size() {return n;}// 改變棧的大小private void resize(int capacity) {assert capacity >= n;// 注意不能直接創建泛型數組Item[] temp = (Item[]) new Object[capacity];for (int i = 0; i < n; i++) {temp[i] = a[i];}a = temp;// 也可以選擇下面這種方式改變數組大小// a = java.util.Arrays.copyOf(a, capacity);}/*** 壓入元素*/public void push(Item item) {//先判斷n的大小，如果棧滿則改變棧的大小if (n == a.length) resize(2*a.length); a[n++] = item; }/*** 彈出并返回元素*/public Item pop() {if (isEmpty()) throw new NoSuchElementException("Stack underflow");Item item = a[n-1];a[n-1] = null; //防止對象游離n--;// 如果有必要則調整棧的大小if (n > 0 && n == a.length/4) resize(a.length/2);return item;}/*** 返回但不彈出棧頂元素*/public Item peek() {if (isEmpty()) throw new NoSuchElementException("Stack underflow");return a[n-1];}/*** 返回一個可以進行先進后出迭代的迭代器*/public Iterator<Item> iterator() {return new ReverseArrayIterator();}// 用內部類實現迭代器接口，實現從棧頂往棧底的先進后出迭代，沒有實現remove()方法。 private class ReverseArrayIterator implements Iterator<Item> {private int i;public ReverseArrayIterator() {i = n-1;}public boolean hasNext() {return i >= 0;}public void remove() {throw new UnsupportedOperationException();}public Item next() {if (!hasNext()) throw new NoSuchElementException();return a[i--];}}/*** 測試*/public static void main(String[] args) {Stack<String> stack = new Stack<String>();while (!StdIn.isEmpty()) {String item = StdIn.readString();if (!item.equals("-")) stack.push(item);else if (!stack.isEmpty()) StdOut.print(stack.pop() + " ");}StdOut.println("(" + stack.size() + " left on stack)");} }

再來看看如何使用鏈表實現棧：

public class Stack<Item> implements Iterable<Item> {private Node<Item> first; //棧頂節點private int N; // 棧內元素數量// 輔助類Node，用于形成鏈表private static class Node<Item> {private Item item;private Node<Item> next;}/*** 初始化棧*/public Stack() {first = null;N = 0;}/*** 判斷棧是否為空*/public boolean isEmpty() {return first == null;//return N == 0;}/*** 返回棧內元素數量*/public int size() {return N;}/*** 壓入元素*/public void push(Item item) {Node<Item> oldfirst = first;first = new Node<Item>();first.item = item;first.next = oldfirst;N++;}/*** 彈出元素*/public Item pop() {if (isEmpty()) throw new NoSuchElementException("Stack underflow");Item item = first.item; // 需彈出的元素first = first.next; // 刪除頭節點N--;return item; }/*** 返回但不彈出元素*/public Item peek() {if (isEmpty()) throw new NoSuchElementException("Stack underflow");return first.item;}/*** 從棧頂到棧底打印元素*/public String toString() {StringBuilder s = new StringBuilder();for (Item item : this)s.append(item + " ");return s.toString();}/*** 實現Iterable接口*/public Iterator<Item> iterator() {return new ListIterator<Item>(first);}// 實現Iterator接口用于迭代，沒有實現remove方法private class ListIterator<Item> implements Iterator<Item> {private Node<Item> current;//初始化時，current指向棧頂public ListIterator(Node<Item> first) {current = first;}public boolean hasNext() {return current != null;}public void remove() {throw new UnsupportedOperationException();}public Item next() {if (!hasNext()) throw new NoSuchElementException();Item item = current.item;current = current.next; return item;}}/*** 測試*/public static void main(String[] args) {Stack<String> s = new Stack<String>();while (!StdIn.isEmpty()) {String item = StdIn.readString();if (!item.equals("-")) s.push(item);else if (!s.isEmpty()) StdOut.print(s.pop() + " ");}StdOut.println("(" + s.size() + " left on stack)");} }

同樣作為數據結構的弟弟，也有些接口需要實現：isEmpty()、size()、enqueue()、dequeue()、peek()以及迭代。隊列和棧不同的是，入列和出列是在兩個地方，所以需要維護兩個變量來表示隊頭和隊尾。

使用數組實現隊列：

public class Queue<Item> implements Iterable<Item> {private Item[] q; private int N; // 隊列中元素的數量private int first; // 隊頭元素的下標private int last; // 隊尾元素的后一個位置的下標，也就是元素入列時可以放置的位置/*** 初始化隊列，此時頭尾下標重合*/public Queue() {q = (Item[]) new Object[2];N = 0;first = 0;last = 0;}/*** 依舊用N判斷隊列是否為空*/public boolean isEmpty() {return N == 0;}/*** 隊列中元素數量*/public int size() {return N;}// 調整數組大小private void resize(int max) {assert max >= N;Item[] temp = (Item[]) new Object[max];//注意這里：把N個元素放入總大小為max的隊列（max>=N）//因為循環使用數組，從first開始的第i個元素可能保存在了first//前面（即last在first前面）。for (int i = 0; i < N; i++) {temp[i] = q[(first + i) % q.length];}q = temp;//把小隊列按順序復制到大隊列后重置隊頭和隊尾first = 0;last = N;}/*** 元素入列*/public void enqueue(Item item) {if (N == q.length) resize(2*q.length); q[last++] = item; // 元素入列if (last == q.length) last = 0; // 如果last超出數組下標，把last置零，循環利用數組N++;}/*** 元素出列*/public Item dequeue() {if (isEmpty()) throw new NoSuchElementException("Queue underflow");Item item = q[first];q[first] = null; // 防止對象游離N--;first++;if (first == q.length) first = 0; // 循環利用數組，下一個隊頭在下標為0的地方if (N > 0 && N == q.length/4) resize(q.length/2); return item;}/*** 返回隊頭元素但不出列*/public Item peek() {if (isEmpty()) throw new NoSuchElementException("Queue underflow");return q[first];}/*** 實現Iterable接口*/public Iterator<Item> iterator() {return new ArrayIterator();}//實現迭代器private class ArrayIterator implements Iterator<Item> {//維護一個i用于迭代private int i = 0;public boolean hasNext() { return i < N; }public void remove() { throw new UnsupportedOperationException(); }//直接利用first進行遍歷，注意可能存在數組的循環利用public Item next() {if (!hasNext()) throw new NoSuchElementException();Item item = q[(i + first) % q.length];i++;return item;}}/*** 測試*/public static void main(String[] args) {Queue <String> q = new Queue <String>();while (!StdIn.isEmpty()) {String item = StdIn.readString();if (!item.equals("-")) q.enqueue(item);else if (!q.isEmpty()) StdOut.print(q.dequeue() + " ");}StdOut.println("(" + q.size() + " left on queue)");}}

使用鏈表實現隊列：

public class Queue<Item> implements Iterable<Item> {private Node<Item> first; // 隊頭節點private Node<Item> last; // 隊尾節點（注意和上面的last區分，last并不是隊尾元素的下標）private int N; // 隊列元素的數量// 輔助類Nodeprivate static class Node<Item> {private Item item;private Node<Item> next;}/*** 初始化隊列*/public Queue() {first = null;last = null;N = 0;}public boolean isEmpty() {return first == null;}public int size() {return N; }/*** 返回但不刪除頭元素*/public Item peek() {if (isEmpty()) throw new NoSuchElementException("Queue underflow");return first.item;}/*** 元素入列*/public void enqueue(Item item) {//記錄尾節點Node<Item> oldlast = last;//創建新的尾節點last = new Node<Item>();last.item = item;last.next = null;//如果隊列是空的，將first置為last，因為這時候隊列中只有一個元素if (isEmpty()) first = last;//否則執行正常的在尾節點插入新節點的操作else oldlast.next = last;N++;}/***元素出列 */public Item dequeue() {if (isEmpty()) throw new NoSuchElementException("Queue underflow");//隊頭元素出列Item item = first.item;first = first.next;N--;//如果這時候隊列為空，表示原來只有一個元素，這時候也將last置為nullif (isEmpty()) last = null; return item;}public String toString() {StringBuilder s = new StringBuilder();for (Item item : this)s.append(item + " ");return s.toString();} public Iterator<Item> iterator() {return new ListIterator<Item>(first); }// 實現迭代private class ListIterator<Item> implements Iterator<Item> {private Node<Item> current;//要實現迭代，我們只需要維護一個節點，并在開始的時候將它置為firstpublic ListIterator(Node<Item> first) {current = first;}public boolean hasNext() { return current != null;}public void remove() { throw new UnsupportedOperationException(); }public Item next() {if (!hasNext()) throw new NoSuchElementException();Item item = current.item;current = current.next; return item;}}/*** 測試*/public static void main(String[] args) {Queue<String> q = new Queue<String>();while (!StdIn.isEmpty()) {String item = StdIn.readString();if (!item.equals("-")) q.enqueue(item);else if (!q.isEmpty()) StdOut.print(q.dequeue() + " ");}StdOut.println("(" + q.size() + " left on queue)");} }

我是一個棧，我的雙胞胎弟弟叫隊列。我的爸爸是數組，我的媽媽是鏈表。 你們可以使用數組和鏈表來實現棧和隊列。

好了，今天關于我和我的家族的故事就先給你介紹到這里了。偷偷告訴你一個秘密，其實我和弟弟之間是可以互相轉換的。也就是說可以使用棧來實現隊列，同樣也可以使用隊列來實現棧。關于這個小秘密，我下次再給你介紹哦。

總結

以上是生活随笔為你收集整理的我是一个“栈”的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。