C++链表

#include<iostream>
#include<stdio.h>
using namespace std;
const int MAX_NUM = 5;

/**
*节点类
*/
template<typename T>
class Node {
public:
    Node(T data, Node* next = NULL, Node* pre = NULL) : data(data), next(next), pre(pre) {
    }
    T getData() { return data; }
    Node* getNext() { return next; }
    Node* getPre() { return pre; }
    void setNext(Node* next) { this->next = next; }
    void setPre(Node* pre) { this->pre = pre; }
    bool equal(const T& t) { return t == data; }

    T data;            //数据
    Node *next;        //后向指针
    Node *pre;        //前向指针
};


/**
*链表类
*/
template<typename T>
class List {
public:
    List() :size(0) {
        head = tail = NULL;
    }
    int length() { return size; }
    void pushBack(const T& t);                            //在尾后添加数据    
    void pushFront(const T& t);                            //在头前添加数据    
    T search_byIndex(int index);                        //根据下标获取对应元素
    Node<T>* search_byData(const T& data);                //根据数据获取对应节点
    void list_all_element();                            //遍历链表的所有元素并输出
    Node<T>* getP_node_ByIndex(int index);                //根据索引找到对应节点并返回
    void delete_byIndex(int index);                        //根据索引删除对应节点
    void delete_byData(const T& data);                    //按照数据查找并删除

    bool empty() { return number == 0; }                                            //判断是否为空
    Node<T> * getHead() { return head; }                //获得头指针a
    Node<T> * getTail() { return tail; }                //获得尾指针
    int getSize() { return size; }                        //获得当前元素总量
    void unique();                                                                    //去除重复元素
    Node<T>* delete_between(Node<T>*first, Node<T>*end);                            //删除两节点指针之间的元素，并返回被删除节点之前的节点的指针
    ~List() {
        //析构时讲占用堆区的内存释放出来
        if (size != 0) {
            Node<T> *pre = NULL;
            for (int i = 0; i < size; i++) {
                pre = tail->getPre();
                delete[] tail;
                tail = pre;
            }
        }
    }
private:
    Node<T> *head;
    Node<T> *tail;
    int size;
};

/**
*在尾后添加数据
*/
template<typename T>
void List<T>::pushBack(const T& t) {
    Node<T>* node = new Node<T>(t);
    //第一次添加
    if (size == 0) {
        head = tail = node;
        size++;                            //计数
    }
    else {//非第一次添加
        tail->setNext(node);
        node->setPre(tail);
        tail = node;
        size++;                            //计数
    }
}

/**
*在头前添加数据
*/
template<typename T>
void List<T>::pushFront(const T& t) {
    Node<T>* node = new Node<T>(t);
    head->setPre(node);
    node->setPre(NULL);
    node->setNext(head);
    head = node;
    size++;                            //计数
}

/**
*根据下标获取对应元素
*/
template<typename T>
T List<T>::search_byIndex(int index) {
    return this->getP_node_ByIndex(index)->getData();
}

/**
*根据数据获取对应节点
*/
template<typename T>
Node<T>* List<T>::search_byData(const T& data) {
    Node<T>* temp = head;
    int i;
    for (i = 0; i < size; i++) {
        if (temp->equal(data)) {
            break;
        }
        temp = temp->getNext();
    }
    if (i == size) {
        cout << "NO FOUND!!!!(return NULL)" << endl;
        return NULL;
    }
    else {
        return temp;
    }
}

/**
*遍历链表的所有元素并输出
*/
template<typename T>
void List<T>::list_all_element() {
    for (int i = 0; i < size; i++) {
        cout.width(5);
        cout.setf(ios::left);
        cout << this->search_byIndex(i) << "	";
    }
}


/**
*根据索引找到对应节点并返回
*/
template<typename T>
Node<T>* List<T>::getP_node_ByIndex(int index) {
    Node<T>* target = head;
    if (index >= size || index < 0) {
        printf("Invalid index : The size of List is %d, the index your input is %d.", size, index);
        getchar();
        exit(0);
    }
    else {
        for (int i = 0; i < index; i++) {
            target = target->getNext();
        }
    }
    return target;
}


