2. 程式人生 > >資料結構-詳細分析“棧（Stack）”

資料結構-詳細分析“棧（Stack）”

阿新 • • 發佈：2019-01-15

一、什麼是棧？

棧是一種資料結構，元素的進出方式類似於“子彈進出子彈夾”。

二、棧的作用？哪裡會用到棧呢？（我理解還不太深，以後會補充）

三、棧的實現（C++、VS2017）

1、新建三個檔案，分別為MyStack.h、MyStack.cpp、StackDemo.cpp,程式碼分別如下，註釋詳細。

MyStack.h

#define MYSTACK_H

class MyStack {
public:
    MyStack(int size); //分配記憶體，初始化棧空間，設定棧容量，棧頂
    ~MyStack();     //回收棧空間記憶體
    bool stackEmpty(); //判定棧是否為空，為空的話返回true,非空返回false
 

    bool stackFull();  //判定棧是否已滿，為滿返回true，不滿返回false
    void clearStack(); //清空棧
    int stackLength(); //已有元素個數
    bool push(char elem); //元素入棧函式，棧頂上升
    bool pop(char &elem); //元素出棧，棧頂下降
    void stackTraverse(bool isFromButtom);    //遍歷棧中所有元素

private:
    char *m_pBuffer;   //棧空間指標
    int m_iSize;   //棧容量
 

    int m_iTop;        //棧頂，也代表了棧中的元素個數
};

MyStack.cpp

//具體實現棧類
#include"stdafx.h"
#include "MyStack.h"
#include<iostream>
using namespace std;

// 實現棧的建構函式
MyStack::MyStack(int size) { 

    m_iSize = size;   //首先將 棧的size 賦值給該類的資料成員
    m_pBuffer = new char[size];  //有了變數之後就可以申請記憶體了，用一個指標來指向這段記憶體，記憶體的資料型別為char
 

    m_iTop = 0;   //初始化棧頂,棧頂為零也就是棧為空了
}

// 實現棧的解構函式，用來釋放回收棧所佔的記憶體空間
MyStack::~MyStack() {

    delete []m_pBuffer;    // 因為是釋放一個記憶體的陣列，所以加[]
}

// 實現棧的判空函式
bool MyStack::stackEmpty(){

    if (0 == m_iTop) {  //很簡單，即判斷下棧頂iTop是否為0
        return true;
    }
    return false;
}

// 實現棧的判滿函式
bool MyStack::stackFull() {
    if (m_iTop == m_iSize) {
        return true;
    }
    return false;
}

// 清空棧函式實現,原理很簡單，就是將棧頂設為0，這樣的話，棧其他的位置無論是啥都沒用了，下次再賦新值的時候就會覆蓋
void MyStack::clearStack() {
    m_iTop = 0;
}

// 獲取棧當中已有的元素個數
int MyStack::stackLength() {
    return m_iTop; // 很簡單，棧頂的數字即元素個數
}

// 實現 元素入棧、棧頂上升 函式
bool MyStack::push(char elem) { // 將elem入棧
    if (stackFull()) { // 如果棧已經滿了
        return false; // 入棧失敗
    }
    m_pBuffer[m_iTop] = elem; // 元素入棧
    m_iTop++; // 棧頂上升

    return true;
}

// 元素出棧，棧頂下降
bool MyStack::pop(char &elem) {
    if (stackEmpty()) {
        return false;
    }
    m_iTop--;// 出棧一定要先將棧頂降低，以指向最高的一個數值，不然棧頂指向的一直是個空的東西
    elem = m_pBuffer[m_iTop];// 將當前的棧頂元素給elem不就行了嗎
    return true;
}

// 遍歷整個棧
void MyStack::stackTraverse(bool isFromButtom) { // 加一個判斷從頂還是底開始遍歷的開關
    if (isFromButtom) {
        for (int i = 0; i < m_iTop; i++) { // 棧底到棧頂做遍歷
            cout << m_pBuffer[i] << ",";
        }
    }
    else {
        for (int i = m_iTop - 1; i >= 0; i--) {   // 棧頂到棧底遍歷
            cout << m_pBuffer[i] << ",";
        }
    }

}

StackDemo.cpp

//這是執行檔案
//棧類具體實現檔案另建

