C++ 簡單版STL list 鏈表（迭代器版）

最近課程開始上設計模式了。

苦於天天滿課的狀態，不過題目可以放到晚上去刷。

周末師大校賽挺有趣的，題目質量好高。

花了幾天寫LIST,一開始就想寫出 跟STL用法一樣的LIST，

加個迭代器然后循環着自己用。

結果發現！！！！好多坑，有C++ 模板 C++ 符號重載等等。

不過也提高了點C++ 代碼能力。感覺迭代器就是對node的封裝.....

#include <iostream>
#include <cstdio>
#include <list>
#include <stdlib.h>
#include <time.h>

template<typename T>
class Node {//雙向鏈表節點
    public:
        T val;//存儲節點值
        Node *next;
        Node *pre;
};

template<typename T>
struct List_iterator { //簡單版迭代器
    typedef Node<T>* Node;
    Node data;

    List_iterator() {
        data = 0;
    }
    List_iterator(Node other) {
        data = other;
    }
    List_iterator(const List_iterator &rhs) {
        data = rhs.data;
    }
    List_iterator& operator ++ () { //重載前置自增符號
        data = data->next;
        return *this;
    }
    T& operator * () {
        return data->val;
    }
    bool operator != (const List_iterator& rhs) {
        return (rhs.data != data);
    }
    bool operator == (const List_iterator& rhs) {
        return (rhs.data == data);
    }
};

/*
    head<->Node1<->Node2(tail)->NULL
*/

template<typename T>
class List { //雙向鏈表
    public:
        typedef Node<T> Node;
        typedef Node* pNode;
        typedef List_iterator<T> iteratorL;
    private:
        pNode head;                    //指向頭節節(頭節點不放元素)
        pNode tail;                    //指向尾節點
        int _size;                     //當前鏈表長度
    private:
        void init();                //構造初始化函數
    public:
        List();                        //默認構造函數
        List(const List &);            //拷貝函數
        ~List();                    //析構函數
        iteratorL begin();            //獲取第一個節點
        iteratorL end();            //獲取最后一個節點的下一位置
        T front();                    //返回第一個節點的值
        T back();                    //返回最后一個節點的值
        int size() const;            //返回鏈表長度
        bool empty();                //判斷鏈表是否為空,空則返回true
        void push_back(T val);        //插入值為val的節點到鏈表末尾
        void pop_back();            //刪除鏈表末尾節點
        void push_front(T val);        //插入值為val的節點到鏈表頭部
        void pop_front();            //刪除鏈表頭節點
        iteratorL insert(iteratorL pos,T val);//在指定位置插入值為val的節點
        void erase(iteratorL pos);    //刪除指定位置的值
        //[first,last)區間中查找值為val的節點,並且返回該位置迭代器，找不到則返回 end()
        iteratorL find(const iteratorL first,const iteratorL last,const T val);
        void remove(T val);            //刪除具有值為val的節點
        void sort();                //按照從小到大進行排序
        void swap(iteratorL first,iteratorL second);//交換兩節點內容 
        void clear();                                //清空鏈表內容
};

template<typename T>
void List<T>::init() {
    tail = head = new Node;
    head->next = 0;
    head->pre = 0;
    head->val = 0;
    _size = 0;
}

template<typename T>
List<T>::List() {
    init();
}

template<typename T>
List<T>::List(const List &other) {
    init();
    Node *p = other.head->next;
    while(p != 0) {
        push_back(p->val);
        p = p->next;
    }
}

template<typename T>
List<T>::~List() {
    clear();
    delete head;
}

template<typename T>
typename List<T>::iteratorL List<T>::begin() {
    return iteratorL(head->next);
}

template<typename T>
typename List<T>::iteratorL List<T>::end() {
    return iteratorL(tail->next);
}

template<typename T>
T List<T>::front() {
    if(!empty())
        return head->next->val;
}

template<typename T>
T List<T>::back() {
    return tail->val;
}

