线性表：实现单链表和子类栈(Stack)及单向队列(Queue) [C++]

　　刚刚开始学习c++。之前c的内容掌握的也不多，基本只是一本概论课的程度，以前使用c的struct写过的链表、用python写过简单的数据结构，就试着把两者用c++写出来，也是对c++的class，以及继承中的public/protected/private的性质进行初步了解。第一次写头文件.h和源文件.cpp分开的c++代码。过程中参考了ProLyn和kgvito的代码，基本就是百度“单链表 c++”的前几个搜索结果。

 　　节点listNode还是用struct来写了，因为我想节点除了构造没有什么方法需要实现，变量和构造也总是需要处于public的状态方便其他类函数调用。

　　栈是保持先进后出(First In Last Out, 或者FILO)的数据结构，在这里只是定义了最基本的五种方法，实现从尾部添加、从尾部弹出；队列是保持先进先出(First In First Out, FIFO)的数据结构，同样定义了最基本的方法实现从尾部添加从头部弹出。二者我都使用了private继承，因为除了重新封装list的几种方法外，多数list的方法都不需要出现在这两种数据结构中，我认为禁止public访问这些方法比较好。

// linked_list.h
// Base class linked list "linkList", derived "linkStack" & "linkQueue" 
typedef int DataType;

// constructing struct "listNode"
struct listNode
{
    DataType nodeVal;
    listNode* nextNode;
    listNode(const DataType x);            // listNode construct func
};

// constructing base class "linklist"
class linkList
{
private:                                // private variables headNode & tailNode
    listNode* headNode;
    listNode* tailNode;
// construction functions, and operator overload
public:
    linkList();
    linkList(const linkList& lista);
    linkList& operator=(linkList& lista);
    DataType operator[](int index);
// other functions, public
public:
    bool isEmpty();
    void PrintList();
    void PushBack(const DataType& x);
    void PushFront(const DataType& x);
    void PopBack();
    void PopFront();
    DataType PeekBack();
    DataType PeekFront();
    void InsertNext(listNode* pos, DataType x);
    void DeleteNext(listNode* pos);
    void Delete(listNode* pos);
    void Clear();
    void Remove(DataType x);
    void RemoveAll(DataType x);
    void Sort();
    int GetLength();
    listNode* Find(DataType x);
};

// derived class linkStack
class linkStack : private linkList
{
public:
    linkStack();
    linkStack(const linkStack& stack1);
    linkStack& operator=(linkStack& stack1);
// the least functions needed
public:
    bool isEmpty();
    int getSize();
    void PushBack(const DataType& x);
    void PopBack();
    DataType PeekBack();
};

// derived class linkQueue
class linkQueue : private linkList
{
public:
    linkQueue();
    linkQueue(const linkQueue& queue1);
    linkQueue& operator=(linkQueue& queue1);

public:
    bool isEmpty();
    int getSize();
    void PushBack(const DataType& x);
    void PopFront();
    DataType PeekFront();
}

 

　　对struct listNode，class linkList, linkStack, linkQueue的方法的具体实现，后两者基本只是对于linkList的重新封装，为了能在private继承的子类中实现，也不得不在linkList中添加了一些没什么用处的函数。其中构造函数和赋值下标运算重载的写法都是现学的…如果现学的不到位请不吝赐教！

#include <iostream>
#include "linked_list.h"
using namespace std;
// construction func for listNode
listNode::listNode(const DataType x)
    :nodeVal(x), nextNode(nullptr)
{}
// construction funcs for linkList
linkList::linkList()                        // without argument
    : headNode(nullptr), tailNode(nullptr)
{}

linkList::linkList(const linkList& lista)    // with argument
    : headNode(nullptr), tailNode(nullptr)
{
    if (lista.headNode) {
        listNode* tmp = lista.headNode;
        while (tmp->nextNode) {
            PushBack(tmp->nodeVal);
            tmp = tmp->nextNode;
        }
        PushBack(tmp->nodeVal);
    }
}
// operator reload =
linkList& linkList::operator=(linkList &lista) {
    if (this != &lista) {
        swap(headNode, lista.headNode);
        swap(tailNode, lista.tailNode);
    }
    return *this;
}
// operator reload [](index)
DataType linkList::operator[](int index) {
    if (index < 0 || headNode == nullptr) {
        cout << "Invalid index!" << endl;
        return -1;
    }
    else {
        listNode* tmp = headNode;
        int i;
        while (tmp != nullptr && i < index) {
            tmp = tmp->nextNode;
            i++;
        }
        if (tmp == nullptr) {
            cout << "Invalid index!" << endl;
            return -1;
        }
        else {
            return tmp->nodeVal;
        }
    }
}

