数据结构——链表（头结点循环链表）

最新推荐文章于 2023-05-17 14:18:34 发布
最新推荐文章于 2023-05-17 14:18:34 发布
阅读量617 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/clusterally/article/details/76674160

头文件：

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

#define FALSE 0
#define TRUE  1

typedef int LinkData;
typedef struct _node
{
    LinkData data;
    struct _node * next;
}Node;

// 创建链表
Node * Create_List();

// 尾插
int Insert_Last(Node *h, LinkData data);

// 头插
int Insert_Head(Node *h, LinkData data);

// 在第 pos 个结点处插入数据
int Insert_Pos(Node *h, int pos, LinkData data);

//删除 第 pos 个结点
int Delete_Pos(Node* h, int pos);

// 逆序
int Reverse_List(Node *head);

// 删除指定数据
int Delete_Data(Node*, LinkData data);

// 查找元素:如果有, 返回元素的位置
int Find_Element(Node* h, LinkData data, int *x);

// 获取顺序表中的元素：通过位置获取
int Get_Element(Node* s, int pos, int *x);

int Get_Len(Node * head);

// 清空所有结点
int Clean_List(Node * head);

// 销毁链表
int Destroy(Node *);

void Display(Node *h);
#endif

功能函数：

#include "LinkList.h"
#include <stdlib.h>
#include <stdio.h>
Node * Create_List()
{
    Node *head = (Node*)malloc(sizeof(Node)/sizeof(char));
    if (head == NULL)
        return NULL;

    head->next = head;   // 空表

    return head;
}

int Insert_Head(Node *h, LinkData data)
{
    if (h == NULL)
        return FALSE;
    Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
    if (node == NULL)
    {
        return FALSE;
    }

    node->data = data;
    node->next = h->next;

    h->next = node;

    return TRUE;
}

int Insert_Last(Node *h, LinkData data)
{
    if (h == NULL)
        return FALSE;

    Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
    if (node == NULL)
    {
        return FALSE;
    }
    node->data = data;
    node->next = h;

    Node* tmp = h;
    while (tmp->next != h)
    {
        tmp = tmp->next;
    }

    tmp->next = node;

    return TRUE;
}

int Insert_Pos(Node *h, int pos, LinkData data)
{
    if (h == NULL || pos < 1)
        return FALSE;

    // 找要插入位置的前一个结点
    Node *tmp = h;
    int i;
    for (i = 0; i < pos-1; i++)
    {
        if (tmp == h)
            break;
        tmp = tmp->next;
    }

    if (tmp == h)   // 越界
    {
        printf("插入位置越界\n");
        return FALSE;
    }

    Node *node = (Node*)malloc(sizeof(Node)/sizeof(char));
    if (node == NULL)
    {
        return FALSE;
    }
    node->data = data;
    node->next = tmp->next;
    tmp->next  = node;

    return TRUE;
}

int Delete_Pos(Node* h, int pos)
{
    if (h == NULL || pos < 1)
        return FALSE;

    // 找要插入位置的前一个结点
    Node *tmp = h;
    int i;
    for (i = 0; i < pos-1; i++)
    {
        if (tmp->next == h)
            break;
        tmp = tmp->next;
    }

    if (tmp->next == h)   // 越界
    {
        printf("删除位置越界\n");
        return FALSE;
    }

    Node *p = tmp->next;
    tmp->next = p->next;
    free(p);

    return TRUE;
}

int Reverse_List(Node *h)
{
    // h->next 空表
    // h->next->next 只有一个结点
    if (h == NULL || h->next == h || h->next->next == h)
        return FALSE;

    Node *pre = h->next;
    Node *cur = h->next->next;
    Node *tmp;

    while (cur == h)
    {
        tmp = cur->next;
        cur->next = pre;
        pre = cur;
        cur = tmp;
    }

    h->next->next = h;
    h->next = pre;

    return TRUE;
}

int Delete_Data(Node* h, LinkData data)
{
    if (h == NULL)
        return FALSE;

    Node *tmp = h;
    while (tmp->next != h)
    {
        if (tmp->next->data == data)
            break;
        tmp = tmp->next;
    }

    if (tmp->next == h)
        return FALSE;

    Node *p = tmp->next;
    tmp->next = p->next;
    free(p);

    return TRUE;
}

int Find_Element(Node* h, LinkData data, int *x)
{
    if (h == NULL)
        return FALSE;

    Node *tmp = h->next;
    int k = 1;
    while (tmp != h)
    {
        if (tmp->data == data)
        {
            *x = k;
            return TRUE;
        }
        k++;
        tmp = tmp->next;
    }

    return FALSE;
}

