[C++] 数据结构应用——链表

C++ 数据结构应用——链表

---

代码已经封装成class啦，方便使用。

---

头文件：Linklist.h

#include <iostream>
/******************************************************
Copyright: University of Science & Technology Beijing
Author: Turing Aaron
Date: 2017-05
Description:
        ProgrammingLanguage: C++
        FunctionName   -------- Description
        Createlist()            创建链表，申请链表头节点的空间，并将头节点的next指针指向NULL。
        ListInsert()            按给定链表位置序号找到位置并将元素插入到该序号后面。
        ListClear()             遍历链表，依次释放节点的内存。
        ListDel()               按照给定序列的值从链表中删除该结点。
        GetElem()               按序号查找链表中的元素，并返回该节点的指针。
        LocateElem()            按值查找（定位）链表中的元素，并返回该节点的指针。
        print()                 遍历链表并打印元素的data.
        isEmpty()               判断链表是否为空。
        Adjmax()                计算相邻k个节点data值之和最大的第一节点。

*******************************************************/

class LinkList
{
public:
    //链表的构造函数，调用私有方法中的Creatlist()，下同，都是通过公共函数调用私有函数
    LinkList() { Createlist(); }
    int Adjmax(const int & k) {
        return Adjmax(head, k);
    }

    const int & GetElem(int i) {
        return GetElem(head, i)->data;
    }
    const int & LocateElem(const int & data) {
        LocateElem(head, data);
    }
    bool ListInsert(const int &i, const int & data) {
        return ListInsert(head, i, data);
    }
    bool ListDel(const int &i) {
        ListDel(head, i);
    }
    void ListClear() {
        ListClear(head);
    }
    void print() {
        print(head);
    }
    bool isEmpty() {
        return isEmpty(head);
    }

private:
    struct LinkNode
    {
        int data;
        LinkNode *next;

        //LinkNode的初始化函数（调用new时会调用这个函数）
        LinkNode(const int & data, LinkNode *next = NULL)
            : data(data), next(next) { }
    };

    LinkNode *head;

    void Createlist();
    int Adjmax(LinkNode * & L, const int & k);
    void ListClear(LinkNode * & H);
    LinkNode * GetElem(LinkNode * H, int i) const;
    LinkNode * LocateElem(LinkNode *H, const int & data) const;
    bool ListInsert(LinkNode * & H, const int & i, const int & data) const;
    bool ListDel(LinkNode * & H, const int & i);
    void print(LinkNode * H);
    bool isEmpty(LinkNode * & head);

};

/*******************************************************
Function:       Adjmax().
Description:    计算相邻k个节点data值之和最大的第一节点.
Arguments:      链表头节点 LinkNode * & L, 链表长度 const int & k .
Variables:
        VariableName   -------- Description
        LinkNode* p             记录当前区间头指针
        LinkNode* q             记录当前区间尾指针
        int sum                 记录当前区间内所有data之和；
        int maxSum              记录和最大的值；
        int maxNode             记录和最大的那个区间的第一个节点位置；
        int curNode             记录当前区间第一个节点位置。

Return:         和最大的第一节点在链表中的序号
*******************************************************/
int LinkList::Adjmax(LinkNode * & L, const int & k) {
    //检测空链表
    if (L->next == NULL) return 0;

    //curNode为当前计数区间的头一个结点
    int sum = 0, maxSum = 0, maxNode = 1, curNode = 1;
    LinkNode *p = NULL, *q = NULL;
    p = q = L->next;

    //根据k的范围移动q指针,sum记录为q到p区间内的和
    //初始化sum，记录和为[1, k]的数据。
    for (int i = 1; i <= k ; i++) {
        sum += q->data;
        q = q->next;
        if(q==NULL){
            std::cout << "[-] ---------- 您输入的k值小于链表长度 ----------" << std::endl;
            return maxNode;
        }
    }
    maxSum = sum;

    //开始移动长度为k的区间，减去前一个元素，加上后一个元素，同时移动curNode，如果sum更大，则更新maxNode
    while (q) {
        sum -= p->data;
        p = p->next;
        curNode++;
        sum += q->data;

        q = q->next;
        if (sum > maxSum) {
            maxSum = sum;
            maxNode = curNode;
        }
    }
    return maxNode;
}