/**
*根据索引删除对应节点
*/
template<typename T>
void List<T>::delete_byIndex(int index) {
    if (size != 0) {
        Node<T>* target = this->getP_node_ByIndex(index);
        //删除非头结点
        if (target != head) {
            target->getPre()->setNext(target->getNext());
            delete[] target;
            size--;
        }
        else {//删除头结点
            head = head->getNext();
            delete[] target;
            size--;
        }
    }
    else {
        cout << "The list is NULL!!" << endl;
    }
}

template<typename T>
void List<T>::delete_byData(const T& data) {
    if (size != 0) {
        Node<T>* target = this->search_byData(data);
        //删除非头结点
        if (target != head && target != NULL) {
            target->getPre()->setNext(target->getNext());
            delete[] target;
            size--;
        }
        else if (target == head) {//删除头结点
            head = head->getNext();
            delete[] target;
            size--;
        }

    }
    else {
        cout << "The list is NULL!!" << endl;
    }
}


template<class T>
void List<T>::unique() {
    T temp;
    Node<T>* tt = head;
    while (tt->next) {
        temp = tt->data;
        for (Node<T>* n = tt->next; n != NULL; n = n->next) {
            if (temp == n->data)
                n = delete_between(n, n)->next;
            if (!n) { break; }
        }
        tt = tt->next;
    }
}

//删除两节点指针之间的元素，并返回被删除节点之前的节点的指针,删除的是头节点则返回头指针
template<class T>
Node<T>* List<T>::delete_between(Node<T>* first, Node<T>* end) {
    //删除的节点中包括尾节点
    if (end == tail) {
        Node<T>* pre = first->pre;                //要删除的节点之前的元素
        Node<T>* temp;                            //用来记录要delete掉的节点
        Node<T>* n = pre->next;                    //用来指向被delete掉的节点的下一个节点
        for (temp = pre->next; temp->next != NULL; ) {
            n = n->next;
            delete[] temp;
            temp = n;
            size--;
        }
        //以上循环删除到尾节点之前
        delete[] temp;
        size--;
        //将删除后的尾节点的next置为NULL
        pre->next = NULL;
        tail = pre;
        return pre;
    }
    //删除的节点中不包括头节点
    else if (first != head) {
        Node<T>* pre = first->pre;
        Node<T>* next = end->next;
        for (Node<T>* temp = first; temp != next; ) {
            temp = temp->next;
            delete[] temp->pre;
            size--;
        }
        pre->next = next;
        pre->next->pre = pre;
        return pre;
    }
    //删除的第一个节点是头节点
    else {
        Node<T>* next = end->next;
        for (Node<T>* temp = head; temp != next; ) {
            temp = temp->next;
            delete[] temp->pre;
            size--;
        }
        head = next;
        if (head) { head->pre = NULL; }
        return head;
    }
}



int main() {
    List<int> list;
    int node_int[MAX_NUM] = {1,2,1,2,5};
    int a;
    Node<int> * temp;
    for (int i = 0; i < MAX_NUM; i++) {
        list.pushBack(node_int[i]);
    }
    /*for(int i = 0; i < 5; i++){
    cout << list.getData(i) << endl;
    }*/
    


    ////通过索引删除
    //while(cin >> a){
    //    list.delete_byIndex(a);
    //    list.list_all_element();
    //}

    ////通过数据查找
    //while(cin >> a){
    //    temp = list.search_byData(a);
    //    if(temp != NULL){
    //    cout << list.search_byData(a)->getData() << endl;
    //    }
    //}

    ////按照数据查找并删除
    //while(cin >> a){
    //    list.delete_byData(a);
    //    list.list_all_element();
    //}


    ////在头前添加数据
    //while (cin >> a) {
    //    list.pushFront(a);
    //    list.list_all_element();
    //}


    //去除重复元素测试
    list.list_all_element();
    list.unique();
    list.list_all_element();

}