int Get_Element(Node* h, int pos, int *x)
{
    if (h == NULL || pos < 1)
        return FALSE;

    int i;
    Node *tmp = h;
    for (i = 0; i < pos; i++)
    {
        if (tmp == h)
            break;
        tmp = tmp->next;
    }

    if (tmp == h)
        return FALSE;
    else
        *x = tmp->data;

    return TRUE;
}

int Get_Len(Node * h)
{
    if (h == NULL)
        return 0;

    Node *tmp = h;
    int count = 0;
    while (tmp->next != h)
    {
        count++;
        tmp = tmp->next;
    }

    return count;
}

int Clean_List(Node * h)
{
    if (h == NULL)
        return FALSE;

    Node *tmp = h;
    while (tmp->next != h)
    {
        Delete_Pos(h, 1);
    }

    return 0;
}


void Display(Node *h)
{
    if (h == NULL)
        return;

    int count = 0;
    Node *tmp = h->next;
    while (tmp != h)
    {
        if (count++ % 4 == 0)
            printf ("\n");
        printf ("%8d", tmp->data);

        tmp = tmp->next;
    }
    printf ("\n");
}

int Destroy(Node *h)
{
    if (h == NULL)
        return FALSE;
    Clean_List(h);
    free(h);

    return TRUE;
}

main函数：

#include <stdio.h>
#include "LinkList.h"

