2. 程式人生 > >java資料結構-棧

java資料結構-棧

阿新 • • 發佈：2018-12-14

1、棧的基本概念

　　棧（英語：stack）又稱為堆棧或堆疊，棧作為一種資料結構，是一種只能在一端進行插入和刪除操作的特殊線性表。它按照先進後出的原則儲存資料，先進入的資料被壓入棧底，最後的資料在棧頂，需要讀資料的時候從棧頂開始彈出資料（最後一個數據被第一個讀出來）。棧具有記憶作用，對棧的插入與刪除操作中，不需要改變棧底指標。

　　棧是允許在同一端進行插入和刪除操作的特殊線性表。允許進行插入和刪除操作的一端稱為棧頂(top)，另一端為棧底(bottom)；棧底固定，而棧頂浮動；棧中元素個數為零時稱為空棧。插入一般稱為進棧（PUSH），刪除則稱為退棧（POP）。

　　由於堆疊資料結構只允許在一端進行操作，因而按照後進先出（LIFO, Last In First Out）的原理運作。棧也稱為後進先出表。

　　這裡以羽毛球筒為例，羽毛球筒就是一個棧，剛開始羽毛球筒是空的，也就是空棧，然後我們一個一個放入羽毛球，也就是一個一個push進棧，當我們需要使用羽毛球的時候，從筒裡面拿，也就是pop出棧，但是第一個拿到的羽毛球是我們最後放進去的

2、Java模擬簡單的順序棧實現

　　

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

package com.ys.datastructure;

public class MyStack {

private int[] array;

private int maxSize;

private int top;

public MyStack(int size){

this.maxSize = size;

array = new int[size];

top = -1;

}

//壓入資料

public void push(int value){

if(top < maxSize-1){

array[++top] = value;

}

}

//彈出棧頂資料

public int pop(){

return array[top--];

}

//訪問棧頂資料

public int peek(){

return array[top];

}

//判斷棧是否為空

public boolean isEmpty(){

return (top == -1);

}

//判斷棧是否滿了

public boolean isFull(){

return (top == maxSize-1);

}

}

　　測試：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

package com.ys.test;

import com.ys.datastructure.MyStack;

public class MyStackTest {

public static void main(String[] args) {

MyStack stack = new MyStack(3);

stack.push(1);

stack.push(2);

stack.push(3);

System.out.println(stack.peek());

while(!stack.isEmpty()){

System.out.println(stack.pop());

}

}

}

　　結果：

　　

　　這個棧是用陣列實現的，內部定義了一個數組，一個表示最大容量的值以及一個指向棧頂元素的top變數。構造方法根據引數規定的容量建立一個新棧，push()方法是向棧中壓入元素，指向棧頂的變數top加一，使它指向原頂端資料項上面的一個位置，並在這個位置上儲存一個數據。pop()方法返回top變數指向的元素，然後將top變數減一，便移除了資料項。要知道 top 變數指向的始終是棧頂的元素。

　　產生的問題：

　　①、上面棧的實現初始化容量之後，後面是不能進行擴容的（雖然棧不是用來儲存大量資料的），如果說後期資料量超過初始容量之後怎麼辦？（自動擴容）

　　②、我們是用陣列實現棧，在定義陣列型別的時候，也就規定了儲存在棧中的資料型別，那麼同一個棧能不能儲存不同型別的資料呢？（宣告為Object）

　　③、棧需要初始化容量，而且陣列實現的棧元素都是連續儲存的，那麼能不能不初始化容量呢？（改為由連結串列實現）

3、增強功能版棧

　　對於上面出現的問題，第一個能自動擴容，第二個能儲存各種不同型別的資料，解決辦法如下：（第三個在講連結串列的時候在介紹）

　　這個模擬的棧在JDK原始碼中，大家可以參考 Stack 類的實現。

　　

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

package com.ys.datastructure;

import java.util.Arrays;

import java.util.EmptyStackException;

