数据结构-线性表-单循环链表（使用尾指针）（c++）

最新推荐文章于 2023-10-19 19:17:41 发布
最新推荐文章于 2023-10-19 19:17:41 发布
阅读量4.8k 收藏 37
点赞数 9
分类专栏： c++数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40666149/article/details/106218929
版权

目录

单循环链表

说明

单循环链表和单链表（参考单链表）大致一样，只是尾结点要指向头结点，本文是使用尾结点rear来表示，之所以使用尾指针，是因为如果使用头结点来寻找列表最后一个元素时间复杂度为O(n),如果使用尾结点来寻找列表最后一个元素时间复杂度为O(1)

注意
  1. 第一个元素地址表示：rear->next->next;最后一个元素地址：rear
  2. 头指针的表示，单链表使用front来标识头指针，单循环链表使用rear->next来表示
  3. 单链表使用p->next=NULL判断是否为尾结点，单循环链表使用p==rear判断是否为尾结点

（一）无参构造函数

建立尾结点，使尾结点指针域指向自己，说明链表为空

template<class T>
CircleList<T>::CircleList()
{
    rear=new Node<T>;
    rear->next=rear;
}

（二）有参构造函数

这里的方法相当于单链表中使用的尾插法，

  1. 为rear开辟空间
  2. 创建头指针Headr，并把rear的地址赋给Headr
  3. 使用for循环将数组依次加入到列表中
  4. 创建一个临时结点temp
  5. 为temp值域赋值，并把其地址赋给rear->next
  6. 修改rear地址
  7. 最后将rear指回头结点
template<class T>
CircleList<T>::CircleList(T a[],int len)
{
    rear = new Node<T>;
    Node<T>* Headr;
    Headr = rear;
    for (int i=0;i<len;i++)
    {
        Node<T>* temp = new Node<T>;
        temp->data = a[i];
        rear->next = temp;
        rear = temp;
    }
    rear->next = Headr;
}

（三）析构函数

与单链表相似，只是最后rear要单独释放

template<class T>
CircleList<T>::~CircleList()
{
    Node<T>* p=rear->next;
    while(p!=rear)
    {
        rear->next=p;
        p=p->next;
        delete rear->next;
    }
    delete rear;
}

（四）获取长度

与单链表相似，只是j的初始值要为1，因为while循环的终止条件为p!=rear,但是rear为最后一个元素，需要算上，所以j的初始值为1

template<class T>
int CircleList<T>::GetLength()const
{
    int j=1;
    Node<T>* p=rear->next->next;
    while(p!=rear)
    {
        j++;
        p=p->next;
    }
    return j;
}

（五）打印数组

因为while循环的终止条件为p!=rear,但是rear为最后一个元素，所以需要单独打印rear；其中if(i%5==4)是控制5个元素为一行

template<class T>
void CircleList<T>::Print()const
{
     Node<T>* p=rear->next->next;
     int i=0;
     while(p!=rear)
     {
         std::cout<<p->data<<" ";
         if(i%5==4)
            std::cout<<std::endl;
        p=p->next;
        i++;
     }
     std::cout<<rear->data<<std::endl;
}

（六）获取第i个元素的地址

与单链表相似，需要注意的是，如果取最后一个元素，需要使用if(GetLength()==i)return rear;单独判断

template<class T>
Node<T>* CircleList<T>::Get(int i)const
{
    int j=0;
    Node<T>* p=rear->next;
    if(GetLength()==i)return rear;
    while(p!=rear&&j!=i)
    {
        p=p->next;
        j++;
    }
    return p;
}

（七）插入

和单链表略有不同

  1. 先判断插入位置是否正确
  2. 然后在插入
template<class T>
void CircleList<T>::Insert(int i,T x)
{
    Node<T>* p=rear->next;
    if(i<0||i>GetLength())throw"位置异常";
    if(i!=1)
        p=Get(i-1);
        Node<T>* s=new Node<T>;
        s->data=x;
        s->next=p->next;
        p->next=s;
}

（八）删除

  1. 获取第i-1位置的地址
  2. q表示第i个元素
  3. 摘链
  4. 释放

如果删除最后一个元素需要单独释放：

  1. 用temp存储最后元素的地址
  2. 让rear指向倒数第二个元素
  3. 摘链，让倒数第二个元素指向头结点
  4. 释放
template<class T>
void CircleList<T>::Delete(int i)
{
    Node<T>* p=rear->next;
    if(i!=1)
        p=Get(i-1);
    if(i==GetLength())
    {
        Node<T>* temp=rear;
        rear=p;
        rear->next=temp->next;
        delete temp;
    }
    else
    {
        Node<T>* q=p->next;
        p->next=q->next;
        delete q;
    }
}

（九）获取值为x的元素的位置

template<class T>
int  CircleList<T>::Location(T x)const
{
    int j=0;
    Node<T>* p=rear->next->next;
    if(x==rear->data)return GetLength();
    while(p!=rear)
    {
        j++;
        if(p->data==x)
            return j;
        p=p->next;
    }
}

（十）排序

使用的是冒泡排序，循环的终止条件与单链表不同

template<class T>
void CircleList<T>::sort()
{
    for(int i=1;i<=CircleList<T>::GetLength();i++)
    {
        Node<T>* p=rear->next->next;
        while(p!=rear)
        {
            if(p->data>p->next->data)
            {
                T t;
                t=p->next->data;
                p->next->data=p->data;
                p->data=t;
            }
            p=p->next;
        }
    }
}

（十一）连接

  1. 保存b链的头结点
  2. b链的尾指向当前链表的头
  3. 当前链表的尾，指向b链的第一个元素
  4. 修改尾指针
  5. 将b链置空，并且把b.rear指向这个节点
template<class T>
void CircleList<T>::Connect(CircleList<T> &b)
{
    if(b.rear==b.rear->next)return;
    Node<T>* p=b.rear->next;//保存b链的头结点
    b.rear->next=rear->next;//b链的尾指向当前链表的头
    rear->next=p->next;//当前链表的尾，指向b链的第一个元素
    rear=b.rear;//修改尾指针
    b.rear=p->next=p;//将b链置空，并且把b.rear指向这个节点
}

（十二）整个文件

CircleList.h
#ifndef CIRCLELIST_H_
#define CIRCLELIST_H_
#include<iostream>
template<class T>
struct Node
{
    T data;
    struct Node<T>* next;
};
template<class T>
class CircleList
{
private:
    Node<T>* rear;
public:
    CircleList();
    CircleList(T a[],int len);
    ~CircleList();
    int GetLength()const;
    void Print()const;
    void Insert(int i,T x);
    void Delete(int i);
    Node<T>* Get(int i)const;
    int Location(T x)const;
    void sort();
    void Connect(CircleList<T> &b);
};
template<class T>
CircleList<T>::CircleList()
{
    rear=new Node<T>;
    rear->next=rear;
}
template<class T>
CircleList<T>::CircleList(T a[],int len)
{
    rear = new Node<T>;
    Node<T>* Headr;
    Headr = rear;
    for (int i=0;i<len;i++)
    {
        Node<T>* temp = new Node<T>;
        temp->data = a[i];
        rear->next = temp;
        rear = temp;
    }
    rear->next = Headr;
}
template<class T>
CircleList<T>::~CircleList()
{
    Node<T>* p=rear->next;
    while(p!=rear)
    {
        rear->next=p;
        p=p->next;
        delete rear->next;
    }
    delete rear;
}
template<class T>
int CircleList<T>::GetLength()const
{
    int j=1;
    Node<T>* p=rear->next->next;
    while(p!=rear)
    {
        j++;
        p=p->next;
    }
    return j;
}
template<class T>
void CircleList<T>::Print()const
{
     Node<T>* p=rear->next->next;
     int i=0;
     while(p!=rear)
     {
         std::cout<<p->data<<" ";
         if(i%5==4)
            std::cout<<std::endl;
        p=p->next;
        i++;
     }
     std::cout<<rear->data<<std::endl;
}
template<class T>
void CircleList<T>::Insert(int i,T x)
{
    Node<T>* p=rear->next;
    if(i<0||i>GetLength())throw"位置异常";
    if(i!=1)
        p=Get(i-1);
        Node<T>* s=new Node<T>;
        s->data=x;
        s->next=p->next;
        p->next=s;
}
template<class T>
void CircleList<T>::Delete(int i)
{
    Node<T>* p=rear->next;
    if(i!=1)
        p=Get(i-1);
    if(i==GetLength())
    {
        Node<T>* temp=rear;
        rear=p;
        rear->next=temp->next;
        delete temp;
    }
    else
    {
        Node<T>* q=p->next;
        p->next=q->next;
        delete q;
    }
}
template<class T>
Node<T>* CircleList<T>::Get(int i)const
{
    int j=0;
    Node<T>* p=rear->next;
    if(GetLength()==i)return rear;
    while(p!=rear&&j!=i)
    {
        p=p->next;
        j++;
    }
    return p;
}
template<class T>
int  CircleList<T>::Location(T x)const
{
    int j=0;
    Node<T>* p=rear->next->next;
    if(x==rear->data)return GetLength();
    while(p!=rear)
    {
        j++;
        if(p->data==x)
            return j;
        p=p->next;
    }
}
template<class T>
void CircleList<T>::sort()
{
    for(int i=1;i<=CircleList<T>::GetLength();i++)
    {
        Node<T>* p=rear->next->next;
        while(p!=rear)
        {
            if(p->data>p->next->data)
            {
                T t;
                t=p->next->data;
                p->next->data=p->data;
                p->data=t;
            }
            p=p->next;
        }
    }
}
template<class T>
void CircleList<T>::Connect(CircleList<T> &b)
{
    if(b.rear==b.rear->next)return;
    Node<T>* p=b.rear->next;//保存b链的头结点
    b.rear->next=rear->next;//b链的尾指向当前链表的头
    rear->next=p->next;//当前链表的尾，指向b链的第一个元素
    rear=b.rear;//修改尾指针
    b.rear=p->next=p;//将b链置空，并且把b.rear指向这个节点
}
#endif // CIRCLELIST_H_
UseCircleList.cpp
#include<iostream>
#include"CircleList.h"
const int SIZE=10;
int main()
{
    using std::cout;
    using std::endl;
    int ss[SIZE]={9,3,4,1,5,0,8,6,2,7};
    int qq[5]={0,1,2,3,4};
    CircleList<int> Grade(ss,SIZE);
    CircleList<int> B(qq,5);
    cout<<"链表内容："<<endl;
    Grade.Print();
    cout<<"长度为："<<endl;
    cout<<Grade.GetLength()<<endl;
    cout<<"查找5的位置："<<endl;
    cout<<Grade.Location(5)<<endl;
    cout<<"删除第10个位置后的内容："<<endl;
    Grade.Delete(10);
    Grade.Print();
    cout<<"此时长度为："<<endl;
    cout<<Grade.GetLength()<<endl;
    cout<<"在第9个位置插入11的内容："<<endl;
    Grade.Insert(9,11);
    Grade.Print();
    cout<<"排序后："<<endl;
    Grade.sort();
    Grade.Print();
    Grade.Connect(B);
    cout<<"连接后："<<endl;
    Grade.Print();
    return 0;
}
m晴朗
关注
  • 9
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
考研系列-数据结构第二章、线性表
Nelson_hehe的博客
06-09 1903
本文是408考研付费专栏系列-数据结构线性表章节，本文章详细地总结了线性表的相关知识，其中包括：顺序表、链表（单链表、双链表、循环链表、静态链表等）的细节和重要知识点汇总。考研听课、复习的好帮手。
尾指针实现循环单链表
08-25
在VC6.0环境下实现了使用尾指针创建循环单链表，输出第一个和最后一个节点的值
尾指针循环单链表
good18Levin的博客
10-17 1675
#include<cstdio>//stdio.h效果一样 #include<stdbool.h> #include<malloc.h> #include<stdlib.h> typedef char Elemtype; typedef struct Node { Elemtype data; struct Node *next; }Node, *TailLinkList; //初始化带头结点、尾指针的循环单链表 void InitTailLinkLis
单循环链表(使用尾指针表示)
XuShuai
03-11 6046
#include #include /* 用尾指针表示的单循环链表，相比于使用头指针表示的单循环链表： * 后者在寻找链表的第一个节点的时候，时间复杂度是O(1),在寻找链 * 表的最后一个元素的时候，时间复杂度是O(n)。 * 前者在寻找链表的第一个节点的时候，事件复杂度是O(1)(tail->next * ->next->data即为第一个元素的值)，在寻找最后一个节点的时候，时间
带尾指针的循环单链表
最新发布
m0_74899987的博客
10-19 613
当参数为LinkList *L时，意味着需要改变或操作L这个指针指向的LinkList类型的指针。当函数参数为LinkList L时，意味着只改变或操作List的内容，而不需要改变L这个指针。③在第一个代码块中Node代表结点的类型，而LinkList代表指向Node结点类型的指针。这里对CLinkList *a的形参定义是：只对a进行遍历等操作不可以修改a的值。CLinkList *&b的形参定义是：可以修改b的值。对a的形参定义是：只对a进行遍历等操作，不可更改。对b的定义是可以修改b。
【数据结构与算法】- (带尾指针)单循环链表 - 详细实现步骤及代码(C/C++)
wkd_007的博客
03-30 7567
本文主要介绍带尾指针的单循环链表，以及详细的实现步骤讲解，最后提供一份自己实现带尾指针的单循环链表的C语言代码
C++数据结构 ---- 循环单链表
Jade1998
07-12 158
环境配置 codeblocks windows10 项目结构 代码 CLinkListClass.h #ifndef _CLINKLISTCLASS_H_ #define _CLINKLISTCLASS_H_ #include <iostream> template <typename T> class LinkListNode { public: ...
数据结构(线性表)：单循环链表
acesfre的博客
04-14 579
/* *数据结构：线性表的链式表示 *单链表 循环链表 *线性表元素序号从1算起 *Date:2017/4/13 */ #include #include #define InitSize 100 #define ElemType char typedef struct LNode{ ElemType data; int length; struct LNode *next;
【C++数据结构学习笔记---线性表】带头结点的单循环链表
EnCaL
03-13 1515
【C++数据结构学习笔记---线性表】带头结点的单循环链表 一个简单的实现例子，只用到了插入函数以及输出函数，初始化26个英文字母。 插入算法的思路：（insert）本算法为结点后插入 1、声明一结点p指向头结点，初始化i从0开始。 2、遍历链表，让指针p向后移动，直至移动到要插入元素的结点，即向后移动k-1次。 3、在系统中新建一个结点s。 4、使用s->next=p->next
数据结构第二章-线性表（详细知识点总结）
热门推荐
疯子书生的博客
11-25 1万+
第二章 线性表 【考纲内容】 （一）线性表的定义和基本操作 （二）线性表的实现 顺序存储；链式存储；线性表的应用 【框架】 2.1 线性表的定义和操作 2.1.1 线性表的定义 线性表是具有相同数据类型的n（n>=0）个数据元素的有限序列，其中n为表长，当n=0时，线性表是一个空表。若用L命名线性表，则其一般表示为                &nbs
数据结构实战——线性表（顺序表、链表——单链表、双链表、循环链表、静态链表）
wypds的博客
04-09 1015
数据结构线性表实战 顺序表、单链表（头插法、尾插法、双链表、循环链表、静态链表） 一、什么是线性表 二、顺序表 三、链表 一、单链表 1、头插法 2、尾插法 二、双链表 三、循环链表 四、静态链表 前言 提示：这里可以添加本文要记录的大概内容： 数据结构——线性表 提示：以下是本篇文章正文内容，下面案例可供参考 一、什么是线性表 线性表是具有相同数据类型的n(>=0)个数据元素的有限序列，n为表长，n=0时线性表是一个空表。若用L命名线性表，一般表示为：L=(a[1]，a[2]，a[3]，.
数据结构之线性表(顺序表与链表)--王道
weixin_64144469的博客
05-21 1026
目录 2.1线性表的定义和基本操作 2.1.1线性表的定义 2.1.2线性表的基本操作 2.2线性表的顺序表示 2.2.1顺序表的定义 2.2.2顺序表上基本操作的实现 2.3线性表的链式表示 2.3.1单链表的定义 2.3.2单链表上基本操作的实现 1.用头插法建立单链表 2.用尾插法 3.按序号查找结点值 4.按值查找表结点 5.插入结点操作 6.删除结点操作 7.求表长操作 2.3.3双链表 1.双链表的插入 2.双链表的删除 2.3.4循环链表...
【数据结构】C语言实现带尾指针循环单链表
weixin_43716338的博客
02-08 3301
带尾指针循环单链表带尾指针循环单链表基本操作定义存储结构类型尾插法创建带尾指针循环单链表头插法创建带尾指针循环单链表将两个带尾指针循环单链表合并遍历尾指针循环单链表测试代码 带尾指针循环单链表基本操作 定义存储结构类型 typedef struct LNode { int data; struct LNode *next; } LNode,*LinkList; 尾插法创建带尾指针循环单链表 //尾插法 void CreateList_R(LinkList *L,int n) //LinkList
单循环链表实现（设立尾指针）（第二章 P35）
但行好事，莫问前程
03-18 4134
设立尾指针的单循环链表 单链的循环链表结点的存储结构和单链表的存储结构一样，所不同的是：最后一个结点的 next 域指向头结点，而不是“空”。这样，由表尾很容易找到表头。 但若链表较长，则由表头找到表尾较费时，因而，单循环链表往往设立尾指针而不是头指针。 例：设立尾指针且具有 2 个结点（4,7）的单循环链表： 空（仅有头结点）的单循环链表 L： 循环链表...
删除一个递增非空单链表中值域重复的结点
qq_43648337的博客
07-21 1024
要求：删除一个递增非空单链表中值域重复的结点 void delete(LNode *L) { LNode *p,*q; p = L->next;//p指向第一个结点 while(p != NULL) { if(p->data == p->next->data)//如果相等则删除q指向的结点 { q = p->next;//q指向要删除的结点 p->next = q->next; free(q); } else {
单循环链表(用尾指针表示)
weixin_30622107的博客
02-12 746
1 #include<stdio.h> 2 #include<stdlib.h> 3 /* 用尾指针表示的单循环链表，相比于使用头指针表示的单循环链表： 4 * 后者在寻找链表的第一个节点的时候，时间复杂度是O(1),在寻找链 5 * 表的最后一个元素的时候，时间复杂度是O(n)。 6 * 前者在寻找链表的第一个节点的时候，事件复杂度是O(1...
设置尾指针的单循环链表
RowandJJ
04-06 9466
形态： 实现： /************************************* 设立尾指针的的单循环链表 by Rowandjj 2014.4.5 *************************************/ #include using namespace std; #define OK 1 #define OVERFLOW 0
（九）第 2 章 线性表 （仅设立尾指针的单循环链表（链式存储））
墨夜白
09-09 301
合并两个已知尾指针的单循环链表
C/C++实现单向循环链表(尾指针，带头尾节点)
weixin_34217773的博客
02-25 1111
　　C语言实现单向循环链表，主要功能为空链表创建，链表初始化（头插法，尾插法），链表元素读取，按位置插入，（有序链表）按值插入，按位置删除，按值删除，清空链表，销毁链表。 　　单向循环链表和单向链表的区别：（1）单向链表为头指针，循环链表为尾指针，头指针指向头结点，尾指针指向终端结点；（2）为统一方便操作，单向链表设置头结点，单向循环链表设置头结点和尾结点；（3）设置尾结点后，尾指针指向尾结点，...
数据结构-线性表详解
"沈阳工程学院信息工程系的数据结构课件，主要涵盖了线性表的概念、表示及实现" 在计算机科学中，数据结构是组织和管理数据的重要工具，它研究如何高效地存储、检索和操作数据。线性表是数据结构中最基础也是最常用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

m晴朗

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值