循环链表简单操作 C++

            //
            CircularList.h文件
            #pragma once
template<class T>
struct listNode{
    T element;
    listNode<T>* next;
    listNode(){}
    listNode(const T&theElement){ this->element = theElement; }
    listNode(const T&theElement, listNode<T>*theNext){ this->element = theElement; this->next = theNext; }
};
//有头节点的循环链表，头节点的指针域指向第一个元素
template<class T>
class CircularList
{
public:
    CircularList();
    CircularList(const CircularList<T>&);
    ~CircularList();
    void insertFirstNode(const T& element);
    void insertLastNode(const T&element);
    void listInsert(int index, const T&element);
    void listDelete(int index);
    void print();
    int listNodeFine(const T&);
private:
    listNode<T>* ahead;
    int listSize;
};

            //
            CircularList.cpp文件
#include "CircularList.h"
#include<iostream>
usingnamespace std;
#include "CircularList.h"
#include<iostream>
usingnamespace std;

template<class T>   //构造函数
CircularList<T>::CircularList()
{
    ahead = new listNode<T>();
    ahead->next = ahead;
    listSize = 0;
}

template<class T>    //复制构造函数
CircularList<T>::CircularList(const CircularList<T>& List)
{
    ahead = new listNode<T>;
    ahead->next = ahead;                         //首先形成一个空的循环链表
    listNode<T>*current = ahead;
    listNode<T>*ListCurrent = List.ahead->next;

    if (List.ahead->next != List.ahead)             //被拷贝的链表不为空    {
        while (ListCurrent->next != List.ahead)
        {
            listNode<T>*newNode = new listNode<T>(ListCurrent->element, current->next);
            current->next = newNode;
            current = current->next;
            ListCurrent = ListCurrent->next;
            listSize++;
        }
        if (ListCurrent->next == List.ahead)
        {
            listNode<T>*newNode = new listNode<T>(ListCurrent->element, current->next);
            current->next = newNode;
            listSize++;
        }
    }
}

template<class T>                //析构函数
CircularList<T>::~CircularList()
{
    while (ahead != NULL)
    {
        listNode<T>*current = ahead->next;
        delete ahead;
        ahead = current;
    }
    cout << "析构函数调用" << endl;
}


template<class T>   //在头部插入元素void CircularList<T>::insertFirstNode(const T& element)
{
    listNode<T>*newNode = new listNode<T>(element,this->ahead->next);
    this->ahead->next = newNode;
    listSize++;
}

template<class T>   //在尾部插入元素void CircularList<T>::insertLastNode(const T&element)
{
    listNode<T>*current = this->ahead;
    while (current->next != this->ahead)
        current = current->next;
    listNode<T>*newNode = new listNode<T>(element,current->next);
    current->next = newNode;
    listSize++;
}

template<class T>  
void CircularList<T>::listInsert(int index, const T&element)
{
    listNode<T>*current = this->ahead->next;
    for (int i = 0; i < index-1; i++)
        current = current->next;
    listNode<T>*newNode = new listNode<T>(element, current->next);
    current->next = newNode;
    listSize++;
}

template<class T>    
void CircularList<T>::print()
{
    listNode<T>*current = this->ahead->next;
    while (current != this->ahead)
    {
        cout << current->element << "";
        current = current->next;
    }
    cout << endl;
}

template<class T>
void CircularList<T>::listDelete(int index)
{
    if (index<0 || index>this->listSize)
    {
        cout << "删除范围有错误，请重新输入！" << endl;
        return;
    }
    
    if (index == 0)
    {
        listNode<T>*current = this->ahead->next;
        ahead->next = current->next;
        delete current;
    }
    else
    {
        listNode<T>*current = this->ahead->next;
        for (int i = 0; i < index - 1; i++)
            current = current->next;
        listNode<T>*temp = current->next;
        current->next = temp->next;
        delete temp;
    }
    listSize--;
}

template<class T>
int CircularList<T>::listNodeFine(const T& A)
{
    this->ahead->element = A;
    listNode<T>*current = this->ahead->next;
    int index = 0;
    while (current->element != A)
    {
        index++;
        current = current->next;
    }
    if (current == ahead)
        return -1;
    elsereturn index;
}