int main()
{
    // 创建链表
    Node* head = Create_List();
    if (head == NULL)
    {
        printf("创建链表失败\n");
        return -1;
    }


    int i;
    for (i = 0; i < 10; i++)
    {
        Insert_Head(head, i);
    }
#if 0       
    for (i = 0; i < 10; i++)
    {
        Insert_Head(head, i);
    }

    Insert_Pos(head, 5, 1000);
    Insert_Pos(head, 1, 2000);
    Insert_Pos(head, 22, 2000);
    Insert_Pos(head, 24, 2000);
    Insert_Pos(head, 26, 2000);
    Delete_Pos (head, 21);

    Reverse_List(head);
#endif
    Delete_Data(head, 0);

    int x;
    Find_Element(head, 7, &x);
    Get_Element(head, 8, &x);
    printf ("%d\n", x);

    printf ("%d\n", Get_Len(head));
    Display(head);
    Clean_List(head);
    printf ("清空后：\n");
    Display(head);

    return 0;
}
数据结构——链表——带头结点的单向循环链表
weixin_44791940的博客
02-25 452
带头结点的单向循环链表 #include<stdlib.h> #include<stdio.h> #include"headList.h" /* 功能：创建一个空链表 参数：无 返回值： 失败返回NULL 成功返回头结点的地址 */ List * createLkList() { List * list = (List *)malloc(sizeof(List)); if(list == NULL) { printf("malloc fail\n");
数据结构——双向循环链表
qq_67611811的博客
08-28 2420
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
双向循环链表头结点
02-12
C语言练习，双向循环通用链表
数据结构头结点循环链表
xym_smart的博客
08-04 392
头结点循环链表 #ifndef __LINKLIST_H__ #define __LINKLIST_H__ #define FALSE 0 #define TRUE 1 typedef int LinkData; typedef struct _node { LinkData data; struct _node * next; }Node; // 创建链表 Node * Creat
数据结构学习之 带有头节点的循环链表
Murphy5222的博客
05-10 425
#pragma once #include <stdbool.h> //带头节点的循环链表 //循环链表尾节点的next指向头节点 //Clist为一条链表，CNode *一个节点的地址 typedef struct CNode { int data; //数据 struct CNode *next; //下一个节点的地址 }CNode,*CList; //CL...
循环单链表-头节点
weixin_46305333的博客
03-24 639
#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> typedef int Elemtype; typedef struct CNode { Elemtype data; struct CNode* next; }CNode,*LinkList; bool List_TailInsert(LinkList& L) { L = (CNode*)malloc(sizeof(CNode));
带有头结点的单向循环链表
星空
10-16 3934
题目：         创建带有头结点的循环链表，实现插入 、查询 、 删除等功能 。 源代码： #include&lt;iostream&gt; #include&lt;malloc.h&gt; using namespace std; typedef int elemtype; //定义结点类型 //定义一个线性链表的类型 typedef struct node { elemty...
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3469
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
数据结构之——链表
xqx_999的博客
10-06 5068
链表的介绍，单链表和双向链表的接口实现。
数据结构 —— 链表
Labrador_Katie的博客
08-28 1249
链表线性表链表的分类单向链表双向链表循环链表 线性表 线性表：由零个或多个数据元素组成的有限序列。 线性表有两种存储方式： 顺序存储结构——即数组 链式存储结构——即链表 线性表强调： 它是一个序列，元素之间有个先来个后到； 若元素存在多个，则第一个元素无前驱，最后一个元素无后继，其他元素有且只有一个前驱和后继； 线性表强调是有限的。 链表的分类 单向链表 单向链表是最简单的链表形式。我们将链表中最基本的数据称为节点(node)，每一个节点包含了数据块和指向下一个节点的指针。 特点：用一组任意的存储
带头结点的双向循环链表数据结构
01-08
用C++和Java实现带头节点的双向循环链表，要继承linearList类，并实现它的所有功能，另外，必须实现双向迭代器。 实现带头节点的双向循环链表，要具有以下的功能： 判断表是否为空，如果为空则返回true，不空返回false. 给出表中数据元素的个数。 给定一个索引（位置），返回指向该位置的数据元素的指针，如果给定的位置号不合法，则返回空指针。 给定数据元素x，如果表中有该元素，则返回x第一次出现的索引，若x 不存在，则返回-1. 删除给定索引的数据元素。 给定索引index ,数据元素x，将x插入到index的位置。 C++：设计一个结构体struct chainNode，再设计一个具体类 class doubleChain 作为抽象类 class linearList的派生类实现类linearList中的所有方法，外加实现双向迭代器； Java：设计一个接口interface linearList，设计一个类class doubleChainNode相当于C++中的结构体，设计一个类class doubleChainjava实现了了接口linearList所有方法，以及实现迭代器接口Iterable中的一个方法Iterator iterator();
数据结构——双向循环带头结点链表
weixin_68644350的博客
07-05 2602
双向循环带头结点链表的操作接口的实现
带头节点循环单链表【详细解析+完整代码】
ChenLin55的博客
05-17 7796
循环单链表在单链表的基础上进行改进。思考一下，普通单链表从表头遍历到表尾，时间复杂度为o(n)，如果我想从表尾找到表头呢？时间复杂度也还是o(n)。怎么快速从表尾找到表头，于是引入了循环链表。整个链表形成闭环，表尾找到表头，时间复杂度为o(1)。循环单链表是首尾相连的一种单链表，即将最后一个结点的空指针改为指向头结点或第一个结点的形成一个环型，最后一个结点称为尾指针:tail。判断单链表为空的条件是 head->next == NULL，而判断循环单链表为空的条件是。
带表头节点的单向循环链表编程
fly__chen的博客
11-08 4601
带表头节点的循环链表编程
笔记6：链表（三种：头指针、头结点、头结点循环）
yangzi_的博客
08-03 488
1、头指针链表 #include #include #define TRUE 1 #define FALSE 0 typedef int LinkData; // 链表的数据类型 typedef struct _node { LinkData data; // 链表的数据 struct _node *next; // 指向链表下一个结点的指针 }N
04线性表之带哨兵位头结点的双向循环链表
精致的灰的博客
08-01 748
单向链表存在一些缺陷：1.无法从后往前遍历。2.无法找到节点的前一个节点。3.插入和删除数据的时间复杂度为O（N）。这对这些缺陷，双向循环链表提供了很好的解决办法，双向循环链表的插入和删除时间复杂度为O（1）。 文章目录带头双向循环链表带头双向循环链表代码实现 带头双向循环链表 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了。 这个链表的结构如下：箭头的指向就代
带头结点的循环链表实现（C++）
weixin_45973487的博客
07-14 2038
带头结点的循环链表实现 先上代码，循环链表的数据结构定义和单链表是相同的。 #include <iostream> #include <string> using namespace std; typedef struct{ int num; string name; }ElemType; typedef struct Node{ ElemType data; Node* next; }Node,*CLList; struct CircleLinkList{ CLLi
双向循环链表带表头结点（各基本操作的小扩展代码）
qq_43613919的博客
02-17 497
/***************************************************** copyright (C), 2014-2015, Lighting Studio. Co., Ltd. File name： Author：Jerey_Jobs Version:0.1 Date: Description： Funcion List: ****...
循环链表的头节点（java）
lianggege88的博客
05-22 1722
问题描述： 寻找循环链表的头结点。 思路分析： 寻找头节点，就要记录以前找过的结点，故我们使用hash表来记录结点，如果遇到重复，则直接返回即可。 代码见下： 结点类定义 package List; class Node{ int data; Node next; public Node(int data) { this.data = data; } } 实现类定义： package List; import java.util.HashSet; p
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值