循环链表——c++实现

循环链表，顾名思义就是循环的链表
一个单链表首尾相连，就组成了一个单循环链表
下面是我自己摸索着写的一个单循环的链表定义和一些基本的操作方法
（懒得写注释，毕竟都看到循环链表了，都是那点东西，一眼就能看懂）

typedef class CircleLinkedListNode *PtrToNode;
class CircularLinkedListNode
{
private:
    ElementType data;
    PtrToNode next;

public:
    CircularLinkedListNode()
    {
        next = NULL;
    }
    CircularLinkedListNode(ElementType x, PtrToNode ptr)
    {
        data = x;
        next = ptr;
    }
};

class CircularLinkedList
{
private:
    PtrToNode head,tail;
    int length;
public:
    CircularLinkedList();

    CircularLinkedList(ElementType x);

    ~CircularLinkedList();

    bool isEmpty();

    int getLength();

    void append(ElementType x);

    void append(PtrToNode node);

    bool removeTail();

    bool removeIndex(int index);

    void clear();

    void print();
};

    CircularLinkedList::CircularLinkedList()
    {
        head = NULL;
        tail = NULL;
        length = 0;
    }
    CircularLinkedList::CircularLinkedList(ElementType x)
    {
        head = new CircleLinkedListNode(x,NULL);
        head->next = head;
        tail = head;
        length = 1;
    }

    
    bool CircularLinkedList::isEmpty()
    {
        if(length == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    int CircularLinkedList::getLength()
    {
        return length;
    }

    void CircularLinkedList::append(ElementType x)
    {
	    if (isEmpty())
	    {
		    head = new CircularLinkedListNode(x, NULL);
		    tail = head;
		    tail->next = head;
            length++;
	    }
	    else
	    {
            
		    tail->next = new CircularLinkedListNode(x, NULL);
		    tail = tail->next;
		    tail->next = head;
		    length++;
	    }

    }

    void CircularLinkedList::append(PtrToNode node)
    {
	    if (isEmpty())
	    {
		    head = new CircularLinkedListNode(x, NULL);
		    tail = head;
		    tail->next = head;
            length++;
	    }
	    else
	    {
		    tail->next = node;
		    tail = node;
		    tail->next = head;
		    length++;
	    }   
    }

    bool CircularLinkedList::removeTail()
    {
        if(isEmpty())
        {
            return false;
        }
        else
        {
            for(PtrToNode p = head; p->Next != tail; p = p->next);
            delete tail;
            p->next = head;
            tail = p;
            length--;
            return true;
        }
    }

    bool CircularLinkedList::removeIndex(int index)
    {
        if(isEmpty() || index >= length || index < 0)
        {
            return false;
        }
        else
        {
            if(index == 0)
            {
                tail->next = head->next;
                delete head;
                head = tail->next;
                length--;
                return true;
            }
            else if(index == length - 1)
            {
                for(PtrToNode p = head; p->next != tail; p = p->next);
                p->next = head;
                delete tail;
                tail = p;
                length--;
                return true;
            }
            else
            {
                int count = 0;
                for(PtrToNode p = head; count != index - 1; p = p->next)
                {
                    count++;
                }
                PtrToNode temp = p->next;
                p->next = temp->next;
                delete temp;
                length--;
                return true;
            }

        }
    }

    void CircularLinkedList::clear()
    {
        tail->next = NULL;
        for(PtrToNode p = head->next;p != NULL; p = p->next)
        {
            delete head;
            head = p;
        }
        delete head;
        head = NULL;
        length = 0;
        
    }
    CircularLinkedList::~CircularLinkedList()
    {
        clear();
    }
    void CircularLinkedList::print()
    {
        if(isEmpty)
        {
            cout << "NULL";
        }
        else
        {
            PtrToNode p = head;
            while(p != tail)
            {
                cout << p->data << endl;
                p = p->next;
            }
            cout << p->data << endl;
        }
    }