线性表的正向迭代器实现

最新推荐文章于 2022-11-24 01:43:35 发布
最新推荐文章于 2022-11-24 01:43:35 发布
阅读量615 收藏
点赞数

线性表包括 : 数组(动态数组类,静态数组类), 链表, 栈, 队列

以双向链表为例, 实现正向迭代器.


测试程序

// testcase.cpp : Defines the entry point for the console application.
//

#include <stdlib.h>
#include <stdio.h>

#include "LsDoublyLinkedList.h"

void fnTestDbList(); ///< 测试CLsLinkedList<T>双链表的所有接口

int main(int argc, char* argv[])
{
    fnTestDbList();
    return 0;
}

void fnTestDbList()
{
    int i = 0;
    int iTmp = 0;
    CLsLinkedList<int> list;
    CLsLinkedList<int>::iterator it = NULL;
    CLsLinkedList<int>::iterator itToDel = NULL;
    
    for (i = 1; i < 10; i++)
    {
        it = list.addTail(i);
        list.setAt(it, 100 + i);
        iTmp = list.getAt(it);   
        
        it = list.addHead(i + 200);
        list.setAt(it, 100 + i);
        iTmp = list.getAt(it);
        
        if (0 == (i % 2))
        {
            itToDel = it;
            list.insert(it, 300 + i);
        }
    }
    
    list.removeAt(itToDel);
    list.removeHead();
    list.removeTail();
    
    printf("[%d]\n", list.getLength());
    it = list.getHead();
    while (it != list.end())
    {
        printf("%d ", *it);
        it++;
    }
    
    printf("\r\n");
    it = list.getTail();
    while(it != list.end())
    {
        printf("%d ", *it);
        it++;
    }
    
    printf("\r\n");
 }

带正向迭代器的双向链表实现

// LsDoublyLinkedList.h: interface for the CLsLinkedList class.
//
//

#if !defined(LSDOUBLYLINKEDLIST_H_82FEA8FE_F7B8_4CD7_A162_751580726632)
#define LSDOUBLYLINKEDLIST_H_82FEA8FE_F7B8_4CD7_A162_751580726632

/**
链表总结
空间
    链式存储
时间复杂度
    尽量避免提供非常量阶的接口
    增加操作: O(1) 常量阶, 快
    删除操作: O(1) 常量阶, 快
    修改操作:O(1) 快(条件:知道位置, 用的是先前返回的位置类或结点指针)
    查询操作:O(n) 线性阶, 慢
    随机访问:O(n) 线性阶, 慢
使用场合
    * 问题规模不确定
    * 随机访问频率低
    * 数据更新频率高(主要指的是添加和删除操作)
缺点
    * 查询速度慢(数组和链表查询速度都慢)
原生new的时间复杂度
    new实现是线性阶.
    调用的memset是线性阶, 有循环操作.
    HeapAlloc中没源码, 但是有循环操作, 是线性阶.
    new不影响时间增长率.

结论
    当算法中, new次数较少时, 可以忽略new对算法时间复杂度的影响.
    当new次数较多时, 可以一次多new几个元素(e.g. 10个), 下次就不用new, 直接取已经new好的数据操作, 等用完了, 才再次new几个元素出来.
    这样对new操作做优化, 等于自己做堆管理, 需要再做一个链表, 将new出来的10个一组的小块内存空间管理起来, 当一个类指针不用了, 就称为闲置空间, 放在内存池中. 下次不用再申请了, 可以复用.
    等链表析构时, 链表的原生操作完成后, 再一块释放内存池.
*/

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

/// ----------------------------------------------------------------------
/// CLsLinkedList 双链表 定义
/// ----------------------------------------------------------------------
template <typename T>
class CLsLinkedList  
{
public:
    /// ----------------------------------------------------------------------
    /// CLsLinkedNode 定义
    /// ----------------------------------------------------------------------
    
    /// LsDoublyLinkedList's Node
    template <typename T>
        struct CLsLinkedNode
    {
        friend CLsLinkedList<T>; ///< 不需要前向声明, 用到的时候才检查
        friend CLsLinkedList<T>::iterator;

    private:
        CLsLinkedNode(T Elem)
            :m_Elem(Elem)
            ,m_pNext(NULL)
            ,m_pPrev(NULL)
        {
        }
        
        ~CLsLinkedNode()
        {
        }

        T m_Elem; //数据元素
        CLsLinkedNode<T>* m_pPrev; //前驱
        CLsLinkedNode<T>* m_pNext; //后继
    };

    /// ----------------------------------------------------------------------
    /// 正向迭代器 定义
    /// ----------------------------------------------------------------------
    class iterator
    {
        friend class CLsLinkedList<T>;
    public:
        iterator()
        {
            m_pNode = NULL;
        }

        iterator(CLsLinkedNode<T>* pNode)
        {
            m_pNode = pNode;
        }
        
        iterator operator++()
        {
            m_pNode = m_pNode->m_pNext;
            return m_pNode;
        }
        
        iterator operator++(int)
        {
            CLsLinkedNode<T> *pTemp = m_pNode;
            m_pNode = m_pNode->m_pNext;
            return pTemp;
        }

        iterator operator--()
        {
            m_pNode = m_pNode->m_pPrev;
            return m_pNode;
        }
        
        iterator operator--(int)
        {
            CLsLinkedNode<T> *pTemp = m_pNode;
            m_pNode = m_pNode->m_pPrev;
            return pTemp;
        }
        
        T& operator* ()
        {
            return m_pNode->m_Elem;
        }
        
        bool operator!= (const iterator& obj)
        {
            return m_pNode != obj.m_pNode;
        }

        bool operator== (const iterator& obj)
        {
            return m_pNode == obj.m_pNode;
        }

    private:
        CLsLinkedNode<T>* GetNode()
        {
            return m_pNode;
        }

    private:
        CLsLinkedNode<T>* m_pNode;
    };

public:
    iterator begin()
    {
        return m_pHead;
    }

    iterator end()
    {
        return NULL;
    }

public:
    CLsLinkedList();
    virtual ~CLsLinkedList();

    /// 只提供O(1)的接口^_^

    iterator getTail() const;
    iterator getHead() const;
    inline bool isEmpty() const;
    inline size_t getLength() const;  //表长
    void clear();

    iterator addTail(T newElem);
    bool removeTail();

    iterator addHead(T newElem);
    bool removeHead();

    T getAt(iterator it) const;
    void setAt(iterator it, T newElem);
    bool removeAt(iterator it);

    bool insert(iterator it, T newElem);

private:
    CLsLinkedNode<T>* m_pHead;  //头结点
    CLsLinkedNode<T>* m_pTail;  //尾结点
    size_t m_nLength;
};

/// ----------------------------------------------------------------------
/// CLsLinkedList 实现
/// ----------------------------------------------------------------------
template <typename T>
inline size_t CLsLinkedList<T>::getLength() const
{
    return m_nLength;
}

template <typename T>
inline bool  CLsLinkedList<T>::isEmpty() const
{
    return (NULL == m_pHead) ? true : false;
}

template <typename T>
CLsLinkedList<T>::CLsLinkedList()
:m_pHead(NULL)
,m_pTail(NULL)
,m_nLength(0)
{
}

template <typename T>
CLsLinkedList<T>::~CLsLinkedList()
{
    clear();
}

template <typename T>
void CLsLinkedList<T>::clear()
{
    while (!isEmpty())
    {
        removeTail();
    }
}

template <typename T>
T CLsLinkedList<T>::getAt(CLsLinkedList::iterator it) const
{
    return *it;
}

template <typename T>
void CLsLinkedList<T>::setAt(CLsLinkedList::iterator it, T newElem)
{
    *it = newElem;
}

template <typename T>
bool CLsLinkedList<T>::insert(CLsLinkedList::iterator it, T newElem)
{
    CLsLinkedNode<T>* pNewNode = NULL;
    CLsLinkedNode<T>* pPrev = NULL;
    CLsLinkedNode<T>* pNext = NULL;

    pPrev = it.GetNode();
    if (NULL == pPrev)
    {
        return false;
    }

    pNewNode = new CLsLinkedNode<T>(newElem);
    pNext = pPrev->m_pNext;
    
    /*
    1 2 3 [6] 4 5
    3.next = 6
    4.prev = 6
    6.prev = 3
    6.next = 4
    
      1 2 3 4 5 [6]
    */
    pPrev->m_pNext = pNewNode;
    if (NULL != pNext)
    {
        pNext->m_pPrev = pNewNode;
    }

    pNewNode->m_pPrev = pPrev;
    pNewNode->m_pNext = pNext;
    m_nLength++;
    return true;
}

template <typename T>
bool CLsLinkedList<T>::removeTail()
{
    bool bRc = false;
    CLsLinkedNode<T>* pPrev = NULL;

    if (NULL == m_pHead)
    {
        return false;
    }
    
    //1 2 [3]
    if (NULL != m_pTail)
    {
        pPrev = m_pTail->m_pPrev;
        if (NULL != pPrev)
        {
            pPrev->m_pNext = NULL;
        }
        else
        {
            m_pHead = NULL;
        }
        
        delete m_pTail;
        bRc = true;
        m_pTail = pPrev;
        m_nLength--;
    }

    return bRc;
}

template <typename T>
bool CLsLinkedList<T>::removeHead()
{
    if (NULL == m_pHead)
    {
        return false;
    }
    
    //[1] 2 3
    CLsLinkedNode<T>* pNext = m_pHead->m_pNext;
    if (NULL != pNext)
    {
        pNext->m_pPrev = NULL;
    }
    else
    {
        m_pTail = NULL;
    }
    
    delete m_pHead;
    m_nLength--;
    m_pHead = pNext;
    return true;
}

template <typename T>
bool CLsLinkedList<T>::removeAt(CLsLinkedList::iterator it)
{
    CLsLinkedNode<T>* pDelNode = it.GetNode();
    CLsLinkedNode<T>* pPrev = NULL;
    CLsLinkedNode<T>* pNext = NULL;

    if ((NULL == m_pHead) 
        || (NULL == pDelNode))
    {
        return false;
    }
    
    /*
    1 2 [3] 4 5 
    2.next = 4
    4.prev = 2
    
      [1] 2 3 4 5 
      
        1 2 3 4 [5]
        
          [1]
    */
    pPrev = pDelNode->m_pPrev;
    pNext = pDelNode->m_pNext;

    if (NULL != pPrev)
    {
        pPrev->m_pNext = pNext;
    }
    else
    {
        m_pHead = pNext;
    }
    
    if (NULL != pNext)
    {
        pNext->m_pPrev = pPrev;
    }
    else
    {
        m_pTail = pPrev;
    }
    
    delete pDelNode;
    m_nLength--;
    
    return true;
}

template <typename T>
CLsLinkedList<T>::iterator CLsLinkedList<T>::addTail(T newElem)
{
    CLsLinkedList<T>::CLsLinkedNode<T>* pNewNode = new CLsLinkedList<T>::CLsLinkedNode<T>(newElem);
    
    //空表
    if (NULL == m_pHead)
    {
        m_pHead = m_pTail = pNewNode;
    }
    else 
    {
        //1 2 3 4 5 [6]
        //5.next = 6    6.prev = 5  tail = 6
        m_pTail->m_pNext = pNewNode;
        pNewNode->m_pPrev = m_pTail;
        m_pTail = pNewNode;
    }

    m_nLength++;

    return pNewNode;
}

template <typename T>
CLsLinkedList<T>::iterator CLsLinkedList<T>::addHead(T newElem)
{
    CLsLinkedList<T>::CLsLinkedNode<T> *pNewNode = new CLsLinkedList<T>::CLsLinkedNode<T>(newElem);
    
    //空表
    if (NULL == m_pHead)
    {
        m_pHead = m_pTail = pNewNode;
    }
    else 
    {
        //[6] 1 2 3 4 5 
        //1.prev = 6    6.next = 1  head = 6
        m_pHead->m_pPrev = pNewNode;
        pNewNode->m_pNext = m_pHead;
        m_pHead = pNewNode;
    }

    m_nLength++;
    return pNewNode;
}

template <typename T>
CLsLinkedList<T>::iterator CLsLinkedList<T>::getTail() const
{
    return m_pTail;
}

template <typename T>
CLsLinkedList<T>::iterator CLsLinkedList<T>::getHead() const
{
    return m_pHead;
}

#endif // !defined(LSDOUBLYLINKEDLIST_H_82FEA8FE_F7B8_4CD7_A162_751580726632)





LostSpeed
关注
队列类模板【C++模板类应用之一】
席木木的博客
12-04 2455
队列类模板1 队列（Queue）特点2 队列中常用的操作3 队列类模板的设计与代码实现3.1 队列类模板的设计3.2 队列类模板的实现3.3 队列类模板的使用举例 1 队列（Queue）特点     队列（Queue）是一种先进先出的数据结构，例如：日常生活中在食堂排队打饭，每个后到的人都要排到队伍的最后边，而队伍最前面的人最先打到饭离开队伍。     因此，队列总是从队尾加入元素，而从队首移除元素，满足先进先出的规则。一般来说
C++ 容器 迭代器和算法
Chroniccandy的博客
12-05 768
容器 我们发觉编写的每个程序都或多或少的要存储一些数据,此前C++在这方面只提供了几种最基本的方法: 创建局部或全局变量来保存单个数据的值,以及使用数组来保存多个数据的值. 此篇文章引出的概念：能容纳两个或更多值的数据结构,我们通常称之为容器(container) 在C++标准库中有许多现成的容器,这个容器都经过不断的精心设计和测试封装,可以直接拿来使用,不过需要注意的是,找到最合适的容器只是编程工作的一部分,要实现程序的最优效率,还需一些适当的函数(算法)来处理这个容器内的数据. 数组作为容器的弊端：
队列的模板
qq_40921866的博客
12-27 163
#include<iostream> #include<stdio.h> #include<string.h> #include<algorithm> using namespace std; typedef struct Qnode{ int data; Qnode *next; }Qnode,*Que...
c++队列类模板的实现
CodingAdo
07-11 7168
//队列类模板定义 template class VarQueue { public: VarQueue() { m_MaxCount=MAX_POINTS; m_Count=0; } VarQueue(unsigned int MaxCount) { if(MaxCount>MAX_POINTS) m_MaxCount=MAX_POINTS; el
数组实现线性表带迭代器
antRain的博客
03-08 238
数组实现线性表带迭代器源代码输出 源代码 #include<bits/stdc++.h> using namespace std; /** * @brief 非法参数异常类 */ class illegalParameterValue { public: illegalParameterValue(string theMessage = "Illegal para...
C++类模板实现的队列
12-21
用C++类模板实现的队列，通过此例子可以清楚理解类模板的使用和数据结构中队列的实现
线性表？。。三个人一起打扑克牌？
weixin_45964036的博客
05-02 1906
文章目录List顺序表顺序表的定义和特点ArrayList的使用ArrayList的构造常见操作遍历扩容三人扑克牌游戏LinkedListLinkedList的使用LinkedList引入LinkedList构造LinkedList常用方法LinkedList遍历链表链表的概念及结构链表的实现ArrayList与LinkedList的区别 List 1、在Java中，List是一个接口 2、继承自Collection 3、从数据结构的角度看，List是一个线性表，即n个具有相同类型的元素的有限序列。 线性表
10【List、Set、Queue】
緑水長流*z
08-03 3847
一、List集合 1.1 List集合概述 List接口是单列集合的一个重要分支，下面主要有两个实现 ArrayList和LinkedList，List类型接口的特点是存储的元素是有序的，即存放进去是什么顺序，取出来还是什么顺序，也就是基于线性存储，可以看作是一个可变数组； List接口特点： List接口存储的数据是有序排列的，原来存储的时候是什么顺序，取出来就什么顺序（Set接口存储的是无序的）； List接口为存储的每一个元素都分配了一个索引，通过索引我们可以精确的来访
集合底层实现原理
ThreeAspects的博客
02-04 1267
ArrayList   ArrayList是List接口的可变数组非同步实现，并允许包括null在内的所有元素。底层使用数组实现。该集合是可变长度数组，数组扩容时，会将老数组中的元素重新拷贝一份到新的数组中，每次数组容量增长大约是其容量的1.5倍，这种操作的代价很高。若是能预估到顶峰容量，可以设置一个足够大的量以避免数组容量以后的扩展。   采用了Fail-Fast机制，面对并发的修改时，迭代器很...
数据结构(Java)——Day10(双向链表，栈)
最新发布
LengchenAl的博客
11-24 708
数据结构(Java)——Day10(双向链表，栈)
队列类模板
11-20
template<class T> class Queue { public: Queue(void); void QInsert(const T &item;); //新元素入队 T QDelete(void); //元素出队 void ClearQueue(void); //清空队列 T QFront(void)const; //访问队首元素 int QLength(void)const; int QEmpty(void)const; int QFull(void)const; private: int front, rear, count; //队头指针、队尾指针、元素个数 T qlist[MaxQSize]; //队列元素数组 };
队列模板类
03-14
队列模板类
模板类实现队列
qq_45651829的博客
09-29 512
#include<iostream> #include<cassert> using namespace std; template<class Type> class queue; // 提起声明 方便引入其作为友元函数 template<class T> class queueitem { // queue的节点定义 public: queueitem(const T& data) : item(data),next(0) { } frie
复习(数据结构：java)：线性表（数组）：迭代器
LandscapeMi
07-02 327
10. 迭代器 ArrayIntListIterator() * 迭代的基本方法 1. hasNext()hasNext() ：有更多可以访问的元素，返回true 2. next()next()：返回下一个元素 3. remove():remove(): 删除最近一次next（）方法返回的元素 1. 设计用例和接口 //输入{5，19，0，2，4，0，13，85，-8，0，
[数据结构]队列之顺序队列的类模板实现
借你一秒
06-23 1424
队列是一种限定存取位置的线性表，允许插入的一端叫做队尾（rear），允许删除的一端叫做队首（front）。 队列具有FIFO的性质 队列的存储表示也有两种方式：基于数组的，基于列表的。基于数组的叫做顺序队列，基于列表的叫做链式队列。 一下是基于动态数组的顺序队列的模板类的实现。 顺序队列的抽象基类如下所示：只提供了接口和显式的默认构造函数和析构函数，在派生类中调用。 #i
队列-模板
世上再无张显宗
04-01 437
题目： 请你实现一个队列。 操作： push x：将 x\x 加入队尾，保证 x\x 为 int 型整数。 pop：输出队首，并让队首出队 front：输出队首：队首不出队 输入描述: 第一行为一个正整数 n\ n ，代表操作次数。(1 \leq n \leq 100000)(1≤n≤100000) 接下来的 n\ n ，每行为一个字符串，代表一个操作。保证操作是题目描述中三种中的一种。 输出描述: 如果操作为push，则不输出任何东西。 如果为另外两种，若队列为空，则输出 "error“ 否则按对应操
队列模板
深海沧澜的博客
06-01 606
#include #include #include using namespace std; #define OVERFLOW 0 #define TRUE 1 #define FLASE 0 #define OK 1 #define ERROR 0 typedef int Status; typedef int QElemType; typedef struct QNode { Q
线性表与迭代器操作详解
"这篇PPT主要讲解了迭代器操作以及数据结构中的线性表概念，包括线性表的定义、基本操作、实现方式等。迭代器是访问数据结构中元素的一种方式，通常在C++中使用，允许程序员按顺序访问容器内的元素。迭代器提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值