#include<iostream>
#include<assert.h>
using namespace std;

typedef int Datatype;
typedef struct Node   //連結串列是由一個個節點組成所以這裡單獨定義這一型別方便在連結串列類中使用
{
    Datatype _data;
    struct Node* next;
    struct Node* prev;
} Node,*pNode;

typedef class LinkList
{
private:
    pNode head;
public:
    LinkList()
    {
        head=NULL;
    }

    void pushback(Datatype x)
    {
        pNode p=new Node[sizeof(Node)];
        p->_data=x;
        p->next=NULL;
        if(head==NULL)
        {
            head=p;
            head->prev=NULL;
        }
        else
        {
            pNode cur=head;
            while(cur->next)
            {
                cur=cur->next;
            }
            cur->next=p;
            p->prev=cur;
        }
    }

    void pushfront(Datatype x)
    {
        pNode tmp=new Node[sizeof(Node)];
        if(head==NULL)
        {
            tmp->_data=x;
            head=tmp;
            head->next= NULL;
            head->prev=NULL;
        }
        else
        {
            //我們要在頭結點前再插入一個結點，需要先建立一個新的結點，將頭結點的值儲存在新節點，然後讓新節點的下
            //個結點指向頭結點的下一個結點，再讓新節點的prev指向頭結點，這樣就將新節點與原來的連結串列融合了，然後我
            //們將頭結點的資料換成x即可。
            tmp->_data=head->_data;
            tmp->next=head->next;
            tmp->prev=head;//
            head->next=tmp;
            head->_data=x;
        }
    }
    void popback()
    {
        if(head!=NULL)
        {
            pNode cur=head;
            pNode pre=NULL;
            while(cur->next)
            {
                pre=cur;
                cur=cur->next;
            }
            delete[] cur;
            cur=NULL;
            pre->next=NULL;//一定要將pre->next置為空,前面一句僅僅是將cur的值置為空，此時pre->next還指向原來的那塊空間
        }
    }

    void popfront()
    {
        if(head!=NULL)
        {
            if(head->next==NULL)
            {
                delete[] head;
                head=NULL;
            }
            else
            {
                pNode del=head;
                head=head->next;
                delete[] del;
                del=NULL;//這裡將del置為空可以防止它變為野指標
            }
        }
    }

    pNode find(Datatype x)
    {
        if(head==NULL)
        {
            return NULL;
        }
        else
        {
            pNode cur=head;
            while(cur)
            {
                if(x==cur->_data)
                {
                    return cur;
                }
                cur=cur->next;
            }
            return NULL;
        }
    }

    void insert(pNode pos,Datatype x)
    {
        assert(pos);//防止pos為空指標
        if(head==NULL)
        {
            return ;
        }
        else
        {
            pNode cur=head;
            if(head==pos)
            {
                pushfront(x);
            }
            else
            {
                while(cur)
                {
                    if(cur==pos)
                    {
                        pNode tmp=new Node[sizeof(Node)];
                        tmp->_data=cur->_data;
                        tmp->next=cur->next;
                        tmp->prev=cur;
                        cur->_data=x;
                        cur->next=tmp;
                        return ;//insert成功後不要忘了直接返回結束函式
                    }
                    cur=cur->next;
                }
                cout<<"沒有找到這個數字"<<endl;
            }
        }
    }

    void erase(pNode pos)   //刪除指定位置的結點
    {
        assert(pos);
        if(head==NULL)
        {
            return;
        }
        else
        {
            if(pos==head)
            {
                popfront();
            }
            else
            {
                pNode del=head->next;
                pNode pre=head;
                while(del)
                {
                    if(del==pos)
                    {
                        if(del->next!=NULL)
                        {
                            pre->next=del->next;
                            del->next->prev=pre;
                            delete[] del;
                            del=NULL;
                        }
                        else
                        {
                            delete[] del;
                            pre->next=NULL;
                        }
                        return;
                    }
                    del=del->next;
                    pre=pre->next;
                }
            }
        }
    }

    int use_count()   //返回連結串列中結點的數量
    {
        int count=0;
        pNode cur=head;
        while(cur)
        {
            cur=cur->next;
            count++;
        }
        return count;
    }

    void display()   //列印連結串列
    {
        pNode cur=head;
        while(cur!=NULL)
        {
            cout<<cur->_data<<endl;
            cur=cur->next;
        }
    }

    ~LinkList()
    {
        pNode cur=head;
        while(cur!=NULL)
        {
            pNode Next=cur->next;
            delete cur;
            cur=Next;
            if(cur!=NULL)
            {
                Next=Next->next;
            }
            else
                break;
        }
    }
};

void test()
{
    LinkList ls1;
    ls1.pushback(1);
    ls1.pushback(2);
    ls1.pushback(3);
    ls1.pushfront(0);
    ls1.display();
    ls1.popback();
    ls1.display();
    ls1.popfront();
    ls1.display();
    pNode ret=ls1.find(2);
    if(ret==NULL)
    {
        cout<<"沒有找到"<<endl;
    }
    else
    {
        cout<<ret->_data<<endl;
    }
    ls1.insert(ret,5);
    ls1.display();
    pNode ret2=ls1.find(2);
    ls1.erase(ret2);
    ls1.display();
    int ret3=ls1.use_count();
    cout<<ret3<<endl;
}

int main()
{
    test();
    //getchar();
    return 0;
}