单循环链表（C语言实现）

最新推荐文章于 2024-03-28 09:01:30 发布
最新推荐文章于 2024-03-28 09:01:30 发布
阅读量402 收藏
点赞数
分类专栏： 数据结构

//CList.h
//结构体定义以及函数声明


#ifndef CLIST_H
#define CLIST_H

#include <stdio.h>
#include <assert.h>
#include <malloc.h>
#include <iostream>

typedef  int ElemType;

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node, *PNode;

typedef struct List
{
    PNode head;
    PNode tail;
    int size;
}List,*PList;

bool InitList(PList list);
void Create_t(PList list,ElemType x);             //尾插
void Create_h(PList list,ElemType x);             //头插
void del_back(PList list);                        //尾删
void del_front(PList list);                       //头删
void sortList(PList list);                        //排序
void insert_val(PList list,ElemType x);           //按值插
PNode find(PList list,ElemType x);
void del_val(PList list,ElemType x);
void modify(PList list,ElemType x1,ElemType x2);
void clear(PList list);
void destroy(PList list);
void reserve(PList list);
int length(PList list);
void menu();
void showList(PList list);
void show_tail(PList list);
ElemType next(PList list,ElemType x);
ElemType prio(PList list,ElemType x);
PNode prev(PList list,PNode p);

#endif
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

//CList.cpp
//函数实现

#include"CList.h"

void menu()           //提供选项的菜单函数
{
    printf("***************************************************************\n");
    printf("* [0] quit_system [1] Create_t   [2] Create_h    [3] showList *\n");
    printf("* [4] del_back    [5] del_front  [6] insert_val  [7] show_tail*\n");
    printf("* [8] find        [9] del_val    [10] sortList   [11] modify  *\n");
    printf("* [12]clear       [13]destroy    [14] resver     [15]length   *\n");
    printf("* [16] next       [17]prio                                    *\n");
    printf("***************************************************************\n");
}
bool InitList(PList list)
{
    list->head = (PNode)malloc(sizeof(Node)); /初始化一个头结点
    assert(list->head != NULL);               //断言，表达式为真，接着往下执行

    list->head->next = list->head;            //初始化head和tail指针，使其都指向头节点
    list->tail = list->head;

    list->size = 0;                           //长度初始化为0
    return true;
}

void Create_t(PList list,ElemType x)     //尾插法
{
    PNode s = (PNode)malloc(sizeof(Node));
    assert(s != NULL);
    s->data = x;                         //填充数据域
    list->tail->next = s;                //tail指向最后一个节点，把新建立的节点链接到链表的最后
    s->next = list->head;                //单循环链表，新节点的next指向头结点           
    list->tail = s;                      //改变尾指针的指向
    list->size++;
} 
void showList(PList list)            //链表显示函数
{
    if(1>list->size)
    {
        printf("--链表为空\n");
        return ;
    }
    PNode p = list->head->next;
    while(list->head != p)           //逐个遍历链表
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
void Create_h(PList list,ElemType x)  //头插法
{
    PNode s = (PNode)malloc(sizeof(Node));
    assert(s != NULL);
    s->data = x;                             //填充数据域
    s->next = list->head->next;              //新节点指向第一个节点           
    list->head->next = s;                    //头节点的next指向新节点s
    if(list->size == 0)                      //如果是第一次头插，需改变尾指针和尾节点的next指向，之后都不改变
    {
        list->tail = s;
        list->tail->next = list->head;        
    }
    list->size++;        //插入一个，长度加1
}

void del_back(PList list)    //尾删
{
    if(0==list->size)
        return;
    PNode p = list->head;
    while(list->head != p->next->next)      //找到倒数第二个节点
    {
        p = p->next;
    }                      
    p->next = list->head;                   //把最后一个节点分离
    free(list->tail);                       //释放最后一个节点
    list->tail = p;                         //尾指针指向原来的倒数第二个节点（现在倒数第一）
    printf("--尾节点已删除\n");
    list->size--;
}

void del_front(PList list)   //头删
{
    if(0==list->size)
        return;
    else
    {
        PNode p = list->head->next;
        if(1==list->size) 
        {                                    //只有一个节点，若删去，需改变尾指针
            list->tail = list->head;
            list->head->next = list->head;
        }
        else
        {                
            list->head->next = p->next;      //头指针指向第二个节点    
        }
        free(p);                             //释放第一个节点
    }                            
    printf("--头节点已删除\n");
    list->size--;
}


void show_tail(PList list)     //为测试尾指针是否正确改变，需显示最后一个节点
{
    printf("--链表的尾节点是：》%d \n",list->tail->data);
}

void sortList(PList list)      // 对无序链表进行从小到大排序
{
    if(2>list->size)
        return ;
    PNode p = list->head->next;
    PNode q = p->next;
    for(int i = 0;i<list->size-1;i++,p = list->head->next,q = p->next)      //n个数比较n-1趟
    {
        for(int j = 0;j<list->size-1-i;j++,p=q,q=q->next)   //第i趟比较n-i次
        {
            if(p->data > q->data)        //如果前面的数大于后面，则交换
            {
                p->data = p->data + q->data;
                q->data = p->data - q->data;
                p->data = p->data - q->data;
            }
        }
    }
}

void insert_val(PList list,ElemType x)   //链表有序的前提下，给一个值插入
{
    PNode p = list->head->next,q = list->head;
    while(list->head != p)               //找到能插入的位置，会在p、q之间
    {   
        if(x<p->data)
            break;
        q = p;
        p = p->next;
    }
    PNode s = (PNode)malloc(sizeof(Node)); //初始化新节点
    s->data = x;
    q->next = s;              //把新节点插入到链表中（在p,q之间插入）
    s->next = p;
    if(list->head == p)       //如果新节点的值最大，即尾插，需改变尾指针和尾节点的next指向
    {
        list->tail = s;
        list->tail->next=list->head;
    }
    list->size++;
}

PNode find(PList list,ElemType x)       //返回要查找元素的前面一个的地址
{
    PNode p = list->head;
    while(list->tail != p && list->head != p->next && x != p->next->data)
    {
        p = p->next;                   //循环结束，p指向x的前面一个元素
    }                      
    if(list->head == p->next)          //如果p指向最后一个元素，说明没有找到
    {
        printf("--没找到！\n");
        return NULL;
    }
    return p;
}

void del_val(PList list,ElemType x)     //删除指定的值x
{
    if(0 == list->size)
        return ;
    PNode p = find(list,x);
    PNode q = NULL;
    if(NULL != p)
    {
        q = p->next;               //q指向要删除的节点  
        if(q == list->tail)        //若删除最后一个节点，需改变尾指针
        {
            p->next = list->head;
            list->tail = p;
        }
        else
        {
            p->next = q->next;
        }
        free(q);                  //释放要删除的节点
        list->size--;
        printf("--%d已删除!\n",x);
    }
    return ;
}

void modify(PList list,ElemType x1,ElemType x2)    //把原有的x1修改成x2
{
    PNode p = find(list,x1);
    if(NULL != p)
        p->next->data = x2;
    else
        return ;
}

void clear(PList list)       //删除链表的所有节点，但不删除头结点
{
    PNode p = list->head->next;
    PNode q = p;
    while(list->head != p)      
    {
        p = p->next;         //p依次后移，跟屁虫q依次释放节点
        free(q);
        q = p;
    }
    list->tail = list->head;   //修改尾指针和链表长度
    list->head->next = list->head;
    list->size = 0;
    printf("--链表已被清空！\n");
}

void destroy(PList list)   //摧毁链表，包括所有节点和头结点
{
    clear(list);
    free(list->head);
    list->head = NULL;
    list->tail = NULL;
    printf("--链表已被摧毁！\n");
}

PNode prev(PList list,PNode p)     //返回p指向的前面一个节点
{
    if(p != list->head)
    {
        PNode q = list->head->next;
        while(q != list->head && q->next != p)  //依次往后移，知道尾指针的前面一个节点
            q=q->next;
        if(q->next == p)
            return q;
    }
    return NULL;
}
void reserve(PList list)   //逆置链表 
{
    PNode s = (PNode)malloc(sizeof(Node));       //建立一个节点
    s->next = list->tail;
    PNode p = list->tail;
    while(list->tail != list->head->next)        //把原链表的尾节点到第一个节点依次连接到新节点上
    {
        list->tail = prev(list,list->tail);
        list->tail->next = list->head;
        p->next = list->tail;
        p=p->next;
    }
    p->next = s;              //p指向第一个节点，即新链表的最后一个节点，尾指针的next指向头结点s，链表结束
    free(list->head);         //释放原来的头结点
    list->head = s;           //把s变成新的头指针
}

int length(PList list)     //求链表的长度
{
    return list->size;
}

ElemType next(PList list,ElemType x)      //返回x的后继
{
    PNode p = find(list,x);  
    if(NULL == p) 
        return -1;
    if(p->next == list->tail)           //因为是单循环链表，尾节点的下一个元素是第一个节点
    {
        return list->head->next->data;    
    }
    p=p->next;
    return p->next->data;
}
ElemType prio(PList list,ElemType x)         //返回x的前驱
{
    PNode p = find(list,x);
    if(NULL != p)
    {
        if(p == list->head || p == list->tail)
        {
            return list->tail->data;
        }
        return p->data;
    }
    return -1;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283

//main.cpp
//测试函数

#include "CList.h"

int main()
{
    List mylist;
    InitList(&mylist);
    ElemType item = 0;
    int pos = 0;
    int chose = 1;
    PNode p = NULL;
    while(chose)
    {
        menu();
        printf("给出想要操作的序号：\n");
        scanf("%d",&chose);
        switch(chose)
        {
        case 0:
            destroy(&mylist);
            chose = 0;
            break;
        case 1:
            printf("输入要尾插的数据[-1结束]：\n");
            while(scanf("%d",&item),item!=-1)
            {
                Create_t(&mylist,item);
            }
            break;
        case 2:
            printf("输入要头插的数据：\n");
            while(scanf("%d",&item),item!=-1)
            {
                Create_h(&mylist,item);
            }
            break;
        case 3:
            showList(&mylist);
            break;
        case 4:
            del_back(&mylist);
            break;
        case 5:
            del_front(&mylist);
            break;
        case 6:
            printf("给出要插入的数：\n");
            scanf("%d",&item);
            insert_val(&mylist,item);
            break;
        case 7:
            show_tail(&mylist);
            break;
        case 8:
            printf("输入要查找的数：\n");
            scanf("%d",&item);
            p = find(&mylist,item);
            if(NULL!=p)
                printf("%d\n",p->next->data);
            break;
        case 9:
            printf("输入要删除的数：\n");
            scanf("%d",&item);
            del_val(&mylist,item);
            break;
        case 10:
            sortList(&mylist);
            break;
        case 11:
            printf("输入要修改的数和修改后的数\n");
            scanf("%d %d",&item,&pos);
            modify(&mylist,item,pos);
            break;
        case 12:
            clear(&mylist);
            break;            
        case 13:
            destroy(&mylist);
            break;
        case 14:
            reserve(&mylist);
            break;
        case 15:
            printf("链表长度为：%d\n",length(&mylist));
            break;
        case 16:
            printf("输入想要找哪个一数的后继：\n");
            scanf("%d",&item);
            printf("%d 的后继是：%d\n",item,next(&mylist,item));
            break;
        case 17:
            printf("输入想要找哪个一数的前驱：\n");
            scanf("%d",&item);
            printf("%d 的前驱是：%d\n",item,prio(&mylist,item));
            break;
        default:
            printf("重新输入\n");
            break;
        }   
    }
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
版权声明：本文为博主原创文章，未经博主允许不得转载。 http://blog.csdn.net/Chengzi_comm/article/details/51387151
csshuke
关注
专栏目录
循环链表（C语言)
weixin_54454406的博客
10-15 292
注意：我们需要首先创建一个新的节点，然后调整节点的指针以适应新的链表结构。否则，将其添加到尾节点的后面，并更新尾节点为新节点。当插入新节点时，利用头节点的指针域始终指向头节点的后继节点的特点，来对新插入的节点完成前驱后继节点的设置。1.4：删除指定节点：前一个节点的 next 指针指向当前节点的下一个节点，从而删除当前节点。1.5：查找指定值：遍历链表中的每个节点，如果节点的数据等于目标值，就返回该节点在链表中的位置。头和尾插法建立：在循环链表的尾部或指定位置插入一个新的节点，更新后继指针和头节点指针。
【C语言数据结构】之循环链表
最新发布
weixin_61276540的博客
09-18 945
本文主要讲解数据结构的循环链表。主打一个手搓代码，能把代码写出来才是最重要的事情。
c语言 实现循环链表
jiangjun_feng的博客
05-01 624
原文地址 挺厉害的，没有错误 #include <stdio.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 typedef int Status; // Status是函数结果状态，成功返回TRUE,失败返回FALSE typedef int ElemType; /* 线性表的循环链表存储结构 */ typedef struct node { ElemType data; struct node *next; }
c语言实现单向循环链表
hkhl_235的博客
10-12 1145
c语言实现单向循环链表
循环链表C语言实现
02-03
代码包含以下功能，经过产品验证，代码运行可靠。 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素； 9.将游标重置指向链表中的第一个数据元素； 10.将游标移动指向到链表中的下一个数据元素； 11.直接指定删除链表中的某个数据元素。
约瑟夫环单循环链表C语言实现
12-12
### 约瑟夫环单循环链表C语言实现 #### 背景与问题描述 约瑟夫环（Josephus Problem）是一个经典的数学问题，最早由Flavius Josephus在公元前1世纪提出。该问题的基本形式是：N个人围成一个圈，从第一个人开始报数...
C语言单循环链表的表示与实现实例详解
09-04
本文将深入探讨C语言中如何表示和实现单循环链表。 单循环链表的特点在于它的最后一个节点指向了链表的第一个节点，形成一个循环，使得链表没有明显的起点和终点。这种结构使得遍历链表变得更为简单，因为可以从...
数据结构——双向循环链表（C语言实现）
GDYJLXQ的博客
10-22 369
双向循环链表：结构复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势。
C语言循环链表的简单应用
07-25
### C语言循环链表的简单应用 #### 一、引言 在计算机科学中，链表是一种常用的数据结构，它由一系列节点组成，每个节点包含数据元素和指向链表中下一个节点的指针。循环链表是链表的一种特殊形式，其中最后一个...
双向链表和循环链表
berniebd的专栏
09-03 1373
一、循环链表循环链表是与单链表一样，是一种链式的存储结构，所不同的是，循环链表的最后一个结点的指针是指向该循环链表的第一个结点或者表头结点，从而构成一个环形的链。循环链表的运算与单链表的运算基本一致。所不同的有以下几点：1、在建立一个循环链表时，必须使其最后一个结点的指针指向表头结点，而不是象单链表那样置为NULL。此种情况还使用于在最后一个结点后插入一个新的结点。 2、在判断是否到表尾时，是判断
C语言循环链表
you__know的专栏
11-13 745
//声明下，这是一个循环链表，只实现了循环链表的创建以及遍历 //可供初学者学习 #include #include typedef struct node //定义一个结构体 { int data; struct node *next; }Node; Node *create(int a) //创建一个循环链表，并返回它的头指针。 { N
数据结构_循环链表(C语言)
小黯
07-17 868
循环链表 1.结构解析 循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。 图示： 2.源代码: #include<stdio.h> #include<stdlib.h> typedef char ElemType; typedef struct CNode { ElemType data; struct CNode *next; }CNode, *CLinkList; void InitList(CLinkList
C语言数据结构之循环链表
m0_58303983的博客
10-15 632
指针域至少包括一个指向下一个节点的指针，一个指向前一个节点的指针（在第一个节点中为NULL），以及一个指向链表头节点的指针。将要删除的节点的prev指针的next指针指向要删除的节点的next指针所指向的节点；将要删除的节点的next指针的prev指针指向要删除的节点的prev指针所指向的节点；将头节点的prev指针的next指针指向头节点的next指针所指向的节点；将头节点的next指针的prev指针指向头节点的prev指针所指向的节点；将前一个节点的next指针指向新节点的next指针所指向的节点。
C语言实现循环链表
Luminescent_fish的博客
01-26 792
数据结构学习笔记|循环链表的创建、初始化、判空与表尾结点判断的代码实现
循环链表-数据结构（C语言）
2301_79870182的博客
10-14 235
在将循环链表之前我们第一步要掌握的是链表，循环链表是链表的一种。循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。
数据结构-循环链表【C语言版】
极客代码
03-28 353
本教程详细介绍了循环链表的概念、操作及其在 C 语言中的实现。循环链表相较于单链表，具有更高的灵活性，适用于需要频繁在链表头部和尾部进行操作的场景。通过对本教程的学习，相信您已经掌握了循环链表的基本知识和编程技巧。在实际开发中，根据需求选择合适的链表结构，可以提高程序的运行效率。
C语言数据结构——循环链表
m0_73676323的博客
06-12 1668
在双向循环链表中，每个结点包括三个域，分别是 data 域、next 域和 prev 域，其中data域为数据域，next 域为指向后继结点的指针域，prev域为指向前驱结点的指针域。下图为链表的结点结构。
C语言单循环链表详解：创建与操作实现
在C语言中，单循环链表通常通过定义一个`struct LNode`结构体来实现，包含一个数据域`data`和一个指向下一个节点的指针`next`。例如： ```c struct LNode { ElementType data; struct LNode* next; }; ``` 为了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值