public class ArrayStack {

//儲存元素的陣列,宣告為Object型別能儲存任意型別的資料

private Object[] elementData;

//指向棧頂的指標

private int top;

//棧的總容量

private int size;

//預設構造一個容量為10的棧

public ArrayStack(){

this.elementData = new Object[10];

this.top = -1;

this.size = 10;

}

public ArrayStack(int initialCapacity){

if(initialCapacity < 0){

throw new IllegalArgumentException("棧初始容量不能小於0: "+initialCapacity);

}

this.elementData = new Object[initialCapacity];

this.top = -1;

this.size = initialCapacity;

}

//壓入元素

public Object push(Object item){

//是否需要擴容

isGrow(top+1);

elementData[++top] = item;

return item;

}

//彈出棧頂元素

public Object pop(){

Object obj = peek();

remove(top);

return obj;

}

//獲取棧頂元素

public Object peek(){

if(top == -1){

throw new EmptyStackException();

}

return elementData[top];

}

//判斷棧是否為空

public boolean isEmpty(){

return (top == -1);

}

//刪除棧頂元素

public void remove(int top){

//棧頂元素置為null

elementData[top] = null;

this.top--;

}

/**

* 是否需要擴容，如果需要，則擴大一倍並返回true，不需要則返回false

* @param minCapacity

* @return

*/

public boolean isGrow(int minCapacity){

int oldCapacity = size;

//如果當前元素壓入棧之後總容量大於前面定義的容量，則需要擴容

if(minCapacity >= oldCapacity){

//定義擴大之後棧的總容量

int newCapacity = 0;

//棧容量擴大兩倍(左移一位)看是否超過int型別所表示的最大範圍

if((oldCapacity<<1) - Integer.MAX_VALUE >0){

newCapacity = Integer.MAX_VALUE;

}else{

newCapacity = (oldCapacity<<1);//左移一位，相當於*2

}

this.size = newCapacity;

int[] newArray = new int[size];

elementData = Arrays.copyOf(elementData, size);

return true;

}else{

return false;

}

}

}

　　測試：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

//測試自定義棧類 ArrayStack

//建立容量為3的棧，然後新增4個元素，3個int，1個String.

@Test

public void testArrayStack(){

ArrayStack stack = new ArrayStack(3);

stack.push(1);

//System.out.println(stack.peek());

stack.push(2);

stack.push(3);

stack.push("abc");

System.out.println(stack.peek());

stack.pop();

stack.pop();

stack.pop();

System.out.println(stack.peek());

}

　　結果：

　

4、利用棧實現字串逆序

　　我們知道棧是後進先出，我們可以將一個字串分隔為單個的字元，然後將字元一個一個push()進棧，在一個一個pop()出棧就是逆序顯示了。如下：

　　將 字串“how are you” 反轉！！！

　　ps：這裡我們是用上面自定的棧來實現的，大家可以將ArrayStack替換為JDK自帶的棧類Stack試試

1

2

3

4

5

6

7

8

9

10

11

12

13

//進行字串反轉

@Test

public void testStringReversal(){

ArrayStack stack = new ArrayStack();

String str = "how are you";

char[] cha = str.toCharArray();

for(char c : cha){

stack.push(c);

}

while(!stack.isEmpty()){

System.out.print(stack.pop());

}

}

　　結果：

　

5、利用棧判斷分隔符是否匹配　　 

　　寫過xml標籤或者html標籤的，我們都知道<必須和最近的>進行匹配，[ 也必須和最近的 ] 進行匹配。

　　比如：<abc[123]abc>這是符號相匹配的，如果是 <abc[123>abc] 那就是不匹配的。

　　對於 12<a[b{c}]>，我們分析在棧中的資料：遇到匹配正確的就消除

　　

　　最後棧中的內容為空則匹配成功，否則匹配失敗！！！

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

//分隔符匹配