#include "stdafx.h"
#include<iostream>
#include"stdlib.h"
#include"MyStack.h"
using namespace std;


int main()
{
    MyStack *pStack = new MyStack(5);   // 首先例項化MyStack類的一個物件

    pStack->push('h'); // 底
    pStack->push('e');
    pStack->push('l');
    pStack->push('l');
    pStack->push('o'); // 頂 

    pStack->stackTraverse(true); // true就是從底到頂遍歷

    cout << endl;

    char elem = 0;
    pStack->pop(elem); // 彈出頂
    cout << elem << endl;

    pStack->clearStack();

    cout << pStack->stackLength() << endl; // 輸出棧元素的個數

    if (pStack->stackEmpty()) {// 通過物件這個指標來判棧是否為空
        cout << "棧為空" << endl;
    }

    if (pStack->stackFull()) {
        cout << "棧為滿" << endl;
    }

    delete pStack; // 用完之後銷燬指標
    pStack = NULL;    // 再將指標指向 NULL

    system("pause");
    return 0;
}

執行結果：
這裡寫圖片描述

2、上面就已經實現了一個簡單的棧，可以對棧進行簡單的元素push、pop，但是隻能對char型別的元素，然而棧可以對所有型別的元素進行操作，因此下面進行改進：

①我們會定義一個 Coordinate 座標類；

②改造棧類，使其可以適用於座標類。

可以靈活掌握棧機制，理解抽象資料型別在棧中的應用。

我們另外建了倆檔案，現在一共五個原始檔：MyStack.h、MyStack.cpp、StackDemo.cpp、Coordinate.cpp、Coordinate.h，其原始碼分別如下：

MyStack.h

#define MYSTACK_H

#include"Coordinate.h"

class MyStack {
public:
    MyStack(int size); //分配記憶體，初始化棧空間，設定棧容量，棧頂
    ~MyStack();     //回收棧空間記憶體
    bool stackEmpty(); //判定棧是否為空，為空的話返回true,非空返回false
    bool stackFull();  //判定棧是否已滿，為滿返回true，不滿返回false
    void clearStack(); //清空棧
    int stackLength(); //已有元素個數
    bool push(Coordinate elem);   //元素入棧函式，棧頂上升
    bool pop(Coordinate &elem);   //元素出棧，棧頂下降
    void stackTraverse(bool isFromButtom);    //遍歷棧中所有元素

private:
    Coordinate *m_pBuffer; //棧空間指標
    int m_iSize;   //棧容量
    int m_iTop;        //棧頂，也代表了棧中的元素個數
};

MyStack.cpp

//具體實現棧類
#include"stdafx.h"
#include "MyStack.h"
#include<iostream>
using namespace std;

// 實現棧的建構函式
MyStack::MyStack(int size) { 

    m_iSize = size;   //首先將 棧的size 賦值給該類的資料成員
    m_pBuffer = new Coordinate[size];    //有了變數之後就可以申請記憶體了，用一個指標來指向這段記憶體，記憶體的資料型別為char
    m_iTop = 0;   //初始化棧頂,棧頂為零也就是棧為空了
}

// 實現棧的解構函式，用來釋放回收棧所佔的記憶體空間
MyStack::~MyStack() {

    delete []m_pBuffer;    // 因為是釋放一個記憶體的陣列，所以加[]
}

// 實現棧的判空函式
bool MyStack::stackEmpty(){

    if (0 == m_iTop) {  //很簡單，即判斷下棧頂iTop是否為0
        return true;
    }
    return false;
}

// 實現棧的判滿函式
bool MyStack::stackFull() {
    if (m_iTop == m_iSize) {
        return true;
    }
    return false;
}

// 清空棧函式實現,原理很簡單，就是將棧頂設為0，這樣的話，棧其他的位置無論是啥都沒用了，下次再賦新值的時候就會覆蓋
void MyStack::clearStack() {
    m_iTop = 0;
}

// 獲取棧當中已有的元素個數
int MyStack::stackLength() {
    return m_iTop; // 很簡單，棧頂的數字即元素個數
}

// 實現 元素入棧、棧頂上升 函式
bool MyStack::push(Coordinate elem) { // 將elem入棧
    if (stackFull()) { // 如果棧已經滿了
        return false; // 入棧失敗
    }
    m_pBuffer[m_iTop] = elem; // 元素入棧
    m_iTop++; // 棧頂上升

    return true;
}

