双向循环链表的创建

双向循环链表的创建

1 节点的创建

struct node
{
    dataType data;
    struct node *prev;
    struct node *next;
};

2 管理结构体

struct headNode
{
    struct node *first;//指向链表首节点
    struct node *last;//指向链表尾节点
    dataType nodeNumder;//链表节点数
};

3 主代码（可运行）

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

typedef int dataType;

//节点
struct node
{
    dataType data;
    struct node *prev;
    struct node *next;
};

//头结点，管理链表
struct headNode
{
    struct node *first;//指向链表首节点
    struct node *last;//指向链表尾节点
    dataType nodeNumder;//链表节点数
};

//头插法
void *addHead(struct headNode *head,struct node *pnew)
{
    pnew->next=head->first;
    pnew->prev=head->first->prev;
    head->first->prev=pnew;
    head->first=pnew;

}

//尾插法
void addTail(struct headNode *head,struct node *pnew)
{
    pnew->prev = head->last;
    head->last->next = pnew;
    head->last = pnew;
}

//初始化头结点
struct headNode *init_headNode()
{
    struct headNode *head=malloc(sizeof(struct headNode));
    if(head == NULL)
    {
        perror("create head failed:");
        return NULL;
    }
    //初始化
    head->first=NULL;
    head->last=NULL;
    head->nodeNumder=0;
    return head;
}

//创建新节点
struct node *create_newNode(dataType data)
{
    struct node *pnew=malloc(sizeof(struct node));
    if(pnew == NULL)
    {
        perror("create new node failed:");
        return NULL;
    }

    pnew->data=data;
    pnew->prev=NULL;
    pnew->next=NULL;
    return pnew;

}

//创建新链表
struct headNode *create_list()
{
    //初始化头节点
    struct headNode *head=init_headNode();
    if(head==NULL)
    {
        printf("over\n");
        // exit(0);
    }

    while (1)
    {
        dataType data;
        scanf("%d",&data);
        if(data==0)
            break;
        
        //创建新节点
        struct node *pnew=create_newNode(data);
        if(head->first==NULL)
        {
            head->first=pnew;
            head->last=pnew;
        }
        else
        {
            // addHead(head,pnew);
            addTail(head,pnew);

        }
        head->nodeNumder++;

    }

    if(head->nodeNumder != 0)
    {
        head->last->next = head->first;
        head->first->prev = head->last;
    }

    return head;

}

//显示链表
void showList(struct headNode* head)
{
    if(head->nodeNumder == 0)
    {
        printf("链表为空\n");
        return;
    }

    // for(struct node* p = head->first;p->next!=head->first;p = p->next)
    // {
    //     printf("%d\t",p->data);
    // }

    struct node *p=head->first;
    int n=head->nodeNumder;
    while (n--)
    {
        printf("%d\t",p->data);
        p=p->next;
    }
    
    printf("\n");
    printf("链表节点数为：%d\n",head->nodeNumder);
}

//删除
struct headNode *del_node(struct headNode *head,dataType data)
{
    // 找节点
    int n=head->nodeNumder;
    struct node *p = head->first;
    // while(p->next!=head->first)
    while(n!=0)
    {
        if(p->data == data)
        {
            break;
        }
            
        else
            p = p->next;
        
        n--;
    }

    if(n==0)
    {
        printf("没有找到\n");
    }

    else if(p->next==head->first)
    {
        p->prev->next = NULL;
        p->prev = NULL;
        free(p);
        head->nodeNumder--;
    }

    // 如果是第一个节点
    else if(head->first->data == data)
    {
        head->first = p->next;
        p->next = NULL;
        p->prev = NULL;
        free(p);
        head->nodeNumder--;
    }

    else
    {
        p->prev->next = p->next;
        p->next->prev = p->prev;
        p->next = NULL;
        p->prev = NULL;
        head->nodeNumder--;

        free(p);
    }
    
    return head;
}

//插入节点
struct headNode *add_node_list(struct headNode *head,dataType newData,dataType data)
{
    struct node *pnew=create_newNode(newData);
    int n=head->nodeNumder;
    struct node *p=head->first;
    // while (p->next!=head->first)
    while(n!=0)
    {
        if(p->data==data)
            break;
        p=p->next;
        n--;
    }


    if(n==0)
    {
        addTail(head,pnew);
    }

    else if(p->data==head->first->data)
    {
        addHead(head,pnew);
    }

    else
    {
        pnew->next=p;
        pnew->prev=p->prev;
        p->prev->next = pnew;
        p->prev = pnew;

    }
    
    head->nodeNumder++;
    return head;
}

//更新链表
struct headNode *updata_node(struct headNode *head,dataType data1,dataType data2)
{
    struct node *p=head->first;
    while (p->next!=head->first)
    {
        if(p->data==data1)
        {
            p->data=data2;
        }

        p=p->next;
    }
}

//销毁
struct headNode *destory(struct headNode *head)
{
    if(head==NULL)
    {
        printf("链表为空\n");
        free(head);
    }

    struct node *temp=NULL;
    struct node *p=head->first;
    int n=head->nodeNumder;
    while (n--)
    {
        temp=p->next;
        p->next=NULL;
        free(p);
        head->nodeNumder--;

    }

    return head;
}

//判断链表是否有环
bool judge_circle(struct headNode *head)
{
    struct node *fast=head->first;

    struct node *slow=head->first;
    do
    {
        fast=fast->next;
        
        if(fast!=NULL)
        {
            fast=fast->next;
        }
        else
        {
            return false;
        }
        slow=slow->next;


    } while (fast!=NULL&&slow!=NULL&&fast!=slow);
    return fast==slow;
    
}

int main(int argc, char const *argv[])
{
    struct headNode *head = create_list();

    if(head==NULL)
    {
        printf("创建链表失败");
        return -1;
    }

    // updata_node(head,1,20);
    del_node(head,2);
    // add_node_list(head,1,2);
    // destory(head);
    // if(judge_circle(head))
    // {
    //     printf("有环\n");
    // }
    // else
    // {
    //     printf("无环\n");
    // }

    showList(head);

    return 0;
}