ADT—双向链表

插入到 头结点，尾结点

删除 头结点，尾结点

考虑到了《数据结构 使用C语言》关于双向链表,没有考虑到的情况

 

#pragma once

template<typename L>
struct Node //双向链表结点
{
    L data;
    Node *next; //后
    Node * prior;//前
};

template<typename L>
class List
{
private:
    Node<L> * headNode;
    int size;

public:
    List();
    ~List();
    

    void Add(L value);
    bool Insert(int index,L x);  //插入
    bool Delete(L value);
    int GetList(int index);
    void Destroy();
    void ListShow();
    int Length();
};

template<typename L>
List<L>::List()
{
    size = 0;
    headNode = new Node<L>;
    headNode->next = NULL;
    headNode->prior = NULL;
}

template<typename L>
List<L>::~List ()
{
}

template<typename L>
int List<L>::Length()
{
    return size;
}

template<typename L>
void List<L>::Add (L value)  //加到链表后面
{
    if(size == 0)  //空链表
    {
        Node<L> * addNode = new Node <L>;  
        addNode ->data = value;
        addNode ->next = NULL;
        addNode ->prior = NULL;
        headNode = addNode;    //结点为头结点
        size = 1;
        return ;
    }
    else if (size == 1)
    {
        Node<L> * addNode = new Node <L>;  
        addNode ->data = value;
        addNode ->next = NULL;
        addNode ->prior = headNode;
        headNode -> next = addNode;    //结点为头结点
        size = 2;
        return ;
    }
    else  //中间普通插入
    {
        Node<L> * p = headNode ;  
        while(p ->next != NULL)
        {
            p = p->next ;
        }
        Node<L> * addNode = new Node <L>;  
        addNode ->data = value;
        addNode ->prior = p ;
        addNode ->next = NULL;
        p ->next = addNode ;
        size ++;
        return ;
    }
}

template<typename L>
bool List<L>::Insert (int index,L x)
{
    
    if((index < 1) || (index >Length())) return 0;
    else
    {
        Node<L> * p;
        Node<L> * newNode;

        p = headNode;
        int j = 0;
        while(p->next !=NULL &&j <index-1)
        {
            p = p->next;
            j++;
        }

        newNode = new Node<L>;     //创建新结点q
        newNode->data = x;
        

        if( p ->prior == NULL) //插入到头结点
        {
            newNode->prior = NULL ;
            newNode->next = p ;
            p->prior = newNode;
            headNode = newNode;
            size ++;
            return true;
        }
        else 
        {
            newNode->prior = p->prior;
            p->prior ->next = newNode;
            newNode->next = p ;
            p->prior = newNode;
            
            size ++ ;
            return true;
        }
    }
    return 1;
}

template<typename L>
bool List<L>::Delete(L value) 
{
    Node<L> *p ;
    int j;

    p = headNode;
    j= 0;
    
    while(p->next != NULL&&p->data != value)
    {
        p=p->next ;
        j++;
    }

    if( p != NULL&& p->next == NULL && p->data != value) 
    {
        cout <<" delete("<<value<<") falied"<<endl; 
        return false;
    }
    if ( p != NULL)
    {
        if( p->prior == NULL)
        {
            headNode = p ->next ;
        }
        else 
        {
            p->prior ->next = p -> next;

            if ( p->next != NULL)
            p->next ->prior = p->prior ;
        }
        size --;
    }
    else
    {
        cout <<" delete("<<value<<") falied"<<endl; 
    
        return false;
    }
    return true;
}

template<typename L>
int List<L>::GetList (int index)
{

    Node<L> *p;
    int j;

    if( ( index <1)||(index>Length())) return NULL;
    {
        p = headNode;
        j = -1;
        while(p->next != NULL&&j < index-1)
        {
            p = p->next ;
            j++;
        }
    }
    return p->data ;
}

template<typename L>
void List<L>::ListShow()
{
    Node<L> * pN;
    pN = headNode;
    while(pN != NULL)
    {
        std::cout <<pN->data <<std::endl ;
        pN = pN->next ;
        
    }
}