数据结构CC++版本-循环链表

最新推荐文章于 2022-03-19 15:10:08 发布
最新推荐文章于 2022-03-19 15:10:08 发布
阅读量216 收藏
点赞数
分类专栏： 数据结构 文章标签： 循环链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AdrianAndroid/article/details/100762228
版权

list_cycle.h

#ifndef LIST_CYCLE_H_INCLUDED
#define LIST_CYCLE_H_INCLUDED
#include <string>
#include <iostream>

#pragma once

#define status bool
#define OK true
#define ERROR false
#define YES true
#define NO false

using namespace std;

void runCycleList();

template <typename DType>
class Node
{
        public:
                DType data;
                Node * pnext;
};

template <typename DType>
class CCircleLinkList
{
        private:
                Node<DType> *phead;
        public:
                CCircleLinkList();
                ~CCircleLinkList();
        public:
                // 初始化链表
                status InitCList();
                // 获取链表长度
                int GetCListLength();
                // 增加一个节点 前插法
                status AddCListNodeFront(DType idata);
                // 增加一个节点 后插法
                status AddCListNodeBack(DType idata);
                // 判断链表是否为空
                status IsCListEmpty();
                // 获取指定位置节点值（注意，本程序规定0号为节点，e获取删除元素）
                status GetCListIndexNode(DType *e, int index);
                // 删除指定位置节点（e获取删除元素）
                status DeleteCListIndexNode(DType *e, int index);
                // 查找和链表中指定值(pindex获取位置0==>not found)
                status SearchCListNode(DType SData, int *pindex);
                // 指定位置前插
                status InsertCListNodeFront(DType IData, int index);
                //  指定位置后插
                status InsertCListNodeBack(DType IData, int index);
                // 清空链表（保留跟节点）
                status ClearCList();
                // 销毁链表（all delete）
                status DestroyCList();
                // 尾部删除一个元素
                status DeleteCListNohdeBack();
                // 打印链表 此函数根据实际情况而定
                void PrintCList();
};



//循环链表的节点
class ListCycleNode{
	public:
		int tag; //方便打印的时候指导末尾
		string name;
		ListCycleNode* next;

		bool hasNext(){
			return this->next  != NULL;
		}
};








#endif // LIST_CYCLE_H_INCLUDED

list_cycle.cpp

#include "list_cycle.h"
#include "tools.h"

#define TLDType  template <typename DType>

template <typename DType>
CCircleLinkList<DType>::CCircleLinkList()
{
    cout << "链表创建" << endl;
    InitCList();
}

template <typename DType>
CCircleLinkList<DType>::~CCircleLinkList()
{
    cout << "销毁链表" << endl;
    DestroyCList();
}

//初始化链表
template <typename DType>
status CCircleLinkList<DType>::InitCList()
{
        Node<DType> *ph = new Node<DType>;
        if(ph != NULL) {
                ph->pnext = ph; //尾指向头
                this->phead = ph;// 头节点
                return OK;
        }
        return ERROR;
}

//获取链表长度（head_node is not  include）
template <typename DType>
int CCircleLinkList<DType>::GetCListLength()
{
        int length = 0;
        Node<DType> *ph = this->phead;
        while(ph->pnext != this->phead)
        {
                length ++;
                ph = ph->pnext;
        }
        return length;
}

// 增加一个节点 前插法
template <typename DType>
status CCircleLinkList<DType>::AddCListNodeFront(DType idata)
{
        Node<DType> * pnode = new Node<DType>;
        if(pnode != NULL) {
                pnode->data = idata;
                pnode->pnext = this->phead->pnext;
                this->phead->pnext = pnode;//挂载

                return OK;
        }
        return ERROR;
}

// 增加一个节点 尾插法
TLDType
status CCircleLinkList<DType>::AddCListNodeBack(DType idata)
{
        Node<DType> * pnode = new Node<DType>;
        Node<DType> * ph = this->phead;
        if(pnode!=NULL) {
                while(ph->pnext != this->phead)
                {
                        ph = ph->pnext;
                }
                pnode->data = idata;
                pnode->pnext = this->phead;
                ph->pnext = pnode;//挂载
                return OK;
        }
        return ERROR;
}

// 判断链表是否为空
TLDType
status CCircleLinkList<DType>::IsCListEmpty(){
        if(this->phead->pnext == this->phead) {
                return YES;
        }
        return NO;
}

// 获取指定位置节点值(注意，本程序规定0为头节点，e获取节点的值）
TLDType
status CCircleLinkList<DType>::GetCListIndexNode(DType *e, int index)
{
        Node<DType> * ph = this->phead;
        int i = 0; //计数器
        if(ph->pnext == this->phead || index < 1 || index>GetCListLength()) {
                return ERROR;
        }
        while(ph->pnext != this->phead) {
                i++;
                ph = ph->pnext;
                if(i == index) {
                        *e = ph->data;
                        return OK;
                }
        }
        return ERROR;
}

//删除指定位置节点
TLDType
status CCircleLinkList<DType>::DeleteCListIndexNode(DType *e, int index)
{
        Node<DType> * ph = this->phead;
        int i = 0; //计数器
        Node<DType> *q = nullptr;
        if(ph->pnext == this->phead || index < 1 || index > GetCListLength()) {
                return ERROR;
        }
        while(ph->pnext != this->phead){
                i++;
                q = ph;//保存备用
                ph = ph->pnext;
                if(i == index)
                {
                        *e = ph->data;
                        q->pnext = ph->pnext;
                        delete ph;
                        return OK;
                }
        }
        return ERROR;
}

// 查找链表中指定值（pindex获取位置 0===>not found)
TLDType
status CCircleLinkList<DType>::SearchCListNode(DType SData, int *pindex)
{
        Node<DType> *ph = this->phead;
        int iCount = 0; //计数器
        while(ph->pnext != this->phead) {
                iCount++;
                ph = ph->pnext;
                if(ph->data == SData)
                {
                        *pindex = iCount;
                        return YES;
                }
        }
        *pindex = 0;
        return NO;
}

// 指定位置前插
TLDType
status CCircleLinkList<DType>::InsertCListNodeFront(DType IData, int index){
        Node<DType> * ph = this->phead;
        if(ph->pnext == this->phead || index < 1 || index > GetCListLength()) {
                return ERROR;
        }
        int iCount = 0; //计数器
        Node<DType> *q = nullptr;//备用
        while(ph->pnext != this->phead)
        {
                iCount++;
                q = ph;
                ph = ph->pnext;
                if(iCount == index) {
                        Node<DType> * p = new Node<DType>;
                        p->data = IData;
                        q->pnext = ph;
                        q->pnext = p;//前插
                        return OK;
                }
        }


        return ERROR;
}

TLDType
 status  CCircleLinkList<DType>::InsertCListNodeBack(DType IData, int index){
        Node<DType> * ph =  this->phead;
        if(ph->pnext == this->phead || index < 1 || index > GetCListLength()) {
                return ERROR;
        }
        int iCount = 0; //计数器
        Node<DType> * q = nullptr;//备用
        while(ph->pnext != this->phead)
        {
                iCount ++;
                q = ph;
                ph = ph->pnext;
                if(iCount == index) {
                        Node<DType> *p = new Node<DType>;
                        q = ph;
                        ph = ph->pnext; //后插就是后一个节点前插
                        p->data=IData;
                        p->pnext = ph;
                        q->pnext=p;
                        return OK;
                }
        }
        return ERROR;
 }

 // 清空链表（保留根节点）
 TLDType
status  CCircleLinkList<DType>::ClearCList(){
        Node<DType> *ph = this->phead;
        Node<DType> *q = nullptr;//防止那啥，野指针
        ph = ph->pnext; //保留头节点
        while(ph != this->phead){
                q = ph;
                ph = ph->pnext;
                delete q;
        }
        this->phead->pnext = this->phead;
        return OK;
}

//销毁链表
TLDType
status CCircleLinkList<DType>::DestroyCList(){
        ClearCList();
        delete this->phead;
        return OK;
}

TLDType
status  CCircleLinkList<DType>::DeleteCListNohdeBack(){
        Node<DType> *ph = this->phead;
        Node<DType> * q = nullptr;
        if(ph->pnext ==  this->phead) {
                return ERROR; // 链表都空了还删啥
        }
        while(ph->pnext != this->phead)
        {
                q = ph;
                ph = ph->pnext;
        }
        q->pnext = this->phead;
        delete ph;
        return OK;
}

TLDType
void CCircleLinkList<DType>::PrintCList(){
        Node<DType> *ph = this->phead;
        if(ph->pnext == this->phead) {
                cout << "链表为空，打印鸡毛" << endl;
        }
        int i = 1;
        cout << "==========print list===========" << endl;
        while(ph->pnext!=this->phead)
        {
                ph = ph->pnext;
                cout << "node["<< i++ << "] = "<< ph->data  << endl;
        }
}

// 运行循环list
void runCycleList()
{
        cout<<"Hello World!"<<endl;
        CCircleLinkList<int>  * pMySList = new CCircleLinkList<int>;
        cout << pMySList->IsCListEmpty() << endl;
        pMySList->AddCListNodeFront(111);
        pMySList->AddCListNodeFront(222);
        pMySList->AddCListNodeFront(333);

        cout << "链表长度" << pMySList->GetCListLength() << endl;
        pMySList->PrintCList();

        pMySList->AddCListNodeBack(444);
        pMySList->AddCListNodeBack(555);
        pMySList->AddCListNodeBack(666);

        pMySList->PrintCList();

        cout << pMySList->IsCListEmpty() << endl;
        cout << "链表长度" << pMySList->GetCListLength() << endl;

        int GetElem, GetIndex;
        pMySList->GetCListIndexNode(&GetElem, 2);
        cout << "Got Elem = " << GetElem << endl;

        pMySList->GetCListIndexNode(&GetElem, 6);
        cout << "Got Elem=" << GetElem << endl;

        pMySList->GetCListIndexNode(&GetElem, 4);
        cout<<"Got Elem"<<GetElem<<endl;

        pMySList->DeleteCListIndexNode(&GetElem, 1);
        cout << "del Elem = " << GetElem<<endl;
        pMySList->DeleteCListIndexNode(&GetElem, 3);
        cout<<"dle Elem="<<GetElem<<endl;

        pMySList->PrintCList();

        pMySList->SearchCListNode(555, &GetIndex);
        cout<<"Search Index ="<<GetIndex<<endl;
        pMySList->SearchCListNode(111, &GetIndex);
        cout<<"Search Index ="<<GetIndex<<endl;
        pMySList->SearchCListNode(666, &GetIndex);
        cout<<"Search Index="<<GetIndex<<endl;

        pMySList->InsertCListNodeFront(333,1);
        pMySList->InsertCListNodeBack(444,4);

        pMySList->PrintCList();

        pMySList->InsertCListNodeBack(777,3);
        pMySList->InsertCListNodeBack(888,3);

        pMySList->PrintCList();

        pMySList->DeleteCListNohdeBack();
        pMySList->PrintCList();
        pMySList->DeleteCListNohdeBack();
        pMySList->PrintCList();
        pMySList->DeleteCListNohdeBack();
        pMySList->PrintCList();



}
赵健zj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构CC循环链表PPT学习教案.pptx
10-08
数据结构CC循环链表PPT学习教案.pptx
c语言链表while循环终止条件,纯C语言实现循环双向链表创建，插入和删除
weixin_42474537的博客
05-18 330
#include #includetypedefintElemType;typedefstructDLNode{ElemType data;struct DLNode *next;struct DLNode *prior;}DLNode;DLNode*InitList(DLNode *DL);//初始化int ListEmpty(DLNode *DL);//判空int ListLength(DLN...
数据结构CC++版本-简单链表
AdrianAndroid的专栏
09-12 160
list.h #ifndef LIST_H_INCLUDED #define LIST_H_INCLUDED #include <iostream> #include <string> using namespace std; void runlistdemo(); class List { public: string name; ...
C/C++编程笔记：链接列表（链表）及其遍历，今天就教你
致力于C语言C++知识分享！
12-09 863
像数组一样，链表是线性数据结构。与数组不同，链接列表元素不存储在连续的位置；元素使用指针链接。 为什么要链接列表？ 数组可用于存储相似类型的线性数据，但是数组具有以下限制。 1）数组的大小是固定的：因此，我们必须提前知道元素数量的上限。而且，通常，所分配的存储器与用途无关而等于上限。 2）在元素数组中插入新元素非常昂贵，因为必须为新元素创建空间，并且为创建房间而必须移动现有元素。 例如，在系统中，如果我们在数组id []中维护ID的排序列表。 id [] = [1000，1010，1050，
循环链表的创建、插入、删除、逆序、显示（C++实现）
Zxn、Sirius荣耀之路
04-19 1993
对于单链表，由于每个结点只存储了向后的指针。到了尾标志就停止了向后链的操作，这样，当中某一结点就无法找到它的前驱结点了。 对于单链表的操作大家可以看我的这篇博客http://blog.csdn.net/zxnsirius/article/details/51183055我们将单链表中终端结点的指针端由空指针改为指向头结点，就使整个单链表形成了一个环，这种头尾相接的单链表称为单循环链表，简称循环链表
单向循环链表的合并图解
c++菜鸟一只。
05-06 6134
第一步：创建一个临时节点指针，指向链表 L2 的第一个数据节点即：ListNode * p = B->next->next; 第二步：将链表 L2 的最后一个节点 B 指向链表 L1 的 头节点即链表 L1 的最后一个节点 A 指向的节点：B->next = A->next； 第三步：将链表 L1 的最后一个节点 A 指向链表 L2 的第一个数据节点即 A->next = p;刚开始，怎么也搞不
数据结构报告c++代码+截图
08-05
3、用顺序存储来定义循环队列结构。编程实现，初始化队列、判队列为空、出队列、入队列、求队列头部元素等运算，自己填写主函数。 4、利用队列打印杨辉三角形。杨辉三角形是形如： 1 1 1 1 2 1 1 3 3 1 1 4 ...
python数据结构与算法详解与源码
08-20
数据结构与算法（Python） 一、引入概念 1-01算法引入 1-02 时间复杂度与大O表示法 1-03-最坏时间复杂度与计算规则 1-04-常见时间复杂度与大小关系 1-05-代码执行时间测量模块 1-06-Python列表类型不同操作的...
《数据结构 1800题》
12-27
《数据结构 1800题》 第一章 绪论 一、选择题 1. 算法的计算量的大小称为计算的（B ）。【北京邮电大学2000 二、3 （20/8分）】 A．效率 B. 复杂性 C. 现实性 D. 难度 2. 算法的时间复杂度取决于（C ）...
DataStructures.jl-864edb3b-99cc-5e75-8d2d-829cb0a9cfe8:来自https的最新快照
04-12
该软件包实现了多种数据结构，包括 双端队列（通过实现） 循环缓冲区 圆形双端 堆 队列 累加器和计数器（即多组/袋） 不相交集 二进制堆 可变二进制堆 有序字典和集合 具有默认值的字典 特里 链表和可变链表 排序...
循环链表及其接口函数的C++实现
王伴农
03-27 1444
转载请注明出处：http://blog.csdn.net/hongkangwl/article/details/22284249 首先建立节点的结构体 struct node { int date; node* ptrnext; }; 然后在循环链表的类中声明需要的成员和方法 class circlelinklist { private: int le
数据结构--链表--约瑟夫环问题（单向循环链表）
Michael是个半路程序员
03-14 5251
问题：一群人站成一个圆圈，从一个人开始报数，1， 2 ，。。。m，报到m的拉出去砍了，求被砍的顺序和最后一个活下来的。 利用单向循环链表实现 C++代码如下：（参考书籍：数据结构与算法实验指导书） #include &lt;iostream&gt; using namespace std; struct NodeType { int num; char name[20...
线性表—双链表、循环链表
qq_39172845的博客
03-19 861
双链表 双链表：在单链表基础上，增加了前驱指针的链表称为双链表。 //双链表中每个节点的定义 template <typename T> //T代表数据元素类型 struct DblNode { T data; //数据域，用来存放数据元素 DblNode<T>* prior; //前趋指针，指向前一个同类型（和本节点类型相同）的节点 DblNode<T>* next; //后继指针，指向下一个同类型（和本节点类型相同）的节点 }
循环链表c++实现
u012967763的专栏
12-19 1112
#ifndef _CIRCLELINK_H_ #define _CIRCLELINK_H_ #include #include "CircleLink.hpp" using namespace std; template struct Node {     DataType data;     Node *next; }; template class CircleLink
C++循环链表的实现
weixin_30398227的博客
01-19 464
// .hpp文件 #include <stdio.h> class NodeCList{ public: NodeCList(); static NodeCList* create(int element); int element; NodeCList* next; }; class CircleList { p...
C++单循环链表
u012332009的专栏
09-22 815
#include using namespace std; struct LinkLinst { char data; LinkLinst *next; }; //头插法 void CreatListT(LinkLinst *&L,char a[],int n) { L=new LinkLinst; L->next=L; for(i
带环的链表
红豆和绿豆的博客
10-08 506
单链表的问题在面试考试等等等等中频频上镜，大有赶上凤姐超越芙蓉之势。假若有一个蛋疼的程序猿把单链表的末尾结点的next指针指向了单链表中一个随机的结点上，那么我们经常写的一个循环while(p)或者while(p->next)就可以父传子子传孙子子孙孙无穷尽了。     话说怎么判断单链表是否带环了呢？大部分人都知道了：让快指针追慢指针，追上了就有环，快指针走到头了，就无环。     那么又如
单循环链表C++实现
YYC的专栏
03-28 5880
#include using namespace std; struct SLNode //节点类 { int data; SLNode * next; }; struct SLList{//链表类型 SLNode * pb;//尾指针 size_t size;//元素个数 }; void InitList(SLList & list)//初始化一个空的单循环链表 { list.
线性表之链表之循环链表（C++/C）
JangKeo
10-12 131
线性表之链表之循环链表（C++/C） 1.循环单链表 #include<stdio.h> #include <stdlib.h> #define ElemType int typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; //初始化一个循环单链表 bool InitList(LinkList &L){ L=(LNode*)malloc(.
java数据结构-循环链表的设计与实现
最新发布
03-16
循环链表是一种特殊的链表，它的最后一个节点指向第一个节点，形成...总之，循环链表是一种非常有用的数据结构，可以在很多场景中使用。在Java中，我们可以通过定义Node类和头节点、尾节点来实现循环链表的设计与实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

赵健zj

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

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

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

打赏作者

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

抵扣说明：

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

余额充值