3.5 循环链表

3.5 循环链表_哔哩哔哩_bilibili

 

//循环单链表（带头结点）C++编译
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

typedef struct LNode{        
    int data;               
    struct LNode *next;  
}LNode, *LinkList;
 
//初始化循环单链表
bool InitList(LinkList &L){
    L=(LNode*)malloc(sizeof(LNode));
    L->next=L;
    return true;
}

//判断循环单链表是否为空
bool Empty(LinkList L){
    return L->next==L;
}

//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L, LNode *p){
    return p->next==L;
}

//结点a之后插入结点b
bool InsertNextNode(LNode *a, LNode *b){
    if(!a || !b) return false;
    b->next=a->next;
    a->next=b;
    return true;
}

//尾插法建立循环单链表
bool CreateLinkList(LinkList &L, int n, int s[]){
    if(!L || n<0 || !s) return false;
    LinkList q, p=L; //p指向头结点
    for(int i=0; i<n; i++){
        q=(LNode*)malloc(sizeof(LNode));
        q->data=s[i];
        InsertNextNode(p,q);
        p=p->next;
    }
    return true;   
}

//删除p结点的后继结点
bool DeletNextNode(LinkList L, LNode *p){
    if(!p) return false; //不合法
    LNode *q=p->next;
    if(q==L) return false; //不存在
    p->next=q->next;
    free(q);
    return true;
}

//遍历输出单链表
bool ListOut(LinkList L){
    if(!L) return false;
    LNode *p=L->next;
    while(p!=L){ //若p不指向头结点
        printf("%d ",p->data); 
        p=p->next;
    }
    puts("");
}
int main(){
    LinkList L;
    InitList(L);
    int n=3; int s[]={5,2,0};
    CreateLinkList(L,n,s);
    ListOut(L);
    
    DeletNextNode(L,L);
    ListOut(L);
    
    CreateLinkList(L,n,s);
    ListOut(L);    
    return 0;
}

 

//循环双链表（带头结点）C++编译
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

//循环双链表结点定义
typedef struct DNode{          
    int data;               
    struct DNode *prev, *next;  
}DNode, *DLinkList;
 
//初始化循环双链表
bool InitDLinkList(DLinkList &L){
    L=(DNode*)malloc(sizeof(DNode));
    L->prev=L; //指向头结点
    L->next=L; //指向头结点
}

//判断循环双链表是否为空
bool Empty(DLinkList L){
    return L->next==L;
}

//判断结点p是否为循环双链表的表尾结点
bool isTail(DLinkList L, DNode *p){
    return p->next==L;
}

//结点a之后插入结点b
bool InsertNextDNode(DNode *a, DNode *b){
    if(!a || !b) return false;
    b->prev=a;
    b->next=a->next;
    a->next->prev=b;
    a->next=b;
}

//尾插法建立循环双链表
bool CreateDLinkList(DLinkList &L, int n, int s[]){
    if(!L || n<0 || !s) return false;
    DNode *q, *p=L; //p指向头结点
    for(int i=0; i<n; i++){
        q=(DNode*)malloc(sizeof(DNode));
        q->data=s[i];
        InsertNextDNode(p,q);
        p=p->next;
    }
    return true;   
}

//删除p的后继结点
bool DeleteNextDNode(DLinkList L, DNode *p){
    if(!p) return false; //不合法
    DNode *q=p->next;
    if(q==L) return false; //不存在
    p->next=q->next;
    free(q);
    return true;
}

//遍历输出循环双链表
bool ListOut(DLinkList L){
    if(!L) return false;
    DNode *p=L->next;
    while(p!=L){ //若p不指向头结点
        printf("%d ",p->data); 
        p=p->next;
    }
    puts("");
}
int main(){
    DLinkList L;
    InitDLinkList(L);
    int n=3; int s[]={5,2,0};
    CreateDLinkList(L,n,s);
    ListOut(L);

    DeleteNextDNode(L,L);
    ListOut(L);

    CreateDLinkList(L,n,s);
    ListOut(L);     
    return 0;
}

 

 

.