bool linkList::isEmpty() {
    if (headNode) {
        return true;
    }
    else {
        return false;
    }
}

int linkList::GetLength() {
    int count = 0;
    listNode* tmp = headNode;
    while (tmp) {
        count++;
        tmp = tmp->nextNode;
    }
    return count;
}

void linkList::PrintList() {
    listNode* tmp = headNode;
    if (tmp) {
        cout << tmp->nodeVal;
        tmp = tmp->nextNode;
        while (tmp) {
            cout << "->" << tmp->nodeVal;
            tmp = tmp->nextNode;
        }
        cout << endl;
    }
    else {
        cout << "Empty linked list!" << endl;
    }
}

void linkList::PushBack(const DataType& x) {
    if (headNode) {
        tailNode->nextNode = new listNode(x);
        tailNode = tailNode->nextNode;
    }
    else {
        headNode = new listNode(x);
        tailNode = headNode;
    }
}

void linkList::PushFront(const DataType& x) {
    if (headNode) {
        listNode* tmp = new listNode(x);
        tmp->nextNode = headNode;
        headNode = tmp;
    }
    else {
        headNode = new listNode(x);
        tailNode = headNode;
    }
}

void linkList::PopBack() {
    if (headNode) {
        if (headNode->nextNode) {
            listNode* tmp = headNode;
            while (tmp->nextNode != tailNode) {
                tmp = tmp->nextNode;
            }
            delete tailNode;
            tmp->nextNode = nullptr;
            tailNode = tmp;
        }
        else {
            delete headNode;
            headNode = nullptr;
            tailNode = nullptr;
        }
    }
    else {
        cout << "Empty linked list!" << endl;
    }
}

void linkList::PopFront() {
    if (headNode) {
        if (headNode->nextNode) {
            listNode* tmp = headNode->nextNode;
            delete headNode;
            headNode = tmp;
        }
        else {
            delete headNode;
            headNode = nullptr;
            tailNode = nullptr;
        }
    }
    else {
        cout << "Empty linked list!" << endl;
    }
}

DataType linkList::PeekBack() {
    if (tailNode) {
        return tailNode->nodeVal;
    }
    else {
        cout << "Empty linked list!" << endl;
        return -1;
    }
}

DataType linkList::PeekFront() {
    if (headNode) {
        return headNode->nodeVal;
    }
    else {
        cout << "Empty linked list!" << endl;
        return -1;
    }
}

listNode* linkList::Find(DataType x) {
    listNode* targetNode = headNode;
    while (targetNode) {
        if (targetNode->nodeVal == x) {break;}
    }
    return targetNode;
}

void linkList::InsertNext(listNode* pos, DataType x) {
    if (pos) {
        if (pos == tailNode) {
            listNode* tmp = new listNode(x);
            pos->nextNode = tmp;
            tailNode = tmp;
        }
        else {
            listNode* tmp = new listNode(x);
            tmp->nextNode = pos->nextNode;
            pos->nextNode = tmp;
        }
    }
    else {
        cout << "Invalid position!" << endl;
    }
}

void linkList::DeleteNext(listNode* pos) {
    if (pos) {
        if (pos == tailNode) {
            cout << "Invalid node!" << endl;
        }
        else {
            listNode* tmp = (pos->nextNode)->nextNode;
            delete pos->nextNode;
            pos->nextNode = tmp;
        }
    }
    else {
        cout << "Invalid node!" << endl;
    }
}

void linkList::Remove(DataType x) {
    if (headNode) {
        if (headNode->nextNode) {
            listNode* tmp = headNode;
            while (tmp->nextNode) {
                if ((tmp->nextNode)->nodeVal == x) {
                    DeleteNext(tmp);
                    break;
                }
                tmp = tmp->nextNode;
            }
        }
        else {
            if (headNode->nodeVal == x) {PopFront();}
        }
    }
}

void linkList::RemoveAll(DataType x) {
    if (headNode) {
        listNode* tmp = headNode;
        while (tmp->nextNode) {
            if ((tmp->nextNode)->nodeVal == x) {
                if (tmp->nextNode == tailNode){
                    PopBack();
                    break;
                }
                else {DeleteNext(tmp);}
            }
            tmp = tmp->nextNode;
        }
        if (tmp->nodeVal == x) {
            PopBack();
        }
    }
}

void linkList::Clear() {
    if (headNode) {
        listNode* prev = headNode;
        listNode* tmp;
        while (prev->nextNode) {
            tmp = prev->nextNode;
            delete prev;
            prev = tmp;
        }
        headNode = nullptr;
        tailNode = nullptr;
    }
}
// construction funcs for linkStack
linkStack::linkStack()                            // without arguments
    :linkList()
{}

linkStack::linkStack(const linkStack& stack1)    // with an argument
    :linkList(stack1)
{}
// other public funcs for linkStack
bool linkStack::isEmpty() {
    return linkList::isEmpty();
}

int linkStack::getSize() {
    return linkList::GetLength();
}

void linkStack::PushBack(const DataType& x) {
    linkList::PushBack(x);
}

void linkStack::PopBack() {
    linkList::PopBack();
}

DataType linkStack::PeekBack() {
    return linkList::PeekBack();
}
// construction funcs for linkQueue
linkQueue::linkQueue()
    :linkList()
{}

linkQueue::linkQueue(const linkQueue& queue1)
    :linkList(queue1)
{}
// other public funcs for linkQueue
bool linkQueue::isEmpty() {
    return linkList::isEmpty();
}

int linkQueue::getSize() {
    return linkList::GetLength();
}

void linkQueue::PushBack(const DataType& x) {
    linkList::PushBack(x);
}

void linkQueue::PopFront() {
    linkList::PopFront();
}

DataType linkQueue::PeekFront() {
    return linkList::PeekFront();
}

 

　　最后还有测试代码，和主题没什么关系，但是从以前用python学习数据结构开始我就喜好把测试代码写成假交互式，所以索性贴在这里方便取用。

#include <iostream>
#include "linked_list.h"
#include <stdlib.h>
#include <map>

using namespace std;

static map<string, int>stringVal {
    {"Exit", 0},
    {"Printlist", 1},
    {"Pushback", 2},
    {"Pushfront", 3},
    {"Popback", 4},
    {"Popfront", 5},
    {"Clear", 6},
    {"Remove", 7},
    {"Removeall", 8},
    {"Sort", 9},
    {"Getlength", 10},
    {"Index", 11},
    {"Peekback", 12},
    {"Peekfront", 13}
};

int test_list() {
    linkList list1;
    cout << ">> Linked list tesing.\n"
        ">> Enter a direction, namely Printlist, Pushback, Pushfront, Popback, Peekback, "
        "Popfront, Peekfront, Clear, Remove, Removeall, Sort, Getlength or Index," 
        "enter Exit to exit." << endl;
    string direction;
    DataType parameter;
    int param;
    while (1) {
        cout << ">> ";
        cout.flush();
        cin >> direction;
        switch(stringVal[direction])
        {
            case 0:
                return 0;
            case 1:
                list1.PrintList();
                break;
            case 2:
                cin >> parameter;
                list1.PushBack(parameter);
                break;
            case 3:
                cin >> parameter;
                list1.PushFront(parameter);
                break;
            case 4:
                list1.PopBack();
                break;
            case 5:
                list1.PopFront();
                break;
            case 6:
                list1.Clear();
                break;
            case 7:
                cin >> parameter;
                list1.Remove(parameter);
                break;
            case 8:
                cin >> parameter;
                list1.RemoveAll(parameter);
                break;
/*            case 9:
                list1.Sort();
                break;*/
            case 10:
                param = list1.GetLength();
                cout << ">> " << param << endl;
                break;
            case 11:
                cin >> param;
                parameter = list1[param];
                cout << ">> " << parameter << endl;
                break;
            case 12:
                parameter = list1.PeekBack();
                cout << ">> " << parameter << endl;
                break;
            case 13:
                parameter = list1.PeekFront();
                cout << ">> " << parameter << endl;
        }
    }
    return 0;
}

int test_stack() {
    linkStack stack1;
    cout << ">> Linked list stack tesing.\n"
        ">> Enter a direction, namely Pushback, Popback or Peekback, "
        "enter Exit to exit." << endl;
    string direction;
    DataType parameter;
    int param;
    while (1) {
        cout << ">> ";
        cout.flush();
        cin >> direction;
        switch(stringVal[direction])
        {
            case 0:
                return 0;
            case 2:
                cin >> parameter;
                stack1.PushBack(parameter);
                break;
            case 4:
                stack1.PopBack();
                break;
            case 12:
                parameter = stack1.PeekBack();
                cout << ">> " << parameter << endl;
                break;
        }
    }
    return 0;
}

int main() {
    test_stack();
    return 0;
}