template<typename T>
int List<T>::size() const {
    return _size;
}

template<typename T>
bool List<T>::empty() {
    return (_size == 0);
}

template<typename T>
void List<T>::push_back(T val) {
    insert(end(),val);
}

template<typename T>
void List<T>::pop_back() {
    erase(iteratorL(tail));
}

template<typename T>
void List<T>::push_front(T val) {
    insert(begin(),val);
}

template<typename T>
void List<T>::pop_front() {
    erase(begin());
}

template<typename T>
typename List<T>::iteratorL
List<T>::insert(iteratorL pos,T val) {//在Pos位置插入值為Val的節點 
    pNode addN = new Node;
    ++_size;
    addN->val = val;
    if(pos != end()) {
        pNode p = pos.data;
        pNode preN = p->pre;
        addN->pre = p->pre;
        addN->next = p;
        if(preN)
            preN->next = addN;
        p->pre = addN;
    } else { //插入末尾
        tail->next = addN;
        addN->pre = tail;
        addN->next = 0;
        tail = addN;
    }
    return iteratorL(addN);
}

template<typename T>
void List<T>::erase(iteratorL pos) {
    if(pos != end()) {
        pNode p = pos.data;

        pNode preN = p->pre;
        pNode nextN = p->next;
        preN->next = nextN;
        if(p == tail)//刪除尾節點特判
            tail = preN;
        if(nextN != 0)
            nextN->pre = preN;
        delete p;
        --_size;
    }
}

template<typename T>
typename List<T>::iteratorL
List<T>::find(const iteratorL first,const iteratorL last,const T val) {
    iteratorL it = first;
    while(it != last) {
        if(*it == val)
            return it;
        ++it;
    }
    return end();//找不到返回 end()
}

template<typename T>
void List<T>::remove(T val) {
    iteratorL it = find(begin(),end(),val);
    if(it!=end()) {
        erase(it);
    }
}

template<typename T>
void List<T>::clear() {
    while(empty() == false) {
        pop_back();
    }
}

template<typename T>
void List<T>:: swap(iteratorL first,iteratorL second)//使用選擇排序 
{
    if(first == end() || second == end())//避免空指針 
        return;
    T tmp = first.data->val;
    first.data->val = second.data->val;
    second.data->val = tmp;
}

template<typename T>
void List<T>:: sort()//使用選擇排序 
{
    if(empty() == false){
        iteratorL minI;
        for(iteratorL it = begin();it!=end();++it)
        {
            minI = it;//最小值初始化 
            for(iteratorL it2 = it;it2!=end();++it2)
            {
                if(minI.data->val > it2.data->val){
                    minI = it2;
                }
            }
            swap(minI,it);//交換兩迭代器所指位置的內容 
        }        
    }
}

//打印輸出List
template<typename T>
void print(List<T> q) {
    for(List<int>::iteratorL it = q.begin(); it!=q.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;
}

int main() {
    //測試 添加 刪除 
    List<int> q;
    q.push_back(1);
    q.push_back(2);
    q.push_back(3);
    print(q);

    q.pop_back();
    q.push_front(3);
    q.push_front(4);
    q.pop_front();
    print(q);

    q.clear();
    print(q);

    q.push_back(1);
    List<int>::iteratorL it = q.begin();
    *it = 2;
    print(q);

    q.insert(q.begin(),3);
    print(q);
    
    //查找元素3 
    if(q.find(q.begin(),q.end(),3) != q.end()){
        printf("find 3\n");
    }
    
    //移除remove測試 
    q.remove(3);
    if(q.find(q.begin(),q.end(),3) != q.end()){
        printf("find 3\n");
    }
    
    
    //測試從小到大排序 
    q.clear();
    srand(static_cast<int>( time(0) ) );
    for(int i=0;i<20;++i){
        q.push_back(rand()%20);
    }
    print(q);
    q.sort();
    print(q);
    return 0;
}