双向链表（不含头节点）

#include <iostream>
using namespace std;
typedef struct node{
    int value;
    struct node *pNext;
    struct node *pFront;
}List;

//创建双向链表
List* CreateList(int num)
{
    int date;
    List *pHead = NULL;
    List *pTail = NULL;
    List *pTemp = NULL;
    while(num--){
        cin>>date;
        pTemp = new List();
        pTemp->value = date;
        pTemp->pNext = NULL;
        if(pHead == NULL){
            pHead = pTemp;
            pHead->pFront = pHead;
        }
        else{
            pTail->pNext = pTemp;
            pTemp->pFront = pTail;
        }
        pTail = pTemp;
    }
    return pHead;
}

//遍历双向链表
void Traver(List *pHead)
{
    while(pHead){
        cout<<pHead->value<<" ";
        pHead = pHead->pNext;
    }
    cout<<endl;
}

//获取双向链表的长度
int GetLength(List *pHead)
{
    int ListLength = 0;
    while(pHead){
        ListLength++;
        pHead = pHead->pNext;
    }
    return ListLength;
}

//反向遍历双向链表
void ReTraver(List *pHead)
{
    if(pHead == NULL)  return ;
    List *node = NULL;
    node = pHead;
    while(node->pNext){
        node = node->pNext;
    }
    while(node != pHead){
        cout<<node->value<<" ";
        node = node->pFront;
    }
    cout<<pHead->value<<endl;
}

//双向链表中接点的加入
void InsertNode(List **pHead, int InsertValue, int Pos)
{
    if(pHead == NULL || Pos < 0 || Pos > GetLength(*pHead))  return ;
    List *insertnode = NULL;
    insertnode = new List();
    insertnode->value = InsertValue;
    if(Pos == 0){
        insertnode->pNext = *pHead;
        insertnode->pNext->pFront = insertnode;
        *pHead = insertnode;
        return ;
    }
    int InsertCounter = 1;
    List *InsertFront = NULL;
    List *InsertNext = NULL;
    InsertFront = *pHead;
    InsertNext = InsertFront->pNext;
    while(InsertCounter != Pos){
        InsertFront = InsertFront->pNext;
        InsertNext = InsertFront->pNext;
        InsertCounter++;
    }
    insertnode->pNext = InsertNext;
    insertnode->pNext->pFront = insertnode;
    InsertFront->pNext = insertnode;
    InsertFront->pNext->pFront = InsertFront;
}

//双向链表中删除节点
void DeleteNode(List **pHead, int Pos)
{
    if(*pHead == NULL || Pos < 1 || Pos > GetLength(*pHead))  return ;
    List *DeleteFront = NULL;
    List *DeleteNext = NULL;
    List *DeleteNode = NULL;
    if(Pos == 1){
        DeleteNode = *pHead;
        DeleteNext = (*pHead)->pNext;
        *pHead = DeleteNext;
        delete DeleteNode;
        DeleteNode = NULL;
        return ;
    }
    int DeleteCounter = 2;
    DeleteFront = *pHead;
    DeleteNode = DeleteFront->pNext;
    DeleteNext = DeleteNode->pNext;
    while(DeleteCounter != Pos){
        DeleteFront = DeleteFront->pNext;
        DeleteNode = DeleteFront->pNext;
        DeleteNext = DeleteNode->pNext;
        DeleteCounter++;
    }
    DeleteFront->pNext = DeleteNext;
    DeleteFront->pNext->pFront = DeleteFront;
    delete DeleteNode;
    DeleteNode = NULL;
}

//双向链表逆置
List *ReList(List *pHead)
{
    if(pHead == NULL)  return NULL;
    List *p1 = NULL;
    List *p2 = NULL;
    List *p3 = NULL;
    p1 = pHead;
    List *node = p1;
    p2 = pHead->pNext;
    p3 = pHead->pNext->pNext;
    while(p3){
        p2->pNext = p1;
        p2->pNext->pFront = p2;
        p1 = p2;
        p2 = p3;
        p3 = p3->pNext;
    }
    p2->pNext = p1;
    p2->pNext->pFront = p2;
    node->pNext = NULL;
    return p2;
}

int main(){
    List *pHead = NULL;
    int num;
    cin>>num;
    pHead = CreateList(num);
    cout<<GetLength(pHead)<<endl;
    Traver(pHead);
    ReTraver(pHead);
    int InsertVlaue,Pos;
    cin>>InsertVlaue>>Pos;
    InsertNode(&pHead,InsertVlaue,Pos);
    cout<<GetLength(pHead)<<endl;
    Traver(pHead);
    ReTraver(pHead);
    int DeletePos;
    cin>>DeletePos;
    DeleteNode(&pHead,DeletePos);
    cout<<GetLength(pHead)<<endl;
    Traver(pHead);
    ReTraver(pHead);
    List *p = NULL;
    p = ReList(pHead);
    cout<<GetLength(p)<<endl;
    Traver(p);
    ReTraver(p);
    return 0;
}