//遇到左邊分隔符了就push進棧，遇到右邊分隔符了就pop出棧，看出棧的分隔符是否和這個有分隔符匹配

@Test

public void testMatch(){

ArrayStack stack = new ArrayStack(3);

String str = "12<a[b{c}]>";

char[] cha = str.toCharArray();

for(char c : cha){

switch (c) {

case '{':

case '[':

case '<':

stack.push(c);

break;

case '}':

case ']':

case '>':

if(!stack.isEmpty()){

char ch = stack.pop().toString().toCharArray()[0];

if(c=='}' && ch != '{'

|| c==']' && ch != '['

|| c==')' && ch != '('){

System.out.println("Error:"+ch+"-"+c);

}

}

break;

default:

break;

}

}

}

6、總結

　　根據棧後進先出的特性，我們實現了單詞逆序以及分隔符匹配。所以其實棧是一個概念上的工具，具體能實現什麼功能可以由我們去想象。棧通過提供限制性的訪問方法push()和pop()，使得程式不容易出錯。

　　對於棧的實現，我們稍微分析就知道，資料入棧和出棧的時間複雜度都為O(1)，也就是說棧操作所耗的時間不依賴棧中資料項的個數，因此操作時間很短。而且需要注意的是棧不需要比較和移動操作，我們不要畫蛇添足

相關推薦

java資料結構——棧

棧是一種特殊的線性表，僅能線上性表的一端操作，棧頂允許操作，棧底不允許操作，遵循“後進先出”的特點。資料結構圖如下： 基本操作包括建立棧、入棧、出棧、獲取棧頂元素、獲取棧的大小等。棧的實現分為兩種，一種是通過陣列實現；一種是通過連結串列來實現。二者的區別是陣列實現棧簡單簡潔，而使用連結

java資料結構-棧

1、棧的基本概念 　　棧（英語：stack）又稱為堆棧或堆疊，棧作為一種資料結構，是一種只能在一端進行插入和刪除操作的特殊線性表。它按照先進後出的原則儲存資料，先進入的資料被壓入棧底，最後的資料在棧頂，需要讀資料的時候從棧頂開始彈出資料（最後一個數據被第一個讀出來）。棧具有

Java資料結構----棧(Stack)原始碼分析和個人簡單實現

一、Stack原始碼分析 1.繼承結構 　棧是資料結構中一種很重要的資料結構型別，因為棧的後進先出功能是實際的開發中有很多的應用場景。Java API中提供了棧（Stacck)的實現。   Stack類繼承了Vector類，而Vector類繼承了AbstractList抽象

java資料結構- 棧

棧 概念很簡單，棧 (Stack)是一種後進先出(last in first off，LIFO)的資料結構 可以理解為子彈匣，裝子彈是一個個壓進彈匣，拆子彈則要一個個拆出來，而最先拆出來的是最後壓進去的子彈 java示例 packag

java之---實現資料結構--棧(基本版)