// 元素出棧，棧頂下降
bool MyStack::pop(Coordinate &elem) {
    if (stackEmpty()) {
        return false;
    }
    m_iTop--;// 出棧一定要先將棧頂降低，以指向最高的一個數值，不然棧頂指向的一直是個空的東西
    elem = m_pBuffer[m_iTop];// 將當前的棧頂元素給elem不就行了嗎
    return true;
}

// 遍歷整個棧
void MyStack::stackTraverse(bool isFromButtom) { // 加一個判斷從頂還是底開始遍歷的開關
    if (isFromButtom) {
        for (int i = 0; i < m_iTop; i++) { // 棧底到棧頂做遍歷
            //cout << m_pBuffer[i] << ","; // 因為<<勝任不了輸出複雜資料型別，所以不用<<輸出
            m_pBuffer[i].printCoordinate();
        }
    }
    else {
        for (int i = m_iTop - 1; i >= 0; i--) {   // 棧頂到棧底遍歷
            //cout << m_pBuffer[i] << ",";
            m_pBuffer[i].printCoordinate();

        }
    }

}

StackDemo.cpp

//這是執行檔案
//棧類具體實現檔案另建

#include "stdafx.h"
#include<iostream>
#include"stdlib.h"
#include"MyStack.h"
using namespace std;


int main()
{
    MyStack *pStack = new MyStack(5);   // 首先例項化MyStack類的一個物件

    pStack->push(Coordinate(1,2)); // 底
    pStack->push(Coordinate(3,4));

    pStack->stackTraverse(true); // true就是從底到頂遍歷

    cout << endl;


    pStack->clearStack();

    cout << pStack->stackLength() << endl; // 輸出棧元素的個數

    if (pStack->stackEmpty()) {// 通過物件這個指標來判棧是否為空
        cout << "棧為空" << endl;
    }

    if (pStack->stackFull()) {
        cout << "棧為滿" << endl;
    }

    delete pStack; // 用完之後銷燬指標
    pStack = NULL;    // 再將指標指向 NULL

    system("pause");
    return 0;
}

Coordinate.cpp

#include"stdafx.h"
#include"Coordinate.h"
#include<iostream>
using namespace std;

Coordinate::Coordinate(int x, int y) {
    m_iX = x;
    m_iY = y;
}

void Coordinate::printCoordinate() {
    cout << "(" << m_iX << "," << m_iY << ")" << endl;
}

Coordinate.h

#define COORDINATE_H

class Coordinate {
public:
    Coordinate(int x=0,int y=0); // 預設建構函式，很重要
    void printCoordinate();

private:
    int m_iX;
    int m_iY;
};

執行結果：
這裡寫圖片描述

3、儘管已經實現了可以使用棧儲存輸出Coordinate座標類，但我們的目標是使其適用於任何資料型別，因此我們要將普通棧改造為類模板棧。只需要修改幾個地方，原始碼檔案還是五個：MyStack.h、MyStack.cpp、StackDemo.cpp、Coordinate.cpp、Coordinate.h，分別如下：

MyStack.h

#define MYSTACK_H

template<typename T> // 將普通棧改造為類模板棧
class MyStack {
public:
    MyStack(int size); //分配記憶體，初始化棧空間，設定棧容量，棧頂
    ~MyStack();     //回收棧空間記憶體
    bool stackEmpty(); //判定棧是否為空，為空的話返回true,非空返回false
    bool stackFull();  //判定棧是否已滿，為滿返回true，不滿返回false
    void clearStack(); //清空棧
    int stackLength(); //已有元素個數
    bool push(T elem);    //元素入棧函式，棧頂上升
    bool pop(T &elem);    //元素出棧，棧頂下降
    void stackTraverse(bool isFromButtom);    //遍歷棧中所有元素

private:
    T *m_pBuffer;  //棧空間指標
    int m_iSize;   //棧容量
    int m_iTop;        //棧頂，也代表了棧中的元素個數
};

template<typename T>
// 實現棧的建構函式
MyStack<T>::MyStack(int size) {

    m_iSize = size;   //首先將 棧的size 賦值給該類的資料成員
    m_pBuffer = new T[size]; //有了變數之後就可以申請記憶體了，用一個指標來指向這段記憶體，記憶體的資料型別為char
    m_iTop = 0;   //初始化棧頂,棧頂為零也就是棧為空了
}

