7-4 带头节点的双向循环链表操作 (100分)(C++实现，带解析）

本题目要求读入一系列整数，依次插入到双向循环链表的头部和尾部，然后顺序和逆序输出链表。

链表节点类型可以定义为

typedef int DataType;
typedef struct LinkedNode{
DataType data;
struct LinkedNode *prev;
struct LinkedNode *next;
}LinkedNode;
链表类型可以定义为

typedef struct LinkedList{
int length; /* 链表的长度 /
LinkedNode head; / 双向循环链表的头节点 */
}LinkedList;
初始化链表的函数可声明为

void init_list(LinkedList *list);
分配节点的函数可声明为

LinkedNode *alloc_node(DataType data);
头部插入的函数可声明为

void push_front(LinkedList *list, DataType data);
尾部插入的函数可声明为

void push_back(LinkedList *list, DataType data);
顺序遍历的函数可声明为

void traverse(LinkedList *list);
逆序遍历的函数可声明为

void traverse_back(LinkedList *list);
输入格式:
输入一行整数（空格分隔），以-1结束。

输出格式:
第一行输出链表顺序遍历的结果，第二行输出逆序遍历的结果。

输入样例:
在这里给出一组输入。例如：

1 2 3 4 5 6 -1
输出样例:
5 3 1 2 4 6
6 4 2 1 3 5

#include<iostream>
using namespace std;
typedef int DataType;
typedef struct LinkedNode {
    DataType data;
    struct LinkedNode* prev;
    struct LinkedNode* next;
}LinkedNode;
typedef struct LinkedList {
    int length; /* 链表的长度 */
    LinkedNode* head; /* 双向循环链表的头节点 */
}LinkedList;
void init_list(LinkedList* list)//初始化链表
{
    list->length = 0;
    list->head = new LinkedNode;
    list->head->next = list->head;
    list->head->prev = list->head;
}
LinkedNode* alloc_node(DataType d)//给节点分配内存空间
{
    LinkedNode* L;
    L = new LinkedNode;
    L->data = d;
    L->prev = NULL; L->next = NULL;
    return L;
}
void push_front(LinkedList* list, DataType data)//头插法
{
    LinkedNode* cur = alloc_node(data);
    //当链表只有头结点时
    if (list->head->next == list->head) {
        list->head->next = cur;
        cur->next = list->head;
        cur->prev = list->head;
        list->head->prev = cur;
    }
    else {
        cur->next = list->head->next;//将新节点的next域指向原链表中头结点后面的节点
        list->head->next->prev = cur;//然后将原头结点中后面节点prev域指向新节点；
        cur->prev = list->head;//将新节点prev域指向头结点
        list->head->next = cur;//将头结点的next域指向新节点
    }list->length++;
}
void push_back(LinkedList* list, DataType data)//尾插法
{
    LinkedNode* cur = NULL;
    //如果链表内只有头结点
    if (list->head->next == list->head) {
        cur = alloc_node(data);
        list->head->next = cur;
        cur->prev = list->head;
        cur->next = list->head;
        list->head->prev = cur;
    }//如果链表内有其他节点
    else {
        cur = alloc_node(data);
        list->head->prev->next = cur;
        cur->prev = list->head->prev;
        list->head->prev = cur;
        cur->next = list->head;
    }list->length++;
}
void traverse(LinkedList* list)//顺序遍历
{
    LinkedNode* cur = list->head->next;
    //如果链表为空
    if (list->length == 0) {}//啥也不用干
    else {
        for (int i = 0; i < list->length; i++) {
            cout << cur->data << " ";
            cur = cur->next;
        }   cout << endl;
    }
}
void traverse_back(LinkedList* list)//倒序遍历
{
    LinkedNode* cur = list->head->prev;
    //如果链表为空
    if (list->length == 0) {}
    else {
        for (int i = 0; i < list->length; i++) {
            cout << cur->data << " ";
            cur = cur->prev;
        }cout << endl;
    }
}
//自己增加的内容 销毁双向循环链表
void destroy(LinkedList* list)
{
    LinkedNode* cur = list->head->next;
    while (cur != list->head) {
        LinkedNode* ret = cur;
        cur = cur->next;
        delete ret;
    }delete(list->head);
}
int main() {
    int data;
    LinkedList L,*pHead=&L;
    init_list(pHead);
    int flag = 1;//根据输出结果可以观察得到构建链表时头插一次，尾插一次，以此类推
    cin >> data;
    while (data != -1)
    {
        if (flag)
        {
            push_front(pHead, data);
            flag = 0;
        }
        else
        {
            push_back(pHead, data);
            flag = 1;
        }
        cin >> data;
    }
    traverse(pHead);
    traverse_back(pHead);
    destroy(pHead);//销毁链表
    return 0;
}