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

//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

//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;
}

//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;
}

时间： 2024-10-08 15:49:49

单循环链表（C语言实现）的相关文章

(续)顺序表之单循环链表(C语言实现)

单循环链表和单链表的唯一区别在于单循环链表的最后一个节点的指针域指向第一个节点, 使得整个链表形成一个环. C实现代码如下: #include<stdio.h> typedef struct node { int data; struct node *next; }Node; //链表的初始化 Node* InitList(int number) { int i; Node *pHead=(Node *)malloc(sizeof(Node)); Node *TempHead=pHead; N

约瑟夫环 C语言单循环链表

/*---------约瑟夫环---------*/ /*---------问题描述---------*/ /*编号为1,2,-,n的n个人围坐一圈,每人持一个密码(正整数). 一开始任选一个正整数作为报数上限值m, 从第一个人开始自1开始顺序报数,报到m时停止. 报m的人出列,将他的密码作为新的m值,从他的下一个人开始重新从1报数, 如此下去,直至所有人全部出列为止.试设计一个程序求出列顺序.*/ /*---------问题分析---------*/ /*n个人围坐一圈,且不断有人出列,即频繁

【数据结构】两个单循环链表的连接操作

如果在单链表或头指针表示的链表上操作这个比较消耗性能,因为都需要遍历第一个链表,找到an,然后将b1链接到an的后面,时间复杂度是:O(n).若在尾指针表示的单循环链表上实现,则只需改变指针,无需遍历,时间复杂度是:O(1) 现在看算法实现,需要4个主要步骤,都注释了: LinkList Connect(LinkList A,LinkList B){ //假设A,B为非空循环链表的尾指针 LinkList p = A->next;//1.保存A链表的头结点的位置 A->next = B->

设立尾指针的单循环链表的表示和实现

设有尾指针的单循环链表的12个基本操作 void InitList(LinkList &L){ L = (LinkList)malloc(sizeof(LNode));//产生头结点,并使L指向此头结点 if (!L)exit(OVERFLOW); L->next = L;//头结点的指针域指向头结点 } void ClearList(LinkList &L){ LinkList p, q; L = L->next;//L指向头结点 p = L->next;//p指向第一

数据结构与算法——线性表链式存储（单循环链表）

今天总结循环单链表什么是单循环链表? 单链表终端结点的指针域是指向空的,如果将其指向头结点,这样就形成了一个环,那么这种首尾相接的环就够成了单循环链表. 单链表中我们都是用头指针来表示的,但是在单循环链表里,用尾指针(指向最后一个节点).为什么要这样,因为如果用头指针,那么当查找最后一个元素的时候,就要循环遍历,时间复杂度为O(n),如果用尾指针,时间复杂度为O(1),而因为是循环的,所以头指针很容易表示出来即rear->next,时间复杂度也是O(1) 单循环链表中需要注意两点: 头指针使用

数据结构学习--单循环链表(python)

概念将单链表的终端节点的指针由原来的空指针改为指向头节点, 就是整个单链表形成一个环, 这种首尾相接的单链表称为单循环链表. 实现 class Node: """ 节点 """ def __init__(self, value): self.data = value self.next = None class CircularLinkedList: def __init__(self): self.rear = None # 尾节点 def

写给过去的自己-No.1-数据结构篇-单向链表C语言的实现

过去的自己,你好. 今天我来教你单向链表,不知道你何时会看到这篇文章,也不知道你此刻对C语言的掌握,我会尽可能讲解细一点. 讲链表之前我先讲一下数组.相信你不管怎样肯定用过数组对吧,数组就是一种数据的组织形式,特点是所有的数据在逻辑上是顺序摆放的,通过数组名和数组下标就可以找到某个元素,而且在内存中存放的物理地址也是连续的,定义数组时,一旦中括号中的数字确定了,数组中元素个数也就确定了.那么问题来了,因为数组的大小需要提前确定,所以定义数组时必须统计好程序中用了多少元素,用多

单向链表 c语言实现

定义(引用百度百科)单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素.链表中的数据是以结点来表示的,每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置),元素就是存储数据的存储单元,指针就是连接每个结点的地址数据. 场景在实际生产中,有可能在软件启动后,对一些数据进行多态扩容,比如,网卡收发包的时候,从协议栈上产生一个需求的包,需要暂时排队,等网卡把数据发送出去后,在在队列里处理,所以这种利用堆中分散的内存,以结点为单位的数据结果是有一定的意义

静态链表 C语言描述

静态链表1.下标为0的游标存放最后存放数据节点的游标,即是第一个没有存放元素(备用链表)的下标2.最后一个的节点存放第一个由数值得下标3.第一个和最后一个都不存放数据即是备用链表的第一个的下标 4.最后一个存储数据的节点的游标为0 静态链表主要是根据游标来遍历,以前没有指针用的思想假如我要删除一个元素图不多描述,自己画画就明白,然后代码部分.都有注释, 1 #include <stdio.h> 2 #define ElemType int 3 #define Status int 4 #