template<typename T>
// 實現棧的解構函式，用來釋放回收棧所佔的記憶體空間
MyStack<T>::~MyStack() {

    delete[]m_pBuffer;  // 因為是釋放一個記憶體的陣列，所以加[]
}

template<typename T>
// 實現棧的判空函式
bool MyStack<T>::stackEmpty() {

    if (0 == m_iTop) {  //很簡單，即判斷下棧頂iTop是否為0
        return true;
    }
    return false;
}


template<typename T>
// 實現棧的判滿函式
bool MyStack<T>::stackFull() {
    if (m_iTop == m_iSize) {
        return true;
    }
    return false;
}


template<typename T>
// 清空棧函式實現,原理很簡單，就是將棧頂設為0，這樣的話，棧其他的位置無論是啥都沒用了，下次再賦新值的時候就會覆蓋
void MyStack<T>::clearStack() {
    m_iTop = 0;
}


template<typename T>
// 獲取棧當中已有的元素個數
int MyStack<T>::stackLength() {
    return m_iTop; // 很簡單，棧頂的數字即元素個數
}


template<typename T>
// 實現 元素入棧、棧頂上升 函式
bool MyStack<T>::push(T elem) { // 將elem入棧
    if (stackFull()) { // 如果棧已經滿了
        return false; // 入棧失敗
    }
    m_pBuffer[m_iTop] = elem; // 元素入棧
    m_iTop++; // 棧頂上升

    return true;
}


template<typename T>
// 元素出棧，棧頂下降
bool MyStack<T>::pop(T &elem) {
    if (stackEmpty()) {
        return false;
    }
    m_iTop--;// 出棧一定要先將棧頂降低，以指向最高的一個數值，不然棧頂指向的一直是個空的東西
    elem = m_pBuffer[m_iTop];// 將當前的棧頂元素給elem不就行了嗎
    return true;
}


template<typename T>
// 遍歷整個棧
void MyStack<T>::stackTraverse(bool isFromButtom) { // 加一個判斷從頂還是底開始遍歷的開關
    if (isFromButtom) {
        for (int i = 0; i < m_iTop; i++) { // 棧底到棧頂做遍歷
            cout << m_pBuffer[i]; // 因為<<勝任不了輸出複雜資料型別，所以不用<<輸出
                                  //m_pBuffer[i].printCoordinate();
        }
    }
    else {
        for (int i = m_iTop - 1; i >= 0; i--) {   // 棧頂到棧底遍歷
            cout << m_pBuffer[i];
            //m_pBuffer[i].printCoordinate();
        }
    }

}

MyStack.cpp

//具體實現棧類
#include"stdafx.h"
#include "MyStack.h"
#include<iostream>
using namespace std;

StackDemo.cpp

//這是執行檔案
//棧類具體實現檔案另建

#include "stdafx.h"
#include<iostream>
#include"stdlib.h"
#include"MyStack.h"
#include"Coordinate.h"

using namespace std;


int main()
{
    //現在MyStack<>這個尖括號裡的資料型別你就可以隨便使用了，比如在這裡用了Coordinate型別的
    MyStack<Coordinate> *pStack = new MyStack<Coordinate>(5);   // 首先例項化MyStack類的一個物件

    pStack->push(Coordinate(1,2)); // 底
    pStack->push(Coordinate(3,4));

    pStack->stackTraverse(true); // true就是從底到頂遍歷

    cout << endl;


    pStack->clearStack();

    cout << pStack->stackLength() << endl; // 輸出棧元素的個數

    if (pStack->stackEmpty()) {// 通過物件這個指標來判棧是否為空
        cout << "棧為空" << endl;
    }

    if (pStack->stackFull()) {
        cout << "棧為滿" << endl;
    }

    delete pStack; // 用完之後銷燬指標
    pStack = NULL;    // 再將指標指向 NULL

    system("pause");
    return 0;
}

Coordinate.cpp

#include"stdafx.h"
#include"Coordinate.h"
#include<iostream>
using namespace std;

Coordinate::Coordinate(int x, int y) {
    m_iX = x;
    m_iY = y;
}

