双循环链表的打印问题

#include<stdio.h>
#include<stdlib.h>

typedef int ElemType;
typedef struct DuLinkList{
    ElemType data;
    struct DuLinkList *prior;
    struct DuLinkList *next;
}DuLNode,*DuLinkList;

/**
 * @brief 初始化头结点head
 * prior和next都指向自身，形成一个空表
 * @return DuLinkList 空的带头结点的双向循环链表
 */
DuLinkList InitDuList(){
    DuLinkList L = (DuLinkList)malloc(sizeof(DuLNode));
    if(L == NULL){
        printf("---Init failure---\n");
        exit(1);
    }
    L->prior = L;
    L->next = L;
    printf("---Init success---\n");
    return L;
}

void InsertLisit(DuLinkList L,int len){
    DuLinkList p = L;
    for(int i = 0;i < len;i++){
        DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode));
        temp->data = i;
        // 建立跟双向循环链表的关系
        p->next = temp;
        temp->prior = p;
        p->prior = temp;
        temp->next = p;
        printf("%d- ",temp->data);
        temp = temp->next;
    }
    printf("\n");
}

/**
 * @brief 头插法插入结点
 * @param L 双循环链表
 * @param data 结点数据
 */
void InsertByHead(DuLinkList L,int data){
    // DuLinkList node = CreatNode(data);
    DuLinkList node = (DuLinkList)malloc(sizeof(DuLNode));
    node->data = data;
    node->prior = L;
    node->next = L->next;
    L->next->prior = node;
    L->next = node;
}

void Display(DuLinkList L){
    DuLinkList p = L;
    if(p->next == L)
        printf("Display: 双向循环链表为空!\n");
    else{
        printf("Display: ");
        while(p->next != L){
            p = p->next;
            printf("%d ",p->data);
        }
        printf("\n");
    }
}

int main(){
    DuLinkList L = InitDuList();
    InsertLisit(L,5);
    // for(int i = 0;i < 5;i++){
    //     InsertByHead(L,i);
    // }
    Display(L);
}

按照当前代码打印的话会出现只打印出一个字，不知道这个InsertList的方法搭配Display为什么会出现这个问题？

然后如果注释了InsertList的方法改用InsertByHead的方法循环插入，搭配Display却可以正常打印，求解答！

我在Dev-C++ 里面，调试你的代码，编译报错了，发现是malloc应该使用指针来存放他的返回值，修改后，运行通过了：

 
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct DuLinkList{
    ElemType data;
    struct DuLinkList *prior;
    struct DuLinkList *next;
} DuLNode;
/**
 * @brief 初始化头结点head
 * prior和next都指向自身，形成一个空表
 * @return DuLinkList 空的带头结点的双向循环链表
 */
DuLinkList * InitDuList(){
    DuLinkList * L = (DuLinkList *)malloc(sizeof(DuLNode));
    if(L == NULL){
        printf("---Init failure---\n");
        exit(1);
    }
    L->prior = L;
    L->next = L;
    printf("---Init success---\n");
    return L;
}
void InsertLisit(DuLinkList * L,int len){
    DuLinkList * p = L;
    for(int i = 0;i < len;i++){
        DuLinkList * temp = (DuLinkList *)malloc(sizeof(DuLNode));
        temp->data = i;
        // 建立跟双向循环链表的关系
        p->next = temp;
        temp->prior = p;
        p->prior = temp;
        temp->next = p;
        printf("%d- ",temp->data);
        temp = temp->next;
    }
    printf("\n");
}
/**
 * @brief 头插法插入结点
 * @param L 双循环链表
 * @param data 结点数据
 */
void InsertByHead(DuLinkList * L,int data){
    // DuLinkList node = CreatNode(data);
    DuLinkList * node = (DuLinkList *)malloc(sizeof(DuLNode));
    node->data = data;
    node->prior = L;
    node->next = L->next;
    L->next->prior = node;
    L->next = node;
}
void Display(DuLinkList * L){
    DuLinkList * p = L;
    if(p->next == L)
        printf("Display: 双向循环链表为空!\n");
    else{
        printf("Display: ");
        while(p->next != L){
            p = p->next;
            printf("%d ",p->data);
        }
        printf("\n");
    }
}
int main(){
    DuLinkList * L = InitDuList();
   // InsertLisit(L,5);
     for(int i = 0;i < 5;i++){
         InsertByHead(L,i);
     }
    Display(L);
}

修改见注释，供参考：

#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct DuLinklist{ //typedef struct DuLinkList{  修改
    ElemType data;
    struct DuLinklist *prior;//struct DuLinkList      修改
    struct DuLinklist *next; //struct DuLinkList      修改
}DuLNode,*DuLinkList;
//
 // @brief 初始化头结点head
 // prior和next都指向自身，形成一个空表
 // @return DuLinkList 空的带头结点的双向循环链表
 //
DuLinkList InitDuList(){
    DuLinkList L = (DuLinkList)malloc(sizeof(DuLNode));
    if(L == NULL){
        printf("---Init failure---\n");
        exit(1);
    }
    L->prior = L;
    L->next  = L;
    printf("---Init success---\n");
    return L;
}
void InsertLisit(DuLinkList L,int len){
    DuLinkList p = L;
    for(int i = 0;i < len;i++){
        DuLinkList temp = (DuLinkList)malloc(sizeof(DuLNode));
        temp->data = i;
        // 建立跟双向循环链表的关系
        p->next = temp;
        temp->prior = p;
        L->prior = temp;  // p->prior = temp; 修改
        temp->next = L;   //p                 修改
        printf("%d- ",temp->data);
        p = temp;
        //temp = temp->next;           // 修改
    }
    printf("\n");
}
//
 // @brief 头插法插入结点
 // @param L 双循环链表
 // @param data 结点数据
 //
void InsertByHead(DuLinkList L,int data){
    // DuLinkList node = CreatNode(data);
    DuLinkList node = (DuLinkList)malloc(sizeof(DuLNode));
    node->data = data;
    node->prior = L;
    node->next = L->next;
    L->next->prior = node;
    L->next = node;
}
void Display(DuLinkList L){
    DuLinkList p = L;
    if(p->next == L)
        printf("Display: 双向循环链表为空!\n");
    else{
        printf("Display(next) : ");
        while(p->next != L){
            p = p->next;
            printf("%d ",p->data);
        }
        printf("\n");

        printf("Display(prior): ");
        while(p != L){
            printf("%d ",p->data);
            p = p->prior;
        }
        printf("\n");
    }
}
int main(){
    DuLinkList L = InitDuList();
    InsertLisit(L,5);
     //for(int i = 0;i < 5;i++){
     //    InsertByHead(L,i);
     //}
    Display(L);
    return 0;
}