package 資料結構; /** * java程式碼實現棧 */ class stack { private class Data { private Object obj; private Data next = null; Da

《java常用演算法手冊》 第二章 資料結構 棧 佇列

 順序棧的實現： package LineStructure; //參考 https://blog.csdn.net/icarus_wang/article/details/79561863 public cla

java中的資料結構——棧

棧的工作原理，後進先出。 棧，佇列是比陣列和其他資料結構更抽象的結構，主要通過介面對棧，佇列進行定義，而他們的主要實 現機制對使用者是不可見的。 棧的主要機制可以用陣列來實現，也可以用連結串列來實現。優先順序佇列的內部 實現可以用陣列或一種特殊的樹（堆）來實現。 棧只允許訪問一個數據項，即最

Java 資料結構2：棧及Stack原始碼詳解

棧 棧，相信大家都非常熟悉了，先進先出，後進後出，又叫做LIFO（先進先出）表，一般棧的模型是，存在某個元素位於棧頂，而該元素是唯一的可見元素 棧的實現方式 1、通過單鏈表，通過在表的頂端插入實現樸實，通過刪除表頂端元素實現pop，top操作知識考察表

自己動手實現java資料結構（三） 棧

自己動手實現java資料結構（三） 棧 1.棧的介紹 　　在許多演算法設計中都需要一種"先進後出(First Input Last Output)"的資料結構，因而一種被稱為"棧"的資料結構被抽象了出來。 　　棧的結構類似一個罐頭：只有一個開口；先被放進去的東西沉在底下，後放進去的東西被

8皇后以及N皇后演算法探究，回溯演算法的JAVA實現，非遞迴，資料結構“棧”實現

是使用遞迴方法實現回溯演算法的，在第一次使用二維矩陣的情況下，又做了一次改一維的優化 但是演算法效率仍然差強人意，因為使用遞迴函式的緣故 下面提供另一種回溯演算法的實現，使用資料結構”棧“來模擬，遞迴函式的手工實現，因為我們知道計算機在處理遞迴時的本質就是棧 時間複雜度是一樣的，空間

（Java資料結構和演算法）棧-----棧本質原理實現+ArrayDeque類實現

自定義棧 class MyStack{ private int[] a; private int size; private int top; private final int ERROR

【Java資料結構】用棧實現字尾表示式求值

今天在學資料結構，自己擼一段用棧來實現字尾表示式求值的程式碼，能改進的地方還有很多，在此先mark一下 package StackPractice; import java.util.Scanner; import java.util.Stack; im

java資料結構與演算法 第4章 棧和佇列

1.棧 棧只允許訪問一個數據項， 即最後插入的資料項，移除這個資料項才能訪問倒數第二個插入的資料項，依此類推。以下是java實現的棧： package exam; public class S

java資料結構與演算法之棧（Stack）設計與實現

關聯文章:   本篇是java資料結構與演算法的第4篇，從本篇開始我們將來了解棧的設計與實現，以下是本篇的相關知識點： 棧的抽象資料型別   棧是一種用於儲存資料的簡單資料結構，有點類似連結串列或者順序表（統稱線性表），棧與線性表的最大區別是

Java資料結構之——棧：用連結串列實現

class Node<E>{ E data; Node<E> next = null; public Node(E data){ this.data = data; } } public class ListStack<

Java資料結構之——棧：用陣列實現

/** * This is an abstract data type interface for the stack. * This interface includes methods: * {@code pop},{@code push},{@code peek},{@code isEm

JAVA資料結構和演算法：第三章（棧和佇列）

棧 棧是限制僅在一個位置上進行插入和刪除的線性表。允許插入和刪除的一端為末端，稱為棧頂。另一端稱為棧底。不含任何資料元素的棧稱為空棧。棧又成為後進先出(LIFO)表，後進入的元素最先出來。 首先，棧是一個線性表，元素之間具有線性關係，即前驅後繼關係，其次，

Java資料結構-線性表之棧的應用-遞迴及其應用

  遞迴函式的定義：把一個直接呼叫自己或通過一系列的呼叫語句間接地呼叫自己的函式，稱做遞迴函式（遞迴函式必須有一個結束的條件，以免陷入無窮盡的遞迴中）。 迭代和遞迴的區別是：  (1).迭代使用的是迴圈結構，遞迴使用的是選擇結構。  (2).遞迴能使程

Java實現資料結構--棧

package lianbiao; //儲存連結串列資訊 class Node { Node next = null; int data; public Node(int data) { this.data = data; } } public class

Java資料結構與演算法之stack棧

目錄：1.棧概述2.陣列實現自定義棧3.連結串列實現自定義棧4.集合實現自定義棧 1.棧概述棧和佇列一樣，也是線性表的一種，它唯一的特點是需要滿足先進後出(FILO)的規則，也就是隻能對棧的一頭進行操作，新增資料 稱為壓棧，移除資料稱為彈棧。而在java中棧的實現可以通過陣