void Coordinate::printCoordinate() {
    cout << "(" << m_iX << "," << m_iY << ")" << endl;
}

ostream &operator<<(ostream &out, Coordinate &coor) {
    out << "(" << coor.m_iX << "," << coor.m_iY << ")" <<endl;
    return out;
}

Coordinate.h

#define COORDINATE_H

#include<ostream>
using namespace std;

class Coordinate {

    friend ostream &operator<<(ostream &out, Coordinate &coor);
public:
    Coordinate(int x=0,int y=0); // 預設建構函式，很重要
    void printCoordinate();

private:
    int m_iX;
    int m_iY;
};

這樣一來，你想要使用什麼資料型別都可以了，只要在StackDemo.cpp檔案裡將MyStack<>簡括裡的資料型別進行相應的修改即可：

比如

這裡寫圖片描述
這裡寫圖片描述

四、接下來就是倆用棧來操作的小例子

1、棧應用–進位制轉換

描述：輸入任意的十進位制正整數N，分別輸出該整數N的二進位制、八進位制、十六進位制表示

公式：N = （N div d）* d + N mod d (div表示整除，mod表示求餘)

(1348)(十進位制) = (2504)(八進位制) = (544)(十六進位制) = (10101000100)(二進位制)

以後只用 StackDemo.cpp 和 MyStack.h 倆檔案就OK了，具體程式碼如下：

MyStack.h不變，只修改StackDemo.cpp：

//這是執行檔案
//棧類具體實現檔案另建

#include "stdafx.h"

#include<iostream>
#include"stdlib.h"
#include"MyStack.h"
#include"Coordinate.h"

using namespace std;

/*
    棧應用--進位制轉換

    描述：輸入任意的十進位制正整數N，分別輸出該整數N的二進位制、八進位制、十六進位制表示

    公式：N = （N div d）* d + N mod d (div表示整除，mod表示求餘)

    (1348)(十進位制) = (2504)(八進位制) = (544)(十六進位制) = (10101000100)(二進位制)

*/

// 首先需要定義好進位制
#define BINARY 2
#define OCTONARY 8
#define HEXADECIMAL 16

int main()
{
    char num[] = "0123456789ABCDEF"; // 為了16進位制考慮

    MyStack<int> *pStack = new MyStack<int>(30);    // 首先例項化MyStack類的一個物件

    int N = 2016; // 以2016為例

    int mod = 0; // 用 mod 來儲存餘數

    while (N != 0) { // 只要N不為零，就可以一直進行操作，進位制轉換的原理
        mod = N % HEXADECIMAL; // 用八進位制舉例子
        pStack->push(mod);// 不斷將餘數儲存進棧
        N = N / HEXADECIMAL;
    }

    //pStack->stackTraverse(false);// false就是從頂到底遍歷

    int elem = 0;
    while (!pStack->stackEmpty()) {
        pStack->pop(elem);
        cout << num[elem];
    }


    delete pStack; // 用完之後銷燬指標
    pStack = NULL;    // 再將指標指向 NULL

    system("pause");
    return 0;
}

這裡寫圖片描述

2、棧應用–括號匹配

描述：任意輸入一組括號，判斷括號是否匹配

字串示例：[()] [()()] [()[()]] [[()]]

思路就是：將字串每個字元按照順序入棧，一旦當有最靠近的倆字串匹配後，將其出棧，最後所有字串入棧結束後，我們判斷在棧中是否有未出棧的字元，也就是說棧是否為空，為空說明匹配完畢，所有字串都匹配成功了。（棧頂就是亟需匹配的字元，匹配成功，出棧）

MyStack.h不變，修改StackDemo.cpp即可，程式碼如下：

//這是執行檔案
//棧類具體實現檔案另建

#include "stdafx.h"

#include<iostream>
#include"stdlib.h"
#include"MyStack.h"
#include"Coordinate.h"

using namespace std;

/*
    棧應用--括號匹配（發散思維可知，不止可以括號匹配）

    描述：任意輸入一組括號，判斷括號是否匹配

    字串示例：[()] [()()] [()[()]] [[()]]

    思路就是，將字串每個字元按照順序入棧，一旦當有最靠近的倆字串匹配後，將其出棧，最後所有字串入棧結束後，我們判斷在棧中是否有未出棧的字元，也就是說棧是否為空，為空說明匹配完畢，所有字串都匹配成功了。
*/


