单向循环链表实现

杰西卡若

已于 2024-07-07 15:04:38 修改

阅读量356

点赞数 6

分类专栏： c/c++ 文章标签：链表数据结构 c语言

于 2024-01-19 17:55:40 首次发布

本文链接：https://blog.csdn.net/myCs05/article/details/135704100

版权

c/c++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文详细介绍了单向循环链表的结构、初始化方法，包括头插法、尾插法的实现，以及按位删除和链表销毁的过程。通过示例展示了如何在循环链表中进行数据插入和删除，并最终销毁整个链表。

摘要由CSDN通过智能技术生成

2.单向循环链表

1.单链表结构体

typedef struct Node
{
    int data;
    struct Node *next;
} Node, *LinkList;

LNOde *L; 可读性不强，代表的是一个指向头结点的指针但通常不知道它是一个结点还是一个指向头结点的指针

LinkList L; 可读性较强，代表的是一个指向头结点的指针主要可以和一个新的结点，和指向头结点的指针区别开来

2.初始化单链表

Node *InitLoopLinkList()
{
    Node *L = (Node *)malloc(sizeof(Node));
    L->data = 0;
    // 单循环链表
    L->next = L;
    return L;
}

int main()
{
    // 赋值
	Node* L=InitLoopList();
    return 0;
}

3.打印单链表

void PrintfLoopLinkList(LinkList L)
{
    Node *p;
    p = L->next;
    while (p != L)
    {
        printf("%d->", p->data);
        p = p->next;
    }
    printf("NULL\n");
}

打印的本质是利用循环，一直找到结点的下一个为NULL的情况下，停止循环

4.头插法

// 头插法 自动插入
void InsertLoopLinkListHeadNode(LinkList L, int data)
{
    Node *p = (Node *)malloc(sizeof(Node));
    p->data = data;
    p->next = L->next;
    L->next = p;
    L->data++;
}

// 头插法 手动插入
void InsertLoopLinkListHeadNode1(Node *L)
{
    Node *newNode;
    int newNode_data;

    printf("please enter to number:");
    scanf("%d", &newNode_data);
    while (newNode_data != 9999)
    {
        newNode = (Node *)malloc(sizeof(Node));
        newNode->data = newNode_data;
        newNode->next = L->next;
        L->next = newNode;
        L->data++; // 表长+1
        printf("please enter to number:");
        scanf("%d", &newNode_data);
    }
}

以9999为结束循环的条件，不断在头部插入结点

5.尾插法

// 尾插法
void InsertLoopLinkListTailNode(LinkList L, int data)
{
    Node *tailNode = L;
    while (tailNode->next != L)
    {
        tailNode = tailNode->next;
    }
    Node *p = (Node *)malloc(sizeof(Node));
    p->data = data;
    p->next = L;
    tailNode->next = p;
    L->data++;
}

6.按位删除

// 按位删除
int LocateDeleteLoopLinkList(LinkList L, int i, int *e)
{
    if (!L || !L->next)
    {
        printf("LinkList is empty\n");
        return 0;
    }
    if (i == 0)
    {
        printf("The position of the element to be deleted invalid\n");
        return 0;
    }
    if (i < 1 || i > L->data + 1)
    {
        printf("The position of the element to be deleted invalid\n");
        return 0;
    }
    Node *preNode = L;
    Node *node = L->next;

    int j = 1;
    while (node != L)
    {
        if (j == i)
        {
            preNode->next = node->next;
            free(node);
            L->data--;
            return 1;
        }
        preNode = node;
        node = node->next;
        j++;
    }
    return 1;
}

7.销毁链表

// 销毁单链表
void DestroyLinkList(LinkList L)
{
    Node *p, *q;
    if (L == NULL)
    {
        printf("Empty Circular LinkList\n");
        return;
    }
    p = L->next;
    while (p != L)
    {
        q = p->next;
        free(p);
        p = q;
    }
    free(L);  // 释放头结点
    L = NULL; // 头指针置空
    printf("Circular LinkList destroyed\n");
}

8.测试

int main()
{
    LinkList L = InitLoopLinkList();

    // InsertLoopLinkListHeadNode(L, 1);
    // InsertLoopLinkListHeadNode(L, 2);
    // InsertLoopLinkListHeadNode(L, 3);
    // InsertLoopLinkListHeadNode(L, 4);
    // InsertLoopLinkListHeadNode(L, 5);

    InsertLoopLinkListTailNode(L, 6);
    InsertLoopLinkListTailNode(L, 7);
    InsertLoopLinkListTailNode(L, 8);
    InsertLoopLinkListTailNode(L, 9);
    InsertLoopLinkListTailNode(L, 10);

    // InsertLoopLinkListHeadNode1(L);
    PrintfLoopLinkList(L);

    int e;

    LocateDeleteLoopLinkList(L, 1, &e);
    LocateDeleteLoopLinkList(L, 2, &e);
    // LocateDeleteLoopLinkList(L, 3, &e);
    // LocateDeleteLoopLinkList(L, 4, &e);
    // LocateDeleteLoopLinkList(L, 5, &e);
    PrintfLoopLinkList(L);

    DestroyLinkList(L);
    PrintfLoopLinkList(L);
    return 0;
}