【ADT】循环链表ADT模板—基础操作

包含了基础操作的adt模板

// 循环链表.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
#include <sstream>
#include <stack>
#include <map>
#include <ctime>
#include <array>
#include <set>
#include <list>
using namespace std;
template<class ElemType>
struct LinkNode
{
    ElemType data;
    LinkNode<ElemType>* next;
    LinkNode(LinkNode<ElemType>* ptr = NULL) 
    { 
        next = ptr;  //构造函数1，用于构造头结点
    }
    LinkNode(const ElemType& item, LinkNode<ElemType>* ptr = NULL) 
    {
        //构造函数2，用于构造其他结点   
        //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
        next = ptr;
        data = item;
    }
    //int getNum(){ return number; } //取得结点的序号 
    ElemType getData() 
    { 
        return data; //取得结点的数据域的值 
    }   
    void SetLink(LinkNode<ElemType>* link) 
    { 
        next = link; 
        //修改结点的next域 
    } 
    void SetLink(ElemType value) 
    { 
        data = value; 
        //修改结点的next域
    } 
};
//带头结点的循环单链表 

template<class ElemType>

class CirLinkList {
private:
    LinkNode<ElemType>* head;   // 头结点
    LinkNode<ElemType>* tail;   // 尾结点
public:
    //无参数的构造函数
    CirLinkList() 
    { 
        head = NULL;
        tail = NULL; 
    }
    CirLinkList(CirLinkList<ElemType>& List);//拷贝构造函数
    ~CirLinkList() 
    { 
        //析构函数
        del_clear();
    }
    void del(int n)
    {
        //删除链表指定元素
        LinkNode<ElemType>* p = getPlace(n);
        if (p == head && p == tail)
        {
            //only have one
            //没写删除元素
            head = NULL;
            tail = NULL;
            delete p;
            return;
        }
        if (p == head)
        {
            LinkNode<ElemType>* p1 = head->next;
            head = p1;
            tail->next = head;
            return;
        }
        if (p == tail)
        {
            LinkNode<ElemType>* p1 = getPlace(n - 1);
            p1->next = head;
            tail = p1;
            return;
        }
        if (p != head && p != tail)
        {
            LinkNode<ElemType>* p1 = getPlace(n - 1);
            p1->next = p->next;
            return;
        }
        return; 
    }
    void del_clear()
    {
        //释放链表

        return;
    }
    int size() const//ok
    {
        //返回链表的长度
        int cnt = 0;
        LinkNode<ElemType>* p;
        bool fir = 0;
        p = head;
        if (p == NULL)
        {
            return 0;
        }
        while (1)
        {
            if (p == head && fir == 1)
                break;
            //------------
            //循环操作
            cnt++;
            //------------
            fir = 1;
            p = p->next;
        }
        return cnt;
    }
    bool empty() const//ok
    {
        //判断链表是否为空表
        if (size() == 0 || head == NULL)
        {
            return 0;
        }
        return 1;
    }
    LinkNode<ElemType>* getHead() //ok
    { 
        //获取循环链表头结点
        return head; 
    }
    LinkNode<ElemType>* getTail() //ok
    { 
        //获取循环链表尾结点
        return tail; 
    }
    LinkNode<ElemType>* getPlace(int n)
    {
        LinkNode<ElemType>* p;
        p = head;
        if (p == NULL)
        {
            cout << "wrong! NULL List!!!" << endl;
            return NULL;
        }
        while (n--)
        {
            p = p->next;
        }
        return p;
    }
    ElemType getNum(int n)
    {
        LinkNode<ElemType>* p = getPlace(n);
        return p->data;
    }
    bool Insert_next(int pos, ElemType num)
    {
        //在链表的第pos个位置之后插入num元素
        
    }
    bool InsFirst(ElemType num)//ok
    {
        //在首结点之前插入一个结点
        if (head == NULL)
        {
            //空链表插入
            head = new LinkNode<ElemType>;
            head->data = num;
            tail = head;
            tail->next = head;
            return 0;
        }
        LinkNode<ElemType>* p = new LinkNode<ElemType>;
        p->next = head;
        p->data = num;
        head = p;
        tail->next = head;
        return 1;
    }
    void pushback(ElemType num)//ok
    {
        if (head == NULL)
        {
            //空链表插入
            head = new LinkNode<ElemType>;
            head->data = num;
            tail = head;
            tail->next = head;
            return;
        }
        LinkNode<ElemType>* p = new LinkNode<ElemType>;
        p->data = num;
        p->next = head;
        tail->next = p;
        tail = p;
        return;
    }
    bool ListTraverse() const//ok
    {
        LinkNode<ElemType>* p;
        bool fir = 0;
        p = head;
        if (p == NULL)
        {
            cout << "wrong! NULL List!!!" << endl;
            return 0;
        }
        while (1)
        {
            if (p == head && fir == 1)
                break;
            //------------
            //循环操作
            cout << p->data;
            if (p->next != head)
                cout << "->";
            else
                cout << endl;
            //------------
            fir = 1;
            p = p->next;
        }
        return 1;
    }
};
//CirLinkList<int> a;
int main()
{
    CirLinkList<int> a;
    a.pushback(10);
    a.InsFirst(999);
    a.pushback(546);
    a.ListTraverse();
    a.del(0);
    a.del(0);
    cout << a.empty() << endl;
    cout << a.size() << endl;
    cout << a.getNum(4) << endl;
    a.ListTraverse();
	return 0;
}