int main(void)
{
    MyStack<char> *pStack = new MyStack<char>(30);

    MyStack<char> *pNeedStack = new MyStack<char>(30);

    char str[] = "[()]";

    char currentNeed = 0;

    for (int i = 0; i < strlen(str); i++) {
        if (str[i] != currentNeed) {
            pStack->push(str[i]);
            switch (str[i]) {

            case '[':
                if (currentNeed != 0) {
                    pNeedStack->push(currentNeed);
                }
                currentNeed = ']';
                break;

            case '(':
                if (currentNeed != 0) {
                    pNeedStack->push(currentNeed);
                }
                currentNeed = ')';
                break;

            default:
                cout << "不匹配" << endl;
                system("pause");
                return 0;
            }
        }
        else {
            char elem;
            pStack->pop(elem);
            if (!pNeedStack->pop(currentNeed)) {// 判斷出棧是否成功
                currentNeed = 0;
            }
        }
    }

    if (pStack->stackEmpty()) {
        cout << "匹配啦" << endl;
    }
    else {
        cout << "不匹配" << endl;
    }

    delete pStack;
    pStack = NULL;

    delete pNeedStack;
    pNeedStack = NULL;

    system("pause");
    return 0;
}

這裡寫圖片描述

棧學習完成。

相關推薦

資料結構-詳細分析“棧（Stack）”

一、什麼是棧？ 棧是一種資料結構，元素的進出方式類似於“子彈進出子彈夾”。 二、棧的作用？哪裡會用到棧呢？（我理解還不太深，以後會補充） 三、棧的實現（C++、VS2017） 1、新建三個檔案，分別為MyStack.h、MyStack.cpp、Sta

資料結構之JavaScript實現棧（Stack）

什麼是棧？ 棧是一種特殊的列表，棧內的元素只能在列表的一段訪問，這一端被稱為棧頂。棧是一種後入先出的資料結構。 下面就是JavaScript實現棧： <!DOCTYPE html> <html lang="en"> <head> <meta

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

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

我理解的數據結構（二）—— 棧（Stack）

tca 查看 png class a 順序 字符串 pac ack lee 我理解的數據結構（二）—— 棧（Stack） 一、棧基礎 棧是一種線性結構 相比較數組，棧對應的操作是數組的子集 只能從一端添加元素，也只能從同一端取出元素，這一端稱為棧頂 棧是一種後進先出的數

資料結構與演算法筆記（二）複雜度分析

2. 複雜度分析 2.1 什麼是複雜度分析 資料結構和演算法的本質：快和省，如何讓程式碼執行得更快、更省儲存空間。 演算法複雜度分為時間複雜度和空間複雜度，從執行時間和佔用空間兩個維度來評估資料結構和演算法的效能。 複雜度描述的是演算法執行時間（或佔用空間）與資料規模的增長關

javascript資料結構與演算法筆記（一）：棧

javascript資料結構與演算法筆記（一）：棧 一：簡介 二：ES6版Stack類（陣列） 三：ES版Stack類私有屬性的封裝 1.偽私有屬性封裝 2.真私有屬性封裝

棧（stack）及其儲存結構和特點詳解

棧是一個有著特殊規則的資料結構。我們熟悉漢諾塔遊戲（如圖 1 所示），這裡有一個明確的規則，即每次只能移動頂端的一個圓盤。 圖 1 漢諾塔遊戲 棧也有這個特點。我們可以將棧視為漢諾塔中的一個柱子，我們往這個柱子上放置圓盤，先放下去的一定是最後才能拿出來的，而最後放下去的一定是最先拿出來的。這也是棧的最

JVM內存—堆（heap）棧（stack）方法區（method） (轉)

定位 箭頭 環境 構造方法 做的 語言 .com jvm的內存 系列 JAVA的JVM的內存可分為3個區：堆(heap)、棧(stack)和方法區(method) 堆區:1.存儲的全部是對象，每個對象都包含一個與之對應的class的信息。(class的目的是得到操作指令)

C# 編程中的堆棧（Stack）和隊列（Queue）

的區別 bottom seq 序表 gin 數組 src 優秀 順序隊列 一、什麽是堆？（Heap） 堆是無序的，是一片不連續的內存域，由用戶自己來控制和釋放，如果用戶自己不釋放的話，當內存達到一定的特定值時，通過垃圾回收器（GC）來回收。 是程序運行期

Java 一維陣列實現一個棧（Stack）類

使用一維陣列編碼實現一個棧（Stack）類，要求提供以下操作：（1）boolean isEmpty()：判斷棧當前是否為空；（2）入棧操作void push(obj)：把資料元素obj插入堆疊；（3）出棧操作Object pop()：出棧，並返回刪除的資料元素；（4）Object get

資料結構與演算法入門（1）

一、資料結構 資料之間相互存在的一種或多種特定的關係的元素的集合。 邏輯結構 資料物件中資料元素之間的相互關係 1.集合結構 在資料結構中，如果不考慮資料元素之間的關係，這種結構稱為集合結構。 各個元素是平等的，共同屬性是屬於同一個集合 2.線性結構 線性結構中的資料元素之間

資料結構和演算法緒論（二）

1、演算法概念 不同的演算法可以提高計算相同算術題的效率，那麼演算法的研究就變得有意義了。 2、演算法的特性 輸入 輸出 有窮性（執行有限的步驟） 確定性（每一個步驟僅有一個含義） 可行性 3、演算法設計要求 沒有無法錯誤、有合法輸入和輸出 4、演算法效率 度量方法： 事前分析估算方法

資料結構——表示式求值（程式碼）

表示式求值 C++ 環境codeblocks17 通過 /* 表示式求值，可用運算子 +-/*(){}[] @CGQ 2018/10/30 */ #include<stdio.h> #include<stdlib.h> #include<ctype.h>

資料結構——二叉樹（程式碼）

 二叉樹 C++ 環境codeblocks17 通過 /* 二叉樹 使用了自定義的 棧 和 佇列 @CGQ 2018/10/29 */ #include <iostream> #include <stdio.h> #include <stdlib.h&

Python實現的棧（Stack）

棧是一種只能在一端進行插入和刪除操作的資料結構。 前言 python本身已有順序表（List、Tupple）的實現，所以這裡從棧開始 什麼是棧 想象在桌子上放一摞書，這就是棧。這堆書的特點就是，最後被堆進去的，永遠在最上面。從這堆書中取出一本書，哪本最方便？還是最上面的那本。

資料結構基礎之圖（下）：最短路徑

轉自：http://www.cnblogs.com/edisonchou/p/4691020.html   圖（下）：最短路徑 圖的最重要的應用之一就是在交通運輸和通訊網路中尋找最短路徑。例如在交通網路中經常會遇到這樣的問題：兩地之間是否有公路可通；在有多條公路可通的情況下，哪

資料結構基礎之圖（中）：最小生成樹演算法

轉自：http://www.cnblogs.com/edisonchou/p/4681602.html   圖（中）：最小生成樹演算法 圖的“多對多”特性使得圖在結構設計和演算法實現上較為困難，這時就需要根據具體應用將圖轉換為不同的樹來簡化問題的求解。 一、生成樹與最小生成

資料結構基礎之圖（中）：圖的遍歷演算法

轉自：http://www.cnblogs.com/edisonchou/p/4676876.html   圖（中）：圖的遍歷演算法 上一篇我們瞭解了圖的基本概念、術語以及儲存結構，還對鄰接表結構進行了模擬實現。本篇我們來了解一下圖的遍歷，和樹的遍歷類似，從圖的某一頂點出發訪問

資料結構基礎之圖（上）：圖的基本概念

轉自:http://www.cnblogs.com/edisonchou/p/4672188.html   圖（上）：圖的基本概念 前面幾篇已經介紹了線性表和樹兩類資料結構，線性表中的元素是“一對一”的關係，樹中的元素是“一對多”的關係，本章所述的圖結構中的元素則是“多對多”的

資料結構基礎之查詢（下）：雜湊表

轉自：http://www.cnblogs.com/edisonchou/p/4706253.html   查詢（下）：雜湊表 雜湊（雜湊）技術既是一種儲存方法，也是一種查詢方法。然而它與線性表、樹、圖等結構不同的是，前面幾種結構，資料元素之間都存在某種邏輯關係，可以用連線圖示