關於數組/鏈表/棧/隊列的形象解釋

來源:互聯網
上載者:User

“棧”:

 

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

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

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

    和你說過了,我們資料結構家族是電腦世界中儲存和組織資料的。我的家族之所以這麼強大,就是因為我們要應付各種需求,提供不同的資料存放區方式。我的四個家庭成員分別可以解決不同的資料存取需求。

 

1. 數組:

    說起我的爸爸——數組,他是資料結構家族的族長,人們都說他是資料結構大家族的根基。很多程式設計語言都內建數組。

    數組爸爸是個很富有的人,他有很多土地。每當有人找他來儲存資料的時候,他都會預先劃分出一塊連續的土地(連續的記憶體),然後把別人交給他的資料按順序儲存在這些連續的土地中,當別人來取這些資料的時候,需要提供給數組要取哪塊土地中的資料(數組的位置索引),然後數組就可以直接去那塊土地中把資料取出來,交給需要讀取這個資料的人。並不是所有資料數組都能幫忙儲存的,父親只會幫別人儲存相同類型的資料。

 

    數組資料結構是由相同類型的元素(element)的集合所組成的資料結構,分配一塊連續的記憶體來儲存。利用元素的索引(index)可以計算出該元素對應的儲存地址。

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

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

 

2. 鏈表:

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

    在協助別人儲存資料這件事上,鏈表的方式和數組有很大不同。數組是提前劃分了一大片連續的土地,用來儲存資料。但是鏈表不是這麼做的,因為鏈表媽媽家裡並沒有數組爸爸家裡那麼富有。他的資料存放區並不是連續的,能這麼做的原因是媽媽儲存資料的土地中有兩塊地區,一塊用來儲存資料,一塊用來記錄下一個資料儲存在哪塊土地中(指標)。這樣,別人找他儲存資料的時候,她就要根據指示先找到下一塊空餘的土地,然後把資料儲存在裡面。鏈表這樣的資料存放區方式可以把一些片段空間利用起來。

 

 

3. 棧和隊列:

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

我的原則是:先進後出(棧)

 

弟弟的原則是:先進先出(隊列)

 

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

 

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

    上面說過了,棧和隊列都是可以通過數組或者鏈表實現的。當然了,父母創造孩子,天經地義嘛。那麼,先來看看我是如何?的。作為一種資料結構,我介面有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;               // 隊列元素的數量   // 輔助類Node   private 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置為null       if (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;       //要實現迭代,我們只需要維護一個節點,並在開始的時候將它置為first       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) {       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)");   }}

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

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

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.