//创建链表，申请链表头结点的空间，并将头节点的next指针指向NULL。
void LinkList::Createlist() {
    head = new LinkNode(0);
}

//遍历链表，依次释放结点的内存。
void LinkList::ListClear(LinkNode * & H) {
    LinkNode * p;
    p = H;
    //从头结点开始循环删除
    while (p)
    {
        LinkNode *q;
        q = p->next;
        delete p;
        p = q;
    }

}

//按序号查找链表中的元素，并返回该节点的指针。
LinkList::LinkNode * LinkList::GetElem(LinkNode * H, int i) const {
    //输入的i小于0或链表为空时返回NULL
    if (i < 0)
        return NULL;
    //新建指针指向表头
    LinkNode * P = H;
    //由于是从表头开始遍历，所以开始时位置为-1
    int j = -1;
    //从表头开始遍历i个节点
    while (P->next && j < i)
    {
        P = P->next;
        ++j;
    }
    //成功遍历到第i个节点，返回该元素的指针
    if (i == j) return P;
    //否则返回空指针
    else return NULL;
}

//按值查找（定位）链表中的元素，并返回该节点的指针。
LinkList::LinkNode * LinkList::LocateElem(LinkNode *H, const int & data) const {
    //新建指针指向第一个元素
    LinkNode * P = H->next;
    //遍历链表，如果没找到data，P指针为NULL
    while (P && P->data != data)
        P = P->next;
    return P;

}

//按给定链表位置序号找到位置并将元素插入到该序号后面。
bool LinkList::ListInsert(LinkNode * & H, const int & i, const int & data) const {
    LinkNode * p, *q;
    if (i == 0) p = H;
    else p = GetElem(H, i - 1);
    if (p == NULL)
        return false;
    else
    {
        //在q中存入数据，并把p指针的下一位给新节点q
        q = new LinkNode(data, p->next);
        p->next = q;
        return true;
    }
}

//按照给定序列的值从链表中删除该结点。
bool LinkList::ListDel(LinkNode * & H, const int & i) {
    LinkNode *p, *q;
    //如果输入位置为0，则从头开始删除
    if (i == 0)
        p = H;
    //如果不是，则查找该元素
    else
        p = GetElem(H, i - 1);
    if (p&&p->next)
    {
        q = p->next;
        p->next = q->next;
        delete q;
        return true;
    }
    else
        return false;
}

//遍历链表并打印元素的data.
void LinkList::print(LinkNode * H) {
    if (H == NULL)
        return;
    for (LinkNode *p = head->next; p; p = p->next) {
        std::cout << p->data << "\t";
    }
    std::cout << std::endl;
}

//判断链表是否为空。
inline bool LinkList::isEmpty(LinkNode * & head) {
    return head == NULL ? true : false;
}

---

主文件：list_app.cpp

#include "LinkList.h"
#include <string>
#include <ctype.h>
#include <fstream>
#include <sstream>
#include <limits>

using namespace std;
int main()
{

    cout << "实验1：链表的应用 -- 作者：Turing Aaron" << endl;
    while (true)
    {
    menu:
        cout << "\n[+] 是否创建链表？\n"
             << "1) 创建链表\t2) 退出系统\t3) 从文件读入数据" << endl;

        //读入操作数并将第一个字符做为操作数
        string op_input;
        cin.clear();
        getline(cin, op_input);
        int op = op_input[0] - '0';

        //1） 创建链表
        if (op == 1)
        {

            //---初始化链表---
            cout << "[+] ---------- 正在初始化链表... ----------" << endl;
            LinkList *myList = new LinkList;
            cout << "[+] ---------- 初始化完毕，接下来请输入k值 ----------" << endl;
            int k = 0;
            while (true)
            {
                cin >> k;
                if (cin.good())
                    break;
                else if (cin.fail())
                {
                    cout << "[-] ---------- k值输入错误，请重新输入！----------" << endl;
                    //清空输入流
                    cin.clear();
                    cin.ignore(numeric_limits<streamsize>::max(), '\n');
                }
            }

            //---数据读取---
            cout << "[+] ---------- 请输入数据，#结束输入 ----------" << endl;
            cin.clear();
            int data = 0, listLen = 0;
            while (true)
            {
                cin >> data;

                //如果读入的是数字，则插入链表
                if (cin.good())
                    myList->ListInsert(listLen++, data);

                //如果输入的不是数字，输入流cin的fail会被置位，此时读入一个字符，判断是#还是非法字符。
                else if (cin.fail())
                {
                    char c = getchar();
                    if (c == '#')
                        break;
                    cin.ignore();
                    cout << "[-] ---------- 输入的【 " << c << " 】非法，该输入跳过! ----------" << endl;
                    //清空错误输入流
                    cin.clear();
                }
            }

            //---判断链表内是否有数据---
            if (myList->isEmpty())
            {
                myList->ListClear();
                goto menu;
            }

            //---输出链表---
            cout << "[+] ---------- 您输入的链表为： ----------" << endl;
            myList->print();

            //---调用Adjmax()求值---
            cout << "[+] ---------- 开始计算相邻 [ " << k << " ] 个节点和最大的第一个节点 ----------" << endl;
            int maxNode = myList->Adjmax(k);
            if (maxNode == 0)
                cout << "[-] ---------- 链表为空！请检查！----------" << endl;
            else
            {
                cout << "[+] 相邻 " << k << " 个结点data值之和为最大的第一结点为： " << endl;
                cout << "[+] 序号" << maxNode << ", data值" << myList->GetElem(maxNode - 1) << endl;
            }
            cout << "[+] ---------- 计算结束 ----------" << endl;

            //---析构链表---
            myList->ListClear();

            //---清除输入流---
            cin.clear();
            cin.ignore(numeric_limits<streamsize>::max(), '\n');
        }

        //2） 退出系统
        else if (op == 2)
        {
            cout << "[+] ---------- 感谢使用，再见 ----------" << endl;
            exit(0);
        }

        //3） 从文件读入数据
        else if (op == 3)
        {
            //------从文件读入数据------
            string file_name;
            cout << "[+] ----------- 请输入要读取的文件名字 ---------" << endl;
            getline(cin, file_name);
            ifstream fin(file_name);
            //------打开文件失败------
            if (!fin)
            {
                cout << "[-] ---------- 找不到数据文件，请检查！ ----------" << endl;
                goto menu;
            }
            //在读到文件结束以前
            while (fin.peek() != EOF)
            {
                int k = 0;
                string k_input, data_input;
                getline(fin, k_input);
                //如果k的输入非空且第一个字符为数字，则判断为k的输入有效，否则退出循环
                if (!k_input.empty())
                    k = k_input[0] - '0';
                else
                    break;

                //建立链表
                LinkList *myList = new LinkList;
                getline(fin, data_input);

                //将data字符串输入变为数据流，方便链表读取
                istringstream sin(data_input);
                int data = 0, listLen = 0;
                while (sin >> data)
                {
                    myList->ListInsert(listLen++, data);
                }

                //---输出链表---
                cout << "[+] ---------- 您输入的链表为： ----------" << endl;
                myList->print();

                //---调用Adjmax()求值---
                cout << "[+] ---------- 开始计算相邻 [ " << k << " ] 个节点和最大的第一个节点 ----------" << endl;
                int maxNode = myList->Adjmax(k);
                if (maxNode == 0)
                    cout << "[-]  ---------- 链表为空！请检查！ ----------" << endl;
                else
                {
                    cout << "[+] 相邻 " << k << " 个结点data值之和为最大的第一结点为： " << endl;
                    cout << "[+] 序号" << maxNode << ", data值" << myList->GetElem(maxNode - 1) << endl;
                }
                cout << "---------------------------------------------------------------------------------------" << endl;

                //---析构链表---
                myList->ListClear();
            }
            fin.close();
        }

        //非法参数
        else
            cout << "[-] ---------- 非法参数，请重试！ ----------" << endl;
    }
    return 0;
}

其他的以后有空再补充哈