連結串列就是有n各結點連結形成一個表，所謂結點就是包含了本身的資料元素，和一個指示直接後繼的儲存位置，即結點包含兩個部分（資料域  指標域）。但是連結串列的存取必須是從頭指標開始進行的，頭指標指向第一個結點的儲存位置，用head 表示，但head只是指向了頭結點，本身不是一個結點 ，而是一個指標。

定義結點的結構體：

struct Node{
     int data;
     Node* next;
}

#include <iostream>
using namespace std;
typedef int T;

class List{
    struct Node{
        T data;
        Node* next;
        Node(const T& d=T()):data(d),next(NULL){}
    };
    Node* head;
public:
    List():head(NULL){}
    ~List(){
        clear();    //逐個釋放
    }
    void clear(){
        Node* p = head->next;
        delete head;
        head = p;
    }
    //插入操作
    void insert(const T& t){
        Node* p = new Node(t);
        p->next = head;
        head = p;
    }
    //遍歷
    void travel(){
        Node* p = head;
        while(p!=NULL){
            cout<<p->data<<endl;
            p = p->next;
        }
    }
    //連結串列的大小
    int size(){
        Node* p = head;
        int cnt=0;
        while(p!=NULL){
        cnt++;
        p = p->next;
    }
        return cnt;
    }
    //獲取頭結點元素值
    T getHead(){
        if(head==NULL)throw"no head";
        return head->data;
    }
    //獲取尾結點元素值
    T getTail(){
        if(head==NULL)throw"no tail";
        Node* p = head;
        while(p!=NULL){
            p = p->next;
        }
        return p->data;
    }
    //判斷是否為空
    bool empty(){
        return head==NULL;
    }
    //查詢一個元素
    int find(const T& t){
        int pos=0;
        Node* p = head;
        while(p!=NULL){
            if(p->data==t){
                return pos;
            }
            p = p->next;
            pos++;
        }
        return -1;
    }
    //修改
    bool update(const T& o,const T& t){
        int pos = find(o);
        if(pos==-1){
            return false;
        }
        Node* p = getpoint(pos);    //獲得到需要修改的指標
        p->data = t;
        return true;
    }
    //獲得某個位置的指標
    Node* getpoint(int pos){
        Node* p = head;
        for(int i=0;i<pos;i++)
            p = p->next;
        return p;
    }
    //刪除元素
    bool erase(const T& t){
        int pos = find(t);
        if(pos==-1){
            cout<<"NO Node"<<endl;
        }
        if(pos==0){
            Node* p = head->next;
            delete head;
            head = p;
        }
        else{
            Node* pre = getpoint(pos-1);
            pre->next = pre->next->next;
            delete pre;
        }
    }
};
 

void insert_back(const T& t){
        Node* p = new Node(t);
        if(head == NULL){
            head = p;
        }
        else{
            getpoint(size()-1)->next = p;
        }
    }

基於單鏈表的棧的一些基本操作：

class Stack{
    List list;  //包含上面連結串列的類
public:
    //向棧頂插入一個元素
    void push(const T& t){
        list.insert(t);
    }
    //出棧
    void pop(){
        list.erase(list.getHead);
    }
    //獲得棧頂元素
    int top(){
        return list.getHead();
    }
    //判斷棧是否為空
    bool empty(){
        return list.empty();
    }
    //棧的大小
    int size(){
        return list.size();
    }
    //清空這個棧
    void clear(){
        list.clear();
    }
};
 

class Queue{
    List list;  //包含上面連結串列的類
public:
    //向佇列末插入一個元素
    void push(const T& t){
        list.insert_back(t);
    }
    //刪除隊首元素
    void pop(){
        list.erase(list.getHead);
    }
    //獲得隊首元素
    int front(){
        return list.getHead();
    }
    //獲得隊尾元素
    int back(){
        return list.getTail();
    }
    //判斷佇列是否為空
    bool empty(){
        return list.empty();
    }
    //佇列的大小
    int size(){
        return list.size();
    }
    //清空這個佇列
    void clear(){
        list.clear();
    }
};
 

同時在C++STL中 提供了棧和佇列的介面卡具體的操作如下：

棧介面卡：

s.pop()  刪除棧頂元素

s.empty() 棧為空

s.push(item) 向棧頂插入元素

s.size() 棧的大小

s.top() 獲取棧頂元素

佇列介面卡：

q.empty() 佇列為空

q.pop() 刪除隊首元素

q.size() 佇列大小

q.push(item) 向隊尾插入元素

q.front() 獲取隊首元素

q.back() 獲取隊尾元素

q.top() 返回一個優先順序高的元素 只適用於優先佇列

這些操作在STL提供下是直接可以應用的 無需上面寫大段的程式碼，只須使用前包含 <stack> <queue> 標頭檔案即可。

連結串列的逆序輸出：只給出連結串列的頭結點，逆序輸出整個連結串列。

c++程式碼簡介：

#include <iostream>
#include <stack>

using namespace std;

struct linkNode{
    int value;
    linkNode* next;
};

//建立結點
linkNode* createNode(int value){
    linkNode* pNode = new linkNode();
    pNode->value = value;
    pNode->next = NULL;
    return pNode;
}

//列印連結串列
void printNode(linkNode* phead){
    linkNode* pNode = phead;
    if(pNode==NULL){
        cout<<"list is null"<<endl;
    }
    while(pNode!=NULL){
        cout<<pNode->value<<" ";
        pNode = pNode->next;
    }
    cout<<endl;
}
//向連結串列的末端插入結點，並且儲存好連結串列的結構，所以需要傳遞一個節點引用，所以形參是一個指向指標的指標
void addToTail(linkNode** phead,int value){
    linkNode* pNew = new linkNode();
    pNew->value = value;
    pNew->next = NULL;
    if(*phead==NULL){
        *phead = pNew;
    }else{
        linkNode* pNode = *phead;
        while(pNode->next!=NULL){
            pNode = pNode->next;
        }
        pNode->next = pNew;
    }
}

void printreverse(linkNode* phead){
    linkNode* pNode = phead;
    stack<linkNode*> nodes;
    while(pNode!=NULL){
        nodes.push(pNode);
        pNode = pNode->next;
    }
    while(!nodes.empty()){
        pNode = nodes.top();
        cout<<pNode->value<<" ";
        nodes.pop();
    }
    cout<<endl;
}

//遞迴呼叫
void print_revserse_order(linkNode* phead){
    linkNode* pNode = phead;
    if(pNode!=NULL){
        if(pNode->next!=NULL){
            print_revserse_order(pNode->next);
        }
    }
    cout<<pNode->value<<" ";
}
int main()
{
    linkNode* p_Node = createNode(1);   //建立一個結點
    printNode(p_Node);
    addToTail(&p_Node,2);       //新增一個結點
    addToTail(&p_Node,3);
    addToTail(&p_Node,4);
    addToTail(&p_Node,5);
    addToTail(&p_Node,6);
    addToTail(&p_Node,7);
    addToTail(&p_Node,8);
    addToTail(&p_Node,9);
    addToTail(&p_Node,0);

    printreverse(p_Node);       // 逆序列印

    print_revserse_order(p_Node);
    return 0;
}