线性表-单链表和单循环链表解析

面相Ai编程

已于 2023-10-15 19:57:19 修改

阅读量530

点赞数 1

文章标签：数据结构链表

于 2023-10-15 19:50:37 首次发布

本文链接：https://blog.csdn.net/XINLOVEBO/article/details/133833892

版权

单链表和单循环链表的概念

单链表：
- 单链表是一种线性数据结构，由一系列节点组成。每个节点包含一个数据元素和一个指向下一个节点的指针（通常称为next指针）。
- 单链表中的节点按顺序连接，每个节点只有一个指针指向下一个节点，而最后一个节点的指针指向空（NULL），表示链表的结束。
- 单链表的优点是插入和删除节点的操作相对高效，但访问特定节点需要从头节点开始遍历整个链表。
单循环链表：
- 单循环链表是一种特殊的链表结构，和单链表类似，最后一个节点的指针不为空，而是指向链表的头节点，形成一个循环。
- 单循环链表的节点按顺序连接形成循环，最后一个节点的指针指向头节点，形成了一个闭环。
- 单循环链表可以从任何一个节点开始遍历整个链表，可以方便地实现循环操作，例如模拟循环队列等。

单链表

头插法：通过将新节点插入到链表的头部来构建链表。

尾插法：通过将新节点插入到链表的尾部来构建链表。

插入元素：在链表中插入元素的算法，根据要插入的位置，可以使用头插法或尾插法。使用头插法时，将新节点插入到链表的头部；使用尾插法时，将新节点插入到链表的尾部。

查找元素：在链表中查找指定元素的算法，需要遍历整个链表，在每个节点上进行比较，直到找到目标元素或遍历完整个链表。

链表长度：即链表中包含的节点个数。遍历链表，每经过一个节点，计数器加一，直到遍历完整个链表。最后得到的计数器值即为链表的长度。

遍历链表：将链表中的节点值依次输出。遍历链表的每个节点，将节点的值输出，直到遍历完整个链表。

删除元素：在链表中删除指定元素的算法，需要找到目标元素所在的节点，然后将它从链表中移除。

初始化函数 init
- 作用：创建链表的头节点并进行初始化工作。
- 功能：使用动态内存分配创建头节点，并将头节点的指针指向NULL，表示链表为空。

/*1. 初始化*/
int init(SingleLinkList **Head) {
    /*申请内存*/
    (*Head) = (SingleLinkList *) malloc(sizeof(SingleLinkList));
    /*判断内存申请是否成功*/
    if (*Head == NULL) {
        printf("申请内存错误， 初始化失败！[100001]\n");
        return 100001;
    }
    (*Head)->next = NULL;
    return 0;
}

2. 头插法插入函数 insert_head：
- 作用：在链表头部插入一个新节点。
- 功能：创建一个新节点，将新节点的指针指向原头节点的next，然后更新头节点的next指针为新节点。

/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x) {
    SingleLinkNode *newNode;

    newNode = (SingleLinkNode *) malloc(sizeof(SingleLinkNode));
    if (!newNode) {
        printf("申请节点内存空间失败！[100004]\n");
        return 100004;
    }
    newNode->data = x;
    newNode->next = (*Head)->next;

    (*Head)->next = newNode;

    return 0;
}

3. 尾插法插入函数 insert_tail：
- 作用：在链表尾部插入一个新节点。
- 功能：遍历链表找到最后一个节点，创建一个新节点，并将最后一个节点的next指针指向新节点。

/*3. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x) {
    SingleLinkNode *newNode;
    SingleLinkNode *p;

    newNode = (SingleLinkNode *) malloc(sizeof(SingleLinkNode));
    if (!newNode) {
        printf("申请节点内存空间失败！[100004]\n");
        return 100004;
    }

    newNode->data = x;
    newNode->next = NULL;

    p = (*Head);

    while (p->next) {
        p = p->next;
    }

    p->next = newNode;

    return 0;
}

4. 插入函数 insert：
- 作用：在指定位置插入一个新节点。
- 功能：遍历链表找到要插入位置的前一个节点，创建一个新节点，并将新节点的指针指向原位置的节点，然后更新前一个节点的指针为新节点。

/*4. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x) {
    int j;
    SingleLinkNode *p;
    SingleLinkNode *newNode;


    /*对i进行判断，0<i<=length+1*/
    if (i < 1 || i > length(*Head) + 1) {
        printf("位置i不是链表有效位置！[100005]\n");
        return 100005;
    }
    p = (*Head);
    j = 1;

    while (j < i) {
        j++;
        p = p->next;
    }

    newNode = (SingleLinkNode *) malloc(sizeof(SingleLinkNode));

    if (!newNode) {
        printf("申请节点内存空间失败！[100004]\n");
        return 100004;
    }


    newNode->data = x;
    newNode->next = p->next;
    p->next = newNode;
    return 0;
}

5. 查找函数 find：
- 作用：在链表中查找指定元素，并返回其位置。
- 功能：遍历链表，找到指定元素后返回其位置，未找到则返回NULL。

/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x) {
    int i;
    SingleLinkNode *p;

    i = 1;
    p = Head->next;

    while (p && p->data != x) {
        i++;
        p = p->next;
    }

    if (!p) {
        return 0;
    } else {
        return i;
    }

}

6. 求链表长度的函数 length：
- 作用：计算链表中的节点个数。
- 功能：遍历整个链表，并计数链表中的节点个数，返回节点数作为链表的长度。

/*6. 链表长度*/
int length(SingleLinkList *Head) {
    int len = 0;
    SingleLinkNode *p;

    p = Head->next;
    while (p) {
        len++;
        p = p->next;
    }
    return len;
}

7. 打印函数 print：
- 作用：打印链表中的数据元素。
- 功能：遍历链表并将其中的每个节点的数据打印出来。

/*7.输出链表*/
void print(SingleLinkList *Head) {
    SingleLinkNode *p;
    int i = 0;

    p = Head->next;
    if (!p) {
        printf("链表为空！\n");
        return;
    }
    while (p) {
        printf("Node[%d]. = %d\n", ++i, p->data);
        p = p->next;
    }
}

8. 删除函数 delete：
- 作用：删除链表中指定元素的节点。
- 功能：首先使用find函数找到元素的位置，然后遍历链表找到位置的前一个节点，将前一个节点的指针指向位置后面的节点，并释放删除节点的内存。

/*8. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x) {
    int i;
    int j;

    SingleLinkNode *p;
    SingleLinkNode *q; /*要删除的元素x*/

    i = find(*Head, x);
    if (!i) {
        printf("元素x【%d】不存在！100006\n", x);
        return 100006;
    }

    p = (*Head);
    j = 1;

    while (j < i) {
        j++;
        p = p->next;
    }

    q = p->next;
    p->next = q->next;

    free(q); /*释放内存*/

    return 0;
}

单循环链

初始化：
初始化一个空的单循环链表，需要创建一个头指针，并将头指针的next指针指向自身，表示空链表。

头插法：
头插法是在链表的头部插入新节点的方法。具体步骤是，创建一个新节点，将新节点的next指针指向原链表的头节点，然后将头节点的next指针指向新节点，最后更新头指针指向新的头节点。

尾插法：
尾插法是在链表的尾部插入新节点的方法。具体步骤是，创建一个新节点，将新节点的next指针指向头节点，然后将链表的尾节点的next指针指向新节点，最后更新尾节点指向新的尾节点。

插入元素：
插入元素到指定位置，可以根据插入位置使用头插法或尾插法进行插入操作。

查找元素：
从头节点开始遍历链表，逐个比较节点的值，直到找到目标元素或者到达尾节点。如果找到目标元素，返回该节点的指针；否则返回空指针表示未找到。

求链表长度：
遍历链表，逐个统计节点的个数，即为链表的长度。

输出链表：
从头节点开始遍历链表，逐个打印或处理节点的值，直到到达尾节点。

删除元素：
删除链表中指定值的节点，需要先查找到目标元素，然后修改前一个节点的next指针，指向目标节点的next指针，最后释放被删除节点的内存空间。

1.链表初始化函数 init

作用：用于初始化循环链表，创建一个头结点，并将头结点的next指针指向自身，形成一个空的循环链表。
功能：如果链表已经初始化，则输出错误信息；否则申请内存，判断内存申请是否成功，将头结点的next指针指向自身，并返回0表示初始化成功。

/*1. 初始化*/
int init(SingleLinkList **Head)
{
    if(Head != NULL)
    {
        /*申请内存*/
        (*Head) = (SingleLinkList*)malloc(sizeof(SingleLinkList));
        /*判断内存申请是否成功*/
        if(*Head == NULL)
        {
            printf("申请内存错误， 初始化失败！[100001]\n");
            return 100001;
        }
        (*Head)->next = *Head;
        return 0;
    }
    else
    {
        printf("该链表已经初始化！请删除后再执行此操作！[100002]\n");
        return 100002;
    }
}

2.头插法插入元素函数 insert_head

作用：将新元素插入链表头部。
功能：申请一个新节点，如果申请内存失败则输出错误信息，将新节点的data赋值为要插入的元素，将新节点的next指针指向原头结点的next指针指向的节点，将头节点的next指针指向新节点，并返回0表示插入成功。

/*2. 插入元素,头插法*/
int insert_head(SingleLinkList **Head, DataType x)
{
    SingleLinkNode *newNode;

    newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
    if(!newNode)
    {
        printf("申请节点内存空间失败！[100004]\n");
        return 100004;
    }
    newNode->data = x;
    newNode->next = (*Head)->next;

    (*Head)->next = newNode;

    return 0;
}

3.尾插法插入元素函数 insert_tail

作用：将新元素插入链表尾部。
功能：申请一个新节点，如果申请内存失败则输出错误信息，将新节点的data赋值为要插入的元素，将新节点的next指针指向头结点，遍历链表找到尾节点，将尾节点的next指针指向新节点，并将新节点的next指针指向头结点，返回0表示插入成功。

/*3. 插入元素， 尾插法*/
int insert_tail(SingleLinkList **Head, DataType x)
{
    SingleLinkNode *newNode;
    SingleLinkNode *p;

    newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
    if(!newNode)
    {
        printf("申请节点内存空间失败！[100004]\n");
        return 100004;
    }

    newNode->data = x;
    newNode->next = *Head;
    p = (*Head);
    while(p->next != NULL && p->next != *Head)
    {
        p = p->next;
    }

    p->next = newNode;
    newNode->next = *Head;
    return 0;
}

4.在指定位置插入元素函数 insert

作用：在位置i处插入新元素。
功能：对i进行判断，若i不是链表的有效位置，则输出错误信息；否则，遍历链表找到位置i的前一个节点，申请一个新节点，将新节点的data赋值为要插入的元素，将新节点的next指针指向位置i的节点，将位置i的前一个节点的next指针指向新节点，并返回0表示插入成功。


/*4. 插入元素，在位置i处插入元素x */
int insert(SingleLinkList **Head, int i, DataType x)
{
    int j;
    SingleLinkNode *p;
    SingleLinkNode *newNode;


    /*对i进行判断，0<i<=length+1*/
    if(i<1 || i>length(*Head)+1)
    {
        printf("位置i不是链表有效位置！[100005]\n");
        return 100005;
    }
    p = (*Head);
    j = 1;

    while(j<i)
    {
        j++;
        p = p->next;
    }

    newNode = (SingleLinkNode*)malloc(sizeof(SingleLinkNode));
    /*此处省略检测newNode是否申请成功*/

    newNode->data = x;
    newNode->next = p->next;
    p->next = newNode;
    return 0;
}

5.查找元素位置函数 find

作用：查找链表中值为x的元素的位置。
功能：初始化i为1，将p指针指向头节点的next指针指向的节点，遍历链表，如果p指针指向的节点不是头节点且值不等于x，则i加1，p指针指向下一个节点；如果p指针指向的节点是头节点，则返回0表示找不到元素x；否则返回i表示找到了元素x的位置。

/*5. 查找值为x的元素，返回位置i */
int find(SingleLinkList *Head, DataType x)
{
    int i;
    SingleLinkNode *p;

    i = 1;
    p = Head->next;

    while(p!= Head && p->data != x)
    {
        i++;
        p = p->next;
    }

    if(p->next == Head)
    {
        return 0;
    }
    else
    {
        return i;
    }

}

6.链表长度函数 length

作用：返回链表的长度。
功能：初始化长度len为0，将p指针指向头节点的next指针指向的节点，遍历链表，每遍历一个节点，长度len加1，最后返回长度len。


/*6. 链表长度*/
int length(SingleLinkList *Head)
{
    int len=0;
    SingleLinkNode *p;
    p = Head->next;
    while(p!=Head)
    {
        len++;
        p = p->next;
    }
    return len;
}

7.输出链表函数 print

作用：打印链表的所有元素。
功能：初始化节点编号为0，将p指针指向头节点的next指针指向的节点，如果p为NULL，则链表为空，输出相应信息；否则，遍历链表，输出每个节点的编号和数据，并将p指针指向下一个节点，直到p指针指向头节点。

/*7.输出链表*/
void print(SingleLinkList *Head)
{
    SingleLinkNode *p;
    int i=0;

    p = Head->next;
    if(!p)				/*  if(p!=Head)  */
    {
        printf("链表为空！\n");
        return;
    }
    while(p != Head)
    {
        printf("Node[%d]. = %d\n", ++i, p->data);
        p = p->next;
    }
}

8.删除函数 delete

作用：删除链表中指定元素的节点。
功能：首先使用find函数找到元素的位置，然后遍历链表找到位置的前一个节点，将前一个节点的指针指向位置后面的节点，并释放删除节点的内存。

/*8. 删除元素, 删除值为x的元素*/
int delete(SingleLinkList **Head, DataType x)
{
    int i;
    int j;

    SingleLinkNode *p;
    SingleLinkNode *q; /*要删除的元素x*/

    i = find(*Head,x);
    if(!i)
    {
        printf("元素x【%d】不存在！100006\n", x);
        return 100006;
    }

    p = (*Head);
    j=1;

    while(j<i)
    {
        j++;
        p = p->next;
    }

    q = p->next;
    p->next = q->next;

    free(q); /*释放内存*/

    return 0;
}

运行结果