怎么免费申请网站域名,114推广平台,wordpress amp 8211,建网站的支付安全CPrimer中文版#xff08;第五版#xff09;#xff1a; //运行时错误#xff1a;迭代器表示要拷贝的范围#xff0c;不能指向与目的位置相同的容器 slist.insert(slist.begin(),slist.begin(),slist.end()); 如果我们传递给insert一对迭代器#xff0c;它们不能… CPrimer中文版第五版 //运行时错误迭代器表示要拷贝的范围不能指向与目的位置相同的容器 slist.insert(slist.begin(),slist.begin(),slist.end()); 如果我们传递给insert一对迭代器它们不能指向添加元素的目标容器。 在新标准下接受元素个数范围的insert版本返回指向第一个新加入元素的迭代 器。在旧版本的标准库存中这些操作返回void。如果范围为空不插入任何元素insert
操作会将第一个参数返回。
例子1
int main() {liststring sl1 { 1,2,3 };_DListstring sl2 { 1,2,3 };vectorstring v { quasi, simba,frollo,scar };//将v的最后两个元素添加到list的开始位置sl1.insert(sl1.begin(), v.end() - 2, v.end());sl2.std_insert(sl2.begin(), v.end() - 2, v.end());_pn(sl1);_pn(sl2);cout ----------------------------------------------------------\n;//添加一列表sl1.insert(sl1.end(), { 4,5,6,7,中文,8,9 });sl2.std_insert(sl2.end(), { 4,5,6,7,中文,8,9 }); _pn(sl1);_pn(sl2);cout ----------------------------------------------------------\n;//复制自己(旧版会运行时错误迭代器表示要拷贝的范围不能指向与目的位置相同的容器sl1.insert(sl1.begin(), sl1.begin(), sl1.end());sl2.std_insert(sl2.begin(), sl2.begin(), sl2.end());_pn(sl1);_pn(sl2);}
结果 例子2 int main() {_DListstring lst1;liststring lst2;string word;auto iter1 lst1.begin();auto iter2 lst2.begin();while (cin word) {iter1 lst1.std_insert(iter1, word); //等价于调用push_front_pn(lst1);iter2 lst2.insert(iter2, word); //等价于调用push_front_pn(lst2);}
}
结果 _DList中的实现
主要函数 /// summary/// 在_Where位置前插入[itBegin,itEnd)用法与std::list::insert要一样/// 注意std旧重版itBegin和itEnd不能指向与目的位置相同的容器,在新标准版可以。/// /summary/// typeparam nameIteratorClass/typeparam/// param name_Where/param/// param nameitBegin/param/// param nameitEnd/param/// 创建时间 2024-09-22 最后一次修改时间2024-09-22 (已测试templateclass IteratorClassinline _DListNodeIteratorT std_insert(const _DListNodeIteratorT _Where, const IteratorClass itBegin,const IteratorClass itEnd) {/*list slist; //运行时错误迭代器表示要拷贝的范围不能指向与目的位置相同的容器slist.insert(slist.begin(),slist.begin(),slist.end());*/if (typeid(_DListNodeIteratorT) typeid(IteratorClass)) {_DListNodeIteratorT* pbegin (_DListNodeIteratorT*)(itBegin);_DListNodeIteratorT* pend (_DListNodeIteratorT*)(itEnd);//lassert(_Where._pCurrentList ! p-_pCurrentList,不能插入指向相同容器的元素);if (_Where._pCurrentList pbegin-_pCurrentList) {//创建一个临时链表,会影响性能_DListT tmp(*pbegin,*pend);return std_insert(_Where, tmp.begin(), tmp.end());} } IteratorClass tmp itBegin;_DListNodeT* pReulst null;if (_Where._Ptr null) {while (tmp ! itEnd) {if (pReulst null) {//保存第一次插入的结点以便返回pReulst this-inseart_back(_Last, *tmp);}elsethis-inseart_back(_Last, *tmp);tmp;}}else {auto ptr _Where._Ptr;while (tmp ! itEnd) {if (pReulst null) //第一次在前面插入第一项{ptr this-inseart_front(ptr, *tmp);//保存第一次插入的结点以便返回pReulst ptr;}else { //第二次开始在插入的第一项后面依次插入ptr this-inseart_back(ptr, *tmp);}tmp;}}return _DListNodeIteratorT(pReulst, this);} _DList类有修改
/*******************************************************************************************
文件名 _List.h作者 李锋功能 链表手机 13828778863Email : ruizhilf139.com创建时间 2016年07月31日最后一次修改时间 : 2024年07月30日/// 链表是一种用来存储数据集合的数据结构。链表具有如下属性
///1元素通过指针依次相连
///2最后一个元素的指针为空null。
///3在程序的执行过程中链表的长度可以自由伸缩。
///4链表的长度可以要求的任意长度除非系统内存耗尽。
///5它不会浪费内存空间但会需要额外的内存空间存储指针。记住 Virtual C Bug: 模板继承用到父类成员访问时要用 this-********************************************************************************************/
#ifndef __LIST_H_
#define __LIST_H_#include _Macro.h
#include _Memory.h
#include _ByteArray.h
#include _Pair.h
#include _IteratorBase.h_LF_BEGIN_templateclass T class _DList; //前置声明/// summary
/// 排序顺序
/// /summary
enum class _SortOrder
{s_Minmax 0, //从小到大 s_Maxmin 1, //从大到小s_null 2 //无排序顺序
};/// summary
/// 单链表节点
/// /summary
/// typeparam nameT/typeparam
/// 创建时间 2021年10月23日 最后一次修改时间 : 2021年10月23日
templateclass T
class _SListNode
{public:/// summary/// 节点数据/// /summaryT Data;/// summary/// 下一个节点/// /summary_SListNodeT* Next;/// summary/// 构造函数/// /summary/// param nameaData/param_SListNode(T aData){Data aData;}};/// summary
/// C#语句public class _DListNodeT
/// /summary
/// typeparam nameT默认数据/typeparam
templateclass T
class _DListNode
{
public:/// summary/// 节点数据/// /summaryT Data;/// summary/// 前一个节点/// /summary_DListNodeT* Prev;/// summary/// 下一个节点/// /summary_DListNodeT* Next;/// summary/// 构造函数/// /summary/// param nameaData默认数据/param_DListNode(const T aData){Data aData;Prev null;Next null;}_DListNode(){Prev null;Next null;Data T();}
};/// summary
/// 单链表
/// 通常我们说的链表指的是单链表singly linked list。单链表包括一组结点每个结
/// 点有一个 next 指针域用来存储指向逻辑上下一个元素对应结点的指针。最后一个结点的
/// next指针域的值为null这预示着已经到达链表的尾部。
///
/// /summary
/// typeparam nameT/typeparam
templateclass T
class _SList : public _Object
{
private:/// summary/// 第一个结点/// /summary_SListNodeT* _First;/// summary/// 结点数/// /summaryint _Count;public:inline const int Count() { return _Count; }inline const _SListNodeT* First() { return _First; }};//------------------------------------------LDIterator
//参考网址 https://blog.csdn.net/qq_28398301/article/details/106321525 C用for遍历自定义类/// summary
///
/// /summary
/// typeparam nameT/typeparam
templateclass T
class _DListNodeIterator
{
public:using value_type T;
public:/// summary/// 当前节点/// /summary_DListNodeT* _Ptr; //命名与标库相同 _pCurrentNode;/// summary/// 当前链表/// /summaryconst _DListT* _pCurrentList;inline _DListNodeIterator(){ _pCurrentList null;_Ptr null;}inline _DListNodeIterator(const _DListT* pCurrentList){assert(pCurrentList ! null);_pCurrentList (_DListT*)pCurrentList;_Ptr null;}/// summary/// 构造函数传值迭代器管理的值/// /summary/// param namepNode/paraminline _DListNodeIterator(const _DListNodeT* pCurrentNode, const _DListT* pCurrentList){_Ptr (_DListNodeT*)pCurrentNode;_pCurrentList (_DListT*)pCurrentList;}inline _DListNodeIterator(const _DListNodeIterator it) {_Ptr it._Ptr;_pCurrentList it._pCurrentList;}/*/// summary/// 比较实现/// /summary/// param namethat/param/// returns/returnsbool operator ! (const _DListNodeIterator that) { return _pNode ! that._pNode; }bool operator (const _DListNodeIterator right) { return _pNode-Data right._pNode-Data; }bool operator (const _DListNodeIterator right) { return _pNode-Data right._pNode-Data; }/// summary/// 自增实现/// /summary/// returns/returnsinline _DListNodeIterator operator () { _pNode _pNode-Next; return *this; }/// summary/// lf::_DListint d { 1,3,5,8,2 };/// auto it1 d.begin(); /// cout *it1 \n; // 输出1/// cout *(it1 2) \n; // 输出5/// /summary/// param namenDiff/param/// returns/returns/// 创建时间 2024-07-01 最后一修改时间2024-07-01inline _DListNodeIterator operator(const size_t nDiff) {_DListNodeIterator result(_pNode); for (int n 0; n nDiff; n){result._pNode result._pNode-Next;}return result;}/// summary/// 解引用取值/// /summary/// typeparam nameT/typeparamT operator * () { return _pNode-Data; }//LDIterator(const LDIterator) delete;//LDIterator operator(const LDIterator) delete;//~LDIterator() default;*/public: //----------------------------重写 /// summary/// 解引用取值/// /summary/// typeparam nameT/typeparam/// 创建时间2024-07-02 最后一次修改时间2024-07-03inline T operator * () const { return _Ptr-Data; }/// summary/// 向前移动为正向后移动为负/// /summary/// param nameiDiff/param/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline virtual void Move(const int iDiff) {if (iDiff 0) return;if (iDiff 0){if (_Ptr null) //已经是最后了不能向后移了{ return;}int n 0;while (true){_Ptr _Ptr-Next;n;if (n iDiff){ return; }}}else{int n 0;if (_Ptr null) {//向前移减-1进入未尾元素_Ptr _pCurrentList-Last();n -1; //已经向前移了一位if (n iDiff) { return; }}while (true){_Ptr _Ptr-Prev;--n;if (n iDiff){ return; }}}throw 未重写代码;}/// summary/// /// /summary/// param nameright/param/// returns/returns/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline _DListNodeIterator operator(const int iDiff)const {_DListNodeIterator itResult(*this);itResult.Move(iDiff);return itResult;}/// summary/// /// /summary/// param nameright/param/// returns/returns/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline _DListNodeIterator operator-(const int iDiff)const {_DListNodeIterator itResult(*this);itResult.Move(-iDiff);return itResult;}/// summary/// /// /summary/// param namer/param/// returns/returns/// 创建时间2024-07-03 最后一次修改时间2024-07-25inline int operator-(const _DListNodeIterator r)const {int n1 _pCurrentList-FindNodeIndex(_Ptr);int n2 _pCurrentList-FindNodeIndex(r._Ptr);//assert(n1 ! -1 n2 ! -1);//确保 _pCurrentList-end() - _pCurrentList-begin() _pCurrentList-Count//超过边界指针都设为指向最后一位元素的下一位if (n1 -1) n1 _pCurrentList-Count;if (n2 -1) n2 _pCurrentList-Count;return n1 - n2; }/// summary/// 前置加加/// /summary/// returns/returns/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline _DListNodeIterator operator() { Move(1); return *this; }/// summary/// 前置减减/// /summary/// returns/returns/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline _DListNodeIterator operator--() { Move(-1); return *this; }/// summary/// 后置加加/// /summary/// param name/param/// returns/returns/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline _DListNodeIterator operator(int) {_DListNodeIterator sResult(*this);Move(1);return sResult;}/// summary/// 后置减减/// /summary/// param name/param/// returns/returns/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline _DListNodeIterator operator--(int) {_DListNodeIterator sResult(*this);Move(-1);return sResult;}/// summary/// /// /summary/// param namer/param/// returns/returns/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline _DListNodeIterator operator(const int iDiff) {Move(iDiff);return *this;}/// summary/// /// /summary/// param namer/param/// returns/returns/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline _DListNodeIterator operator-(const int iDiff) {Move(iDiff);return *this;}/// summary/// 关联代码/// _DListint d { 1,3,53,55,35,97,35,10 };/// d.end() - d.begin(); //8/// /summary/// param namer/param/// returns/returns/// 创建时间2024-07-03 最后一次修改时间2024-07-03inline int operator-(const _DListNodeIterator r){//note1 到最未尾的索引//note2 到最未尾的索引int i1 0, i2 0;auto pNode1 _Ptr;auto pNode2 r._Ptr;//pNote1到结点未尾的距离while (pNode1 ! null){pNode1 pNode1-Next;i1;}//pNote2到结点未尾的距离while (pNode2 ! null){pNode2 pNode2-Next;i2;}// - (i1-i2) 值越小离结点未越近例如 null 结点就是 0。return i2 - i1;}//-------------------------------如果是非线性表下面的运算符重载也要重写inline bool operator!(const _DListNodeIterator r) { return this-_Ptr ! r._Ptr; }inline bool operator(const _DListNodeIterator r) { return this-_Ptr r._Ptr; }inline bool operator(const _DListNodeIterator r) { return this-_Ptr r._Ptr; }inline bool operator(const _DListNodeIterator r) { return this-_Ptr r._Ptr; }
};/// summary
///
/// /summary
/// typeparam nameT/typeparam
/// 创建时间 2024-07-03 最后一修改时间2024-07-03
templateclass T
class _DListNodeReverseIterator
{
public:using value_type T;private:/// summary/// 当前节点/// /summary_DListNodeT* _pCurrentNode;/// summary/// 当前链表/// /summary_DListT* _pCurrentList;
public:inline _DListNodeReverseIterator(){_pCurrentList null;_pCurrentNode null;}inline _DListNodeReverseIterator(const _DListT* pCurrentList){assert(pCurrentList ! null);_pCurrentList (_DListT*)pCurrentList;_pCurrentNode null; }/// summary/// 构造函数传值迭代器管理的值/// /summary/// param namepNode/paraminline _DListNodeReverseIterator(const _DListNodeT* pCurrentNode, const _DListT* pCurrentList){_pCurrentNode (_DListNodeT*)pCurrentNode;_pCurrentList (_DListT*)pCurrentList;}inline _DListNodeReverseIterator(const _DListNodeReverseIterator it){_pCurrentNode it._pCurrentNode;_pCurrentList it._pCurrentList;}/// summary/// 解引用取值/// /summary/// typeparam nameT/typeparam/// 创建时间2024-07-02 最后一次修改时间2024-07-03inline T operator * ()const { return _pCurrentNode-Data; }/// summary/// 前置加加/// /summary/// returns/returns/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline _DListNodeReverseIterator operator() { Move(1); return *this; }/// summary/// 前置减减/// /summary/// returns/returns/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline _DListNodeReverseIterator operator--() { Move(-1); return *this; }/// summary/// 后置加加/// /summary/// param name/param/// returns/returns/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline _DListNodeReverseIterator operator(int) {_DListNodeIterator sResult(*this);Move(1);return sResult;}/// summary/// 后置减减/// /summary/// param name/param/// returns/returns/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline _DListNodeReverseIterator operator--(int) {_DListNodeIterator sResult(*this);Move(-1);return sResult;}/// summary/// 向后移动为正向前移动为负/// /summary/// param nameiDiff/param/// 创建时间2024-07-02 最后一次修改时间2024-07-02inline void Move(const int iDiff) {assert(_pCurrentList ! null);if (iDiff 0) return;if (iDiff 0) { //向后移动int n 0;if (_pCurrentNode null) { //不能向前移动_pCurrentNode _pCurrentList-Last();n 1; //已经向后移动了一位 if (n iDiff) { return; }}while (true) {_pCurrentNode _pCurrentNode-Prev;n;if (n iDiff) { return; }}}else {if (_pCurrentNode null) { //不能向后移动return;}int n 0;while (true) {_pCurrentNode _pCurrentNode-Next;--n;if (n iDiff) { return;}}}throw 未重写代码;}inline bool operator!(const _DListNodeReverseIterator r) { return this-_pCurrentNode ! r._pCurrentNode; }inline bool operator(const _DListNodeReverseIterator r) { return this-_pCurrentNode r._pCurrentNode; }inline bool operator(const _DListNodeReverseIterator r) { return this-_pCurrentNode r._pCurrentNode; }inline bool operator(const _DListNodeReverseIterator r) { return this-_pCurrentNode r._pCurrentNode; }
};/// summary
/// 双向链表, 数据 T 要求能够比较大小否则编译会出错。
/// /summary
/// typeparam nameT/typeparam
templateclass T
class _DList : public _Object
{
public:using value_type T;using iterator _DListNodeIteratorT;static const size_t npos -1; //不可能的索引
protected:_DListNodeT* _First; //第一个节点_DListNodeT* _Last; //最后一个节点size_t _Count; //节点个数size_t _MaxBuffer; //双链表最大可以存储的元素个数_SortOrder _so; //排序顺序
protected:/// summary/// 初台化数据/// /summary/// returns/returnsinline void InitData() {_Count 0; _First null; _Last null; _MaxBuffer 100000;_so _SortOrder::s_null;}public: //---------------------------------------------------------------------------属性__declspec(property(get GetSortOrder, put SetSortOrder) ) _SortOrder SortOrder;const _SortOrder GetSortOrder() const { return _so; }virtual void SetSortOrder(const _SortOrder so) { _so so; }__declspec(property(get GetCount)) const int Count;/// summary/// 为了兼容标准库。/// 例T vector, string, _DList..../// size_t nSize T.size();/// auto itBegin T.begin();/// /summary/// returns/returns/// 创建时间 2024-07-30 最后一修改时间2024-07-30int size()const { return _Count; }inline int GetCount() const { return _Count; }public://------------------------------------------------------------构造与析构/// summary/// 默认构造函数/// /summary/// returns/returnsinline _DList(){InitData();}/// summary/// 拷贝[itBegin,itEnd)/// /summary/// param nameitBegin/param/// param nameitEnd/param/// 创建时间 2024-09-23 最后一修改时间2024-09-23inline _DList(const _DListNodeIteratorT itBegin, const _DListNodeIteratorT itEnd) {InitData();_DListNodeIteratorT it itBegin;while (it ! itEnd) { Add(*it);it;}}inline _DList(const _DList dl){//_cout _t(inline _DListT::_DList(const _DList dl)\n);InitData();_DListNodeT* dn dl.First();while (dn ! null){Add(dn-Data);dn dn-Next;}}inline _DList(const std::vectorT v) {InitData();for (const T t : v){Add(t);}}inline _DList(const T item) {InitData();Add(item);}/// summary/// 列表初始化 dListint idl {1,2,3,4};/// /summary/// typeparam nameT/typeparam/// param nametList/paraminline _DList(std::initializer_listT tList){InitData();for (T t : tList) { Add(t); }}/// summary/// 析构函数/// /summaryinline virtual ~_DList(){//_cout _t(inline _DListT::~_DList()\n);ClearData();}//------------------------------------------------------------属性/// summary/// 双链表最大可以存储的元素个数/// /summaryint MaxBuffer()const { return _MaxBuffer; }/// summary///设定双链表最大可以存储的元素个数/// /summary/// param namenCaptionty/paraminline void MaxBuffer(const size_t nCaptionty) { _MaxBuffer nCaptionty; }inline size_t csharp_Count() const { return _Count; }inline _DListNodeT* First()const { return _First; }inline _DListNodeT* Last()const { return _Last; }inline _DListNodeIteratorT begin()const { return _DListNodeIteratorT(_First,this); }inline _DListNodeReverseIteratorT rbegin()const { return _DListNodeReverseIteratorT(_Last,this); }/// summary/// /// /summary/// returns/returnsinline _DListNodeIteratorT end()const{//迭代器使用的语句//for (_DListNodeIteratorint f dl.begin(); f ! dl.end(); f) { }return _DListNodeIteratorT(null,this);}/// summary/// /// /summary/// returns/returnsinline _DListNodeReverseIteratorT rend()const{//迭代器使用的语句//for (_DListNodeIteratorint f dl.begin(); f ! dl.end(); f) { }return _DListNodeReverseIteratorT(null, this);}//-----------------------------------------------------------运算符重载/// summary/// 重载的下标操作符 []/// /summaryT operator[](const size_t nIndex) const { return IndexOfNode(nIndex)-Data; }/// summary/// 重载的下标操作符 /// /summary/// 创建时间 ????-??-?? 最后一次修改时间2024-04-19 inline _DListT operator (const _DListT other){if (this ! other){ClearData();Add(other); }return *this;}/// summary/// 类型转换/// /summaryinline operator _string() const{ return ToString(); }/// summary/// 类型转换/// /summaryinline operator _stdstr() const { return ToString().Data; }//---------------------------------------------------------虚函数重写/// summary/// 是否存在 item/// /summaryinline virtual bool Contains(const T item){ return BinarySearch(item) ! -1; }/// summary/// 交换两个节点的数据/// /summary/// typeparam nameT/typeparam/// param nameiIndex1/param/// param nameiIndex2/param/// returns/returns/// 创建时间 ???-??-?? 最后一次修改时间2024-09-20 (改用_Math::swap) inline bool SwapNodeData(const int iIndex1, const int iIndex2){_DListNodeT* pNode1, * pNode2;pNode1 IndexOfNode(iIndex1);pNode2 IndexOfNode(iIndex2);if (!(pNode1 ! null pNode2 ! null)){return false;}/*T ptmp pNode1-Data;pNode1-Data pNode2-Data;pNode2-Data ptmp;*/_Math::swap(pNode1-Data, pNode2-Data);return true;}/// summary/// 选择排序Selection sort是一种简单直观的排序算法。它的工作原理是第一次从待排序的数据元素中选出最小/// 或最大的一个元素存放在序列的起始位置然后再从剩余的未排序元素中寻找到最小大元素然后放到已排序/// 的序列的末尾。以此类推直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。/// /summary/// typeparam nameT/typeparam/// param namesortord/param/// 创建时间 ???-??-?? 最后一次修改时间2024-09-20 (改用_Math::swap) 已测试inline virtual void Sort_Selection(const _SortOrder sortord _SortOrder::s_Minmax){if (_Count 0 || _Count 1) return;_DListNodeT* min _First, * tmp _First-Next;if (sortord _SortOrder::s_Minmax) //从小到大{while (min-Next ! null){while (tmp ! null){if (tmp-Data min-Data) //交换数据{/*T pt tmp-Data;tmp-Data min-Data;min-Data pt;*/_Math::swap(tmp-Data, min-Data);}tmp tmp-Next;}min min-Next;tmp min-Next;}}else{while (min-Next ! null){while (tmp ! null){if (tmp-Data min-Data){/*T pt tmp-Data;tmp-Data min-Data;min-Data pt;*/_Math::swap(tmp-Data, min-Data);}tmp tmp-Next;}min min-Next;tmp min-Next;}}this-_so sortord; //已排序}/// summary/// 返回索引的节点/// /summaryinline virtual _DListNodeT* IndexOfNode(const size_t nPos)const{if (nPos _Count) //错误索引:{return NULL;}size_t nindex 0;if (nPos _Count / 2){_DListNodeT* pNode _Last;while (pNode ! null){if (nindex _Count - nPos - 1) { return pNode; }pNode pNode-Prev;}}else{_DListNodeT* pNode _First;while (pNode ! null){if (nindex nPos){return pNode;}pNode pNode-Next;}}return null;}/// summary/// 把节点移到最后/// /summary/// param namednCurrent/param/// returns/returns/// 创建时间 2022-02-18 最后一次修改时间2024-09-23inline virtual _DListNodeT* MoveLast(_DListNodeT* pNode){if (pNode ! null) {if (pNode _Last) {//ok}else if (pNode _First) { //此时最少两个节点_First _First-Next;_First-Prev null;_Last-Next pNode;pNode-Prev _Last;_Last pNode;this-_so _SortOrder::s_null;}else {pNode-Prev-Next pNode-Next;pNode-Next-Prev pNode-Prev;_Last-Next pNode;pNode-Prev _Last;_Last pNode;this-_so _SortOrder::s_null;}}return pNode; }/// summary/// 把索引为nIndex的节点移到最后并返回这个节点。/// /summary/// typeparam nameT/typeparam/// param nameiIndex/param/// returns/returns/// 创建时间 ???-??-?? 最后一次修改时间2024-09-22 inline virtual _DListNodeT* MoveLast(const size_t nIndex){return MoveLast(IndexOfNode(nIndex));}/// summary/// 把索引为nIndex的节点移到最前/// /summary/// param nameiIndex/paraminline virtual bool MoveFirst(const size_t nIndex){_DListNodeT* pNode IndexOfNode(nIndex);if (pNode ! null){if (pNode _First)return true;if (pNode _Last) //此时最少两个节点{_Last-Prev-Next null;_Last _Last-Prev;pNode-Prev null;pNode-Next _First;_First-Prev pNode;_First pNode;}else{pNode-Prev-Next pNode-Next;pNode-Next-Prev pNode-Prev;pNode-Next _First;_First-Prev pNode;pNode-Prev null;_First pNode;}return true;}return false;}/// summary/// 将指定集合的元素添加到末尾/// /summary/// typeparam nameT/typeparam/// param nameitem/param/// returns/returns/// 创建时间 ????-??-?? 最后一次修改时间2024-09-22inline virtual _DListNodeT* Add(const T tValue){_DListNodeT* pResult;if (_Count 0){//_First new _DListNodeT(item);pResult _Memory::New _DListNodeT (1);_First pResult;_First-Data tValue;_First-Next null;_First-Prev null;_Last _First;}else{pResult _Memory::New _DListNodeT (1);pResult-Data tValue;pResult-Next null;pResult-Prev _Last;_Last-Next pResult;_Last pResult;}_Count;this-_so _SortOrder::s_null; //要重新排序return pResult;}/// summary/// 添加一个链表/// /summary/// 创建时间 ????-??-?? 最后一次修改时间2024-09-22inline _DListNodeT* Add(const _DListT dList){_DListNodeT* pResult null;_DListNodeT* pNode dList._First;while (pNode ! null){if (pResult null) pResult Add(pNode-Data);elseAdd(pNode-Data);pNode pNode-Next;}return pResult;}
protected:/// summary/// 在结点pItemNode后面插入一个结点,成功返回新的结点否则返回NUll/// 如果pItemNote null则默认在后面添加一个项。/// /summary/// typeparam nameT/typeparam/// param namepItemNode当前结点/param/// param namerValue/param/// returns/returns/// 创建时间 ????-??-?? 最后一次修改时间2024-09-22inline virtual _DListNodeT* InserNodeBack(_DListNodeT* pNoteItem, const T tValue){if (pNoteItem null || _Count 0) return this-Add(tValue);this-SortOrder _SortOrder::s_null;_DListNodeT* pNode _Memory::New_DListNodeT(1);pNode-Data tValue;//pNodepNode-Prev pNoteItem;pNode-Next pNoteItem-Next;//pListItem-Nextif (pNoteItem-Next ! null) {pNoteItem-Next-Prev pNode;}else{_Last pNode;}//--pNoteItempNoteItem-Next pNode;_Count;return pNode;}/// summary/// 在结点pNoteItem前面插入一个结点,成功返回新的结点否则返回null/// 如果pItemNote null则默认在后面添加一个项。/// /summary/// typeparam nameT/typeparam/// param namepListItem/param/// param namerData/param/// returns/returns/// 创建时间 ????-??-?? 最后一次修改时间2024-09-22inline virtual _DListNodeT* InserNodeFront(_DListNodeT* pNoteItem, const T tValue){if (pNoteItem null || _Count 0) return this-Add(tValue);this-SortOrder _SortOrder::s_null;if (pNoteItem null) return null;_DListNodeT* pNode _Memory::New_DListNodeT(1);pNode-Data tValue;//pNode pNode-Next pNoteItem;pNode-Prev pNoteItem-Prev;//--pListItem-Previf (pNoteItem-Prev ! null){pNoteItem-Prev-Next pNode;}else{_First pNode;}//pNoteItempNoteItem-Prev pNode;_Count;return pNode;}//------------------------------------------------------------操作
public:/// summary/// 如果已排好序它会按二分法查找否则它会普通查找。/// /summary/// param nameitem/param/// returns/returns/// 创建时间 ????-??-?? 最后一次修改时间????_??_?? 已测试inline int BinarySearch(const T item)const {switch (this-_so){case _SortOrder::s_Maxmin:{if (_Count 0){return -1;}if (_Count 1){//return (_First.Data as IComparable).CompareTo(item) 0 ? 0 : -1; //C#return _First-Data item ? 0 : -1;}if (_Count 2){//if ((_First.Data as IComparable).CompareTo(item) 0) return 0;//if ((_First.Next.Data as IComparable).CompareTo(item) 0) return 1;if (_First-Data item) return 0;if (_First-Next-Data item) return 1;return -1;}int nPos (int)_Count / 2; //nPos在中间所以无素一定要大于等于3才行int nLeft 0; //左边远素int nRight (int)_Count - 1; //右边远素_DListNodeT* pNode;while (nRight 0 nLeft 0){pNode IndexOfNode(nPos);//int iCom (item as IComparable).CompareTo(ld.Data);if (item pNode-Data){if (nRight nLeft || nPos nLeft){return -1;}nRight nPos - 1;}else if (item pNode-Data){if (nRight nLeft || nPos nRight){return -1;}nLeft nPos 1;}else{return nPos;}nPos nLeft (nRight - nLeft 1) / 2;}break;}case _SortOrder::s_Minmax:{if (_Count 0){return -1;}if (_Count 1){//return (_First.Data as IComparable).CompareTo(item) 0 ? 0 : -1;return _First-Data item ? 0 : -1;}if (_Count 2){//if ((_First.Data as IComparable).CompareTo(item) 0) return 0;//if ((_First.Next.Data as IComparable).CompareTo(item) 0) return 1;if (_First-Data item) return 0;if (_First-Next-Data item) return 1;return -1;}int nPos (int)_Count / 2; //nPos在中间所以无素一定要大于等于3才行int nLeft 0; //左边远素int nRight (int)_Count - 1; //右边远素_DListNodeT* pNode null;while (nRight 0 nLeft 0){pNode IndexOfNode(nPos);//int iCom (item as IComparable).CompareTo(ld.Data);if (item pNode-Data){if (nRight nLeft || nPos nLeft){return -1;}nRight nPos - 1;}else if (item pNode-Data){if (nRight nLeft || nPos nRight){return -1;}nLeft nPos 1;}else{return nPos;}nPos nLeft (nRight - nLeft 1) / 2;}break;}case _SortOrder::s_null:{_DListNodeT* pNode _First;int iCount 0;while (pNode ! null){if (pNode-Data item){return iCount;}pNode pNode-Next;iCount;}break;}default:{return -1;}}return -1;}/// summary/// 清除节点并释放内存/// /summary/// typeparam nameT/typeparam/// 创建时间 ????-??-?? 最后一次修改时间2022-12-24 (已测试inline void ClearData() override { ClearMemory(); }/// summary/// 清除节点并释放内存/// /summaryinline void ClearMemory() override{_Count 0;_DListNodeT* dn _First;while (dn ! null){if (dn-Prev ! null)_Memory::Delete _DListNodeT (dn-Prev, 1);dn dn-Next;}if (_Last ! null)_Memory::Delete _DListNodeT (_Last, 1);_First null;_Last null;this-_so _SortOrder::s_null;}/// summary/// 复制一个链表清除原来链表的数据/// /summary/// typeparam nameT/typeparam/// param nameld/paraminline void CopyFrom(const _DListT ld){if (this ! ld){ClearData();_DListNodeT* pNode ld._First;while (pNode ! null){Add(pNode-Data);pNode pNode-Next;}}}/// summary/// 移除指定索引处的元素/// /summary/// typeparam nameT类型/typeparam/// param nameiIndex要移除的元素的从零开始的索引。/param/// returns成功返回true,否则返回false/returns/// 创建时间????-??-?? 最后一次修改时间2023-04-08inline bool RemoveAt(const size_t nIndex){if (nIndex _Count) return false;_DListNodeT* pNode _First;size_t nCount 0;while (pNode ! null){if (nCount nIndex){if (pNode _First){if (_First-Next null) //只有一个{ClearData();return true;}else{_First _First-Next;_First-Prev null;--_Count;_Memory::Delete _DListNodeT (pNode, 1);return true;}}else if (pNode _Last){if (_Last-Prev null){ClearData();return true;}else{ _Last _Last-Prev;_Last-Next null;--_Count;_Memory::Delete _DListNodeT(pNode, 1);return true;}}else{pNode-Prev-Next pNode-Next;pNode-Next-Prev pNode-Prev;--_Count;_Memory::Delete _DListNodeT(pNode, 1);return true;}}pNode pNode-Next;nCount;}return false;}/// summary/// 在节点中查找一项数据这项数据值与tData相同/// /summary/// param nametData/param/// returns/returns/// 创建时间????-??-?? 最后一次修改时间2024-09-20inline _DListNodeT* FindNodeItem(const T tValue)const{switch (this-_so){case _SortOrder::s_Maxmin:{if (_Count 0){return null;}if (_Count 1){//return (_First.Data as IComparable).CompareTo(tValue) 0 ? _First : null;return _First-Data tValue ? _First : null;}if (_Count 2){//if ((_First.Data as IComparable).CompareTo(tValue) 0) return _First;//if ((_First.Next.Data as IComparable).CompareTo(tValue) 0) return _First.Next;if (_First-Data tValue) return _First;if (_First-Next-Data tValue) return _First-Next;return null;}int nPos (int)(_Count / 2); //nPos在中间所以无素一定要大于等于3才行int nLeft 0; //左边远素int nRight (int)(_Count - 1); //右边远素_DListNodeT* pNode null;while (nRight 0 nLeft 0){pNode IndexOfNode(nPos);//int iCom (tValue as IComparable).CompareTo(ld.Data);if (tValue pNode-Data){if (nRight nLeft || nPos nLeft){return null;}nRight nPos - 1;}else if (tValue pNode-Data){if (nRight nLeft || nPos nRight){return null;}nLeft nPos 1;}else{return pNode;}nPos nLeft (nRight - nLeft 1) / 2;}break;}case _SortOrder::s_Minmax:{if (_Count 0){return null;}if (_Count 1){//return (_First.Data as IComparable).CompareTo(tValue) 0 ? _First : null;return _First-Data tValue ? _First : null;}if (_Count 2){//if ((_First.Data as IComparable).CompareTo(tValue) 0) return _First;//if ((_First.Next.Data as IComparable).CompareTo(tValue) 0) return _First.Next;if (_First-Data tValue) return _First;if (_First-Next-Data tValue) return _First-Next;return null;}int nPos (int)(_Count / 2); //nPos在中间所以无素一定要大于等于3才行int nLeft 0; //左边远素int nRight (int)(_Count - 1); //右边远素_DListNodeT* pNode null;while (nRight 0 nLeft 0){pNode IndexOfNode(nPos);//int iCom (tValue as IComparable).CompareTo(ld.Data);if (tValue pNode-Data){if (nRight nLeft || nPos nLeft){return null;}nRight nPos - 1;}else if (tValue pNode-Data){if (nRight nLeft || nPos nRight){return null;}nLeft nPos 1;}else{return pNode;}nPos nLeft (nRight - nLeft 1) / 2;}break;}case _SortOrder::s_null:{_DListNodeT* pNode _First;while (pNode ! null){//总结:Equals比较的永远是变量的内容是否相同而 比较的则是引用地址是否相同(前提:此种类型内部没有对Equals 或 进行重写操作//否则输出可能会有不同)。string 类型是个特例因为他的内部对这两个都进行了重写。if (tValue pNode-Data){return pNode;}/*if (pNode.Data.Equals(tValue)){return pNode;}*/pNode pNode-Next;}break;}default:{return null;}}return null;}inline _DListNodeT* Find(const T tValue)const { return FindNodeItem(tValue); }/// summary/// 在链接中查找节点返回节点的索引/// /summary/// param namepFind/param/// returns/returns/// 创建时间2024-07-03 最后一次修改时间2024-07-03inline int FindNodeIndex(const _DListNodeT* pFind)const{if (pFind ! null){_DListNodeT* pNode _First;int nIndex 0;while (pNode ! null){if (pNode pFind)return nIndex;pNode pNode-Next;nIndex; }}return -1;}/// summary/// 删除链表中的数据/// /summary/// typeparam nameT/typeparam/// param namepData/param/// returns/returnsinline bool RemoveItem(const T pData){if (this-_so _SortOrder::s_null){_DListNodeT* pNode _First;while (pNode ! null){if (pNode-Data pData) //找到一项{if (pNode _First) //删除的是第一个节点{if (_First-Next ! null){_First-Next-Prev null;_First _First-Next;}else{_First null;_Last null;}}else if (pNode _Last) //删除的是最后一个节点{if (_Last-Prev ! null){_Last-Prev-Next null;_Last _Last-Prev;}else{_Last null;_Last null;}}else //删除的是中间的一个节点{pNode-Next-Prev pNode-Prev;pNode-Prev-Next pNode-Next;}--_Count;return true;}pNode pNode-Next;}return false;}else{return RemoveAt(BinarySearch(pData));}}/// summary/// 删除最后一个节点/// /summary/// 创建时间2020-09-12 最后一次修改时间 2023-01-18inline bool DeleteLast(){auto pDelete Last();if (_Count 0){return false;}else if (_Count 1){_First null;_Last null;_Count 0;}else if (_Count 2){_Last _First;_Last-Prev null;_Last-Next null;_First-Next null;_First-Prev null;--_Count;}else{_Last-Prev-Next null;_Last _Last-Prev;--_Count;}_Memory::Delete_DListNodeT(pDelete, 1);return true;}/// summary/// 添加一个元素并把它放在首位其它元素后移,如果后面的元素删除总无素个数不变如果元素个数为零则添加一个无素。/// /summary/// param nameItem/param/// param namebRemoveLast/param/// 创建时间 2022-04-19 最后一次修改时间2022-04-19inline void HistoryAdd(const T Item, bool bRemoveLast){if (_Count 0) {Add(Item);}else if (_Count 1) {if (bRemoveLast) {_First-Data Item;}else {//把无素放在最前_DListNodeT* dnNew _Memory::New_DListNodeT(1);dnNew-Data Item;_First-Prev dnNew;dnNew-Next _First;_First dnNew;_Count;}}else {if (bRemoveLast) {_DListNodeT* dnDelete _Last;//删除最后一个元素_Last _Last-Prev;_Last-Next null;_DListNodeT* dnNew _Memory::New_DListNodeT(1);dnNew-Data Item;_First-Prev dnNew;dnNew-Next _First;dnNew-Prev null;_First dnNew;_Memory::Delete _DListNodeT(dnDelete, 1);}else {//把无素放在最前_DListNodeT* dnNew _Memory::New_DListNodeT(1);dnNew-Data Item;_First-Prev dnNew;dnNew-Next _First;dnNew-Prev null;_First dnNew;_Count;}}}/// summary/// 出栈(先进后出,删除最后一个元素/// /summary/// 创建时间 2022-04-19 最后一次修改时间2023-04-06inline T StackPop(){assert(_Count 0);T tResult _Last-Data;this-RemoveAt(_Count - 1);return tResult;}//----------------------------------------------------------------------------------------------------Python List方法/// summary/// 将元素tItem添加到列表末尾。/// /summary/// 创建时间 2023-04-08 最后一次修改时间2023-04-08inline void Python_append(const T tItem){Add(tItem);}/// summary/// 在位置nIndex后面插入一个元素tItem/// /summaryinline void Python_insert(const size_t nIndex, const T tItem){InserNodeBack(IndexOfNode(nIndex), tItem);}/// summary/// 在最前面插入一项/// /summary/// param nametItem/param/// 创建时间 2024-04-16 最后一次修改时间2024-09-19inline void inseart_front(const T tItem){this-SortOrder _SortOrder::s_null;_DListNodeT* pNode _Memory::New_DListNodeT(1);pNode-Data tItem;if (_First ! null){_First-Prev pNode;pNode-Next _First;pNode-Prev null;_First pNode;}else{ pNode-Next null;pNode-Prev null;_First pNode;_Last pNode;}_Count;}inline _DListNodeT* inseart_back(_DListNodeT* pNode, const T tData) {return this-InserNodeBack(pNode, tData);}inline _DListNodeT* inseart_front(_DListNodeT* pNode, const T tData) {return this-InserNodeFront(pNode, tData);}/// summary/// 删除索引位置为nIndex的元素并返回删除的元素值的拷贝如果索引值nIndex -1则默认删除为最后一个元素。/// /summary/// param namenIndex/param/// returns/returns/// 创建时间 2023-04-08 最后一次修改时间2023-04-09inline T Python_pop(const size_t nIndex npos){if (nIndex npos){ return StackPop();}else{ auto dn this-IndexOfNode(nIndex);T tmp T();if (dn ! null){tmp dn-Data; DeleteNode(dn);}return tmp;} }/// summary/// 删除值为tItem的一项。/// 注意方法remove()只删除第一个指定的值。如果要删除的值可能在列表中出现多次/// 就需要使用循环来确保每个值都删除。/// /summaryinline bool Python_remove(const T tItem){ int n _Count;DeleteNode(FindNodeItem(tItem));return n _Count;}protected:/// summary/// 删除链表中的节点/// /summary/// typeparam nameT/typeparam/// param namepListItem/param/// returns/returns//inline bool DeleteNode(const _DListNodeT* pNodeDelete)//{// if (_Count 0 || pNodeDelete null)// {// return false;// }// _DListNodeT* pNode _First.Next;// while (pNode ! null)// {// if (pNode pNodeDelete) //找到了// {// //pListItem-Prev// if (pNodeDelete-Prev ! null)// {// pNodeDelete-Prev-Next pNodeDelete-Next;// }// else //删除的是第一个节点// {// _First pNodeDelete.Next;// }// //pListItem-Next// if (pNodeDelete-Next ! null)// {// pNodeDelete-Next-Prev pNodeDelete-Prev;// }// else //删除的是最后一个节点// {// _Last pNodeDelete-Prev;// }// break;// }// pNode pNode-Next;// }// if (pNode ! null)// {// --_Count;// _Memory::Delete _DListNodeT (pNode,1); //C#不用清除内存// return true;// }// return false;//}/// summary/// 删除链表中的某一节点注意这个节点一定要是在链表中的。/// /summary/// 创建时间 2023-04-09 最后一次修改时间2023-04-09inline void DeleteNode(_DListNodeT* pNodeDelete){if (_Count 0 || pNodeDelete null) return;if (_Count 1){ClearMemory();}else{if (pNodeDelete _First) //删除的是第一个节点{_First _First-Next;_First-Prev null;}else if (pNodeDelete _Last){_Last _Last-Prev;_Last-Next null;}else{pNodeDelete-Prev-Next pNodeDelete-Next;pNodeDelete-Next-Prev pNodeDelete-Prev;}--_Count;_Memory::Delete _DListNodeT (pNodeDelete, 1);}}public://---------------------------------------------------------- Cinline void push_back(const T tItem) { Add(tItem); }inline void push_front(const T tItem) { this-inseart_front(tItem);}public: //------------------------------------------------------------------重写/// summary/// 转换为字符串/// /summary/// returns/returns/// 创建时间 2023-05-16 最后一次修改时间2024-07-23inline virtual _string ToSplitString(const _string sSplitString) const override{//不可以这样 const _DList_Object* dp (_DList_Object *)pList;//就算 T 类型数据是从 _Object中继承也不可以。_string sResult;sResult.Add(_t({));_string sp sSplitString.Length 0 ? _string(_t(,)) : sSplitString;if(_Count 0){//是否继承处_Objectif (std::is_base_of_Object, T::value){ _Object* po;if (_Count 1){po (_Object*)(_First-Data);sResult.Add((_string)(*po));}_DListNodeT* dn this-_First;while (dn ! _Last){po (_Object*)(dn-Data);sResult.Add((_string)(*po));sResult.Add(sp);dn dn-Next;}po (_Object*)(_Last-Data);sResult.Add((_string)(*po));}else{if (typeid(T) typeid(int)){_DListNodeT* dn this-_First;while (dn ! _Last){int* pInt (int*)(dn-Data);sResult.Add(_string::Java_valueOf(*pInt));sResult.Add(sp);dn dn-Next;}if (this-Count 0)sResult.Add(_string::Java_valueOf(*((int*)((_Last-Data)))));} else if(typeid(T) typeid(size_t)){_DListNodeT* dn this-_First;while (dn ! _Last){size_t* pInt (size_t*)(dn-Data);sResult.Add(_string::Java_valueOf(*pInt));sResult.Add(sp);dn dn-Next;}if (this-Count 0)sResult.Add(_string::Java_valueOf(*((size_t*)((_Last-Data)))));}else if (typeid(T) typeid(double)){if (_Count 0) return sResult;double* pd;if (_Count 1){pd (double*)((_First-Data));sResult.Add(_Convert::DoubleToString(*pd));}_DListNodeT* dn this-_First;while (dn ! _Last){pd (double*)(dn-Data);sResult.Add(_Convert::DoubleToString(*pd));sResult.Add(sp);dn dn-Next;}pd (double*)(_Last-Data);sResult.Add(_Convert::DoubleToString(*pd));}else if (typeid(T) typeid(_string)){_string* ps;_DListNodeT* dn this-_First;while (dn ! _Last){ps (_string*)(dn-Data);sResult.Add(_t(\));sResult.Add(*ps);sResult.Add(_t(\));sResult.Add(sp);dn dn-Next;}if (_Count 0){ps (_string*)(_Last-Data);sResult.Add(_t(\));sResult.Add(*ps);sResult.Add(_t(\));}}else if (typeid(T) typeid(_StrA)){_StrA* ps;if (_Count 0){}else if (_Count 1){ps (_StrA*)(_First-Data);sResult.Add(_t(\));sResult.Add(*ps);sResult.Add(_t(\));}else{_DListNodeT* dn this-_First;while (dn ! _Last){ps (_StrA*)(dn-Data);sResult.Add(_t(\));sResult.Add(*ps);sResult.Add(_t(\));sResult.Add(_t(,));dn dn-Next;}ps (_StrA*)(_Last-Data);sResult.Add(_t(\));sResult.Add(*ps);sResult.Add(_t(\));}}else if (typeid(T) typeid(std::string)) {std::string* ps;if (_Count 0){}else if (_Count 1){ps (std::string*)(_First-Data);sResult.Add(_t(\));sResult.Add(_string(ps-c_str()));sResult.Add(_t(\));}else{_DListNodeT* dn this-_First;while (dn ! _Last){ps (std::string*)(dn-Data);sResult.Add(_t(\));sResult.Add(_string(ps-c_str()));sResult.Add(_t(\));sResult.Add(_t(,));dn dn-Next;}ps (std::string*)(_Last-Data);sResult.Add(_t(\));sResult.Add(_string(ps-c_str()));sResult.Add(_t(\));}}else //所有继承自 _Object 类的数据类型都可以{sResult.Add(_t(_LDList::ToSplitString重写,数据类型为));sResult.Add(_string(typeid(T).name())); }}}sResult.Add(_t(}));return sResult;}inline _string ToString()const{return ToSplitString(_t());}////std/// summary/// 在_Where位置前插入[itBegin,itEnd)用法与std::list::insert要一样/// 注意std旧重版itBegin和itEnd不能指向与目的位置相同的容器,在新标准版可以。/// /summary/// typeparam nameIteratorClass/typeparam/// param name_Where/param/// param nameitBegin/param/// param nameitEnd/param/// 创建时间 2024-09-22 最后一次修改时间2024-09-22 (已测试templateclass IteratorClassinline _DListNodeIteratorT std_insert(const _DListNodeIteratorT _Where, const IteratorClass itBegin,const IteratorClass itEnd) {/*list slist; //运行时错误迭代器表示要拷贝的范围不能指向与目的位置相同的容器slist.insert(slist.begin(),slist.begin(),slist.end());*/if (typeid(_DListNodeIteratorT) typeid(IteratorClass)) {_DListNodeIteratorT* pbegin (_DListNodeIteratorT*)(itBegin);_DListNodeIteratorT* pend (_DListNodeIteratorT*)(itEnd);//lassert(_Where._pCurrentList ! p-_pCurrentList,不能插入指向相同容器的元素);if (_Where._pCurrentList pbegin-_pCurrentList) {//创建一个临时链表,会影响性能_DListT tmp(*pbegin,*pend);return std_insert(_Where, tmp.begin(), tmp.end());} } IteratorClass tmp itBegin;_DListNodeT* pReulst null;if (_Where._Ptr null) {while (tmp ! itEnd) {if (pReulst null) {//保存第一次插入的结点以便返回pReulst this-inseart_back(_Last, *tmp);}elsethis-inseart_back(_Last, *tmp);tmp;}}else {auto ptr _Where._Ptr;while (tmp ! itEnd) {if (pReulst null) //第一次在前面插入第一项{ptr this-inseart_front(ptr, *tmp);//保存第一次插入的结点以便返回pReulst ptr;}else { //第二次开始在插入的第一项后面依次插入ptr this-inseart_back(ptr, *tmp);}tmp;}}return _DListNodeIteratorT(pReulst, this);}/// summary/// std::insert/// /summary/// param name_Where/param/// param name_Ilist/param/// returns/returns/// 创建时间 2024-09-22 最后一次修改时间2024-09-22 (已测试inline _DListNodeIteratorT std_insert(const _DListNodeIteratorT _Where,std::initializer_listT _Ilist) {return std_insert(_Where, _Ilist.begin(), _Ilist.end());}/// summary/// std::insert/// /summary/// param name_Where/param/// param nametValue/param/// returns/returns/// 创建时间 2024-09-22 最后一次修改时间2024-09-22 (已测试inline _DListNodeIteratorT std_insert(const _DListNodeIteratorT _Where, const T tValue) {if (_Where._Ptr null)return _DListNodeIteratorT(inseart_back(_Last, tValue), this);elsereturn _DListNodeIteratorT(inseart_front(_Where._Ptr, tValue), this);}}; //--------------------------------------------------------------------------DList////SortedDList///// summary
/// C#语句public class SortListT : _DListT
/// /summary
/// typeparam nameT/typeparam
templateclass T
class SortedDList : public _DListT
{};////_StrList//
templateclass T
class _StrList : public _DListT
{public: //------------------------------------------------------------------构造与析构 _StrList() : _DListT() {};_StrList(const _StrListT sl) : _DListT(sl) {};explicit _StrList(const _char* pStr, const _char* pSplit, bool bIgnoreEmptyString false){this-InitData();SplitForSeparator(pStr, pSplit, bIgnoreEmptyString);}/// summary/// 要加上 explicit阻止自动转换 否则执行语名会自动调用这个构造函数 _StrList ls { LAA,LBB};/// /summary/// param namesText/param/// param namesSplit/param/// param namebIgnoreEmptyString/paramexplicit _StrList(const T sText, const T sSplit, bool bIgnoreEmptyString false){//assert(sText ! null sSplit ! null);//SplitForSeparator(sText.Data, sSplit.Data, bIgnoreEmptyString);if (sText.Length 0) { return; }if (sSplit.Length 0) { Add(sText); return; }int iStart 0;int iIndex sText.IndexOf(sSplit, iStart);if (iIndex -1){Add(sText);return;}while (iIndex ! -1 iStart 1 sText.Length){if (iIndex ! iStart)Add(sText.SubStr(iStart, iIndex - iStart));else{if (!bIgnoreEmptyString) Add(T());}iStart iIndex sSplit.Length;iIndex sText.IndexOf(sSplit, iStart);if (iIndex -1 sText.Length ! iStart)Add(sText.SubStr(iStart, sText.Length - iStart)); //拷贝最后一个}}_StrList(std::initializer_listT aList){for (T s : aList){Add(s);}}public: //------------------------------------------------------------------操作void writeToFile(const T sFullPathName){}bool readToFile(const T sFullPathName){return false;}bool readToUnicodeFile(const T sFileName, const T sSplit){return false;}/// summary/// 获取所有字符串的总共长度/// /summary/// returns/returns/// 创建时间 2022-11-05 最后一次修改时间 2022-11-05 int GetStringLength() const{int iSum 0;auto dn this-_First;while (dn ! null) {iSum (int)dn-Data.Length;dn dn-Next;}return iSum;}T connectForSeparator(const T sConnector)const{if (this-_Count 0) return _t();if (this-_Count 1) return this-_First-Data;T tmp(_t(), GetStringLength() sConnector.Length * this-_Count 100);_DListNodeT* ldNode this-_First;while (ldNode ! this-_Last){tmp ldNode-Data;tmp sConnector;ldNode ldNode-Next;}tmp this-_Last-Data; //加入最后一项return tmp;}T connectForSeparator(const _char cConnector) const{return connectForSeparator(cConnector);}/// summary/// 返回分隔后的字符串列表/// /summary/// param namepStr原文本/param/// param namepSplit分隔字符串/param/// param namebIgnoreEmptyString是否忽略空字符串/param/// returns返回一个字符串列表/returns/// 创建时间 2022-10-04 最后一修改时间2022-10-05 已测试_StrListT SplitForSeparator(const _char* pStr, const _char* pSplit, bool bIgnoreEmptyString){if (pStr null || pSplit null){_cout 在中_StrList::SplitForSeparator中 LpStr null || pSplit null \n;throw pStr null || pSplit null;}this-ClearData();if (pStr[0] 0 || pSplit[0] 0){Add(_t(), 0, 0);return *this;}int i 0;int j 0;int nStart 0, nEnd 0;while (pStr[i] ! 0) {// _cout _t(pStr[i] ) pStr[i] _t(\n); //此句出错无任何提示bool bFind true;j 0;while (pSplit[j] ! 0) {if (pStr[i j] ! pSplit[j]) {bFind false;break;}j;}if (bFind) {nEnd i - 1; //此处如果 nEnd 是 int 则 nEnd i - 1 nEnd 18446744073709551615 溢出错误 if (bIgnoreEmptyString) {if (nStart nEnd) {Add(pStr, nStart, nEnd); //这里应nStart nEnd而不是 nStart nEnd因为当 nStart nEnd 还是有一个字符的}}else {Add(pStr, nStart, nEnd);}nStart i j;i nStart - 1;}i;}//拷贝右边最后一项if (bIgnoreEmptyString) {if (nStart i - 1) {Add(pStr, nStart, (int)i - 1);}}else {Add(pStr, nStart, (int)i - 1);}return *this;}//int SplitForSeparator(const T sText, const _char cSplit);int IndexOf(const T s){int nIndex 0;auto dn this-_First;while (dn){if (dn-Data s) { return nIndex; }nIndex;dn dn-Next;}return -1;}int GetMaxSpaceLength(int nTabCount 9, int nChineseCharactersCount 3)const{int nMax 0;auto dn this-_First;while (dn){int n gs.s_length_space(dn-Data.Data, nTabCount, nChineseCharactersCount);if (n nMax) nMax n;dn dn-Next;}return nMax;}/// summary/// 用tab键使每行等长/// /summary/// param namenTabCount/param/// returns/returns/// 创建时间 2022-10-30 最后一次修改时间 2022-10-30 T equilongTabLine(int nTabCount 9){this-RemoveHeadTab();int iMax GetMaxSpaceLength(nTabCount);for (T s : *this) {int nSapceLength gs.s_length_space(s.Data);int n (iMax - nSapceLength) / 9;if (iMax - nSapceLength - n * 9 5)n;else--n;for (int j 0; j n; j){s.Add(_t(\t));}}return connectForSeparator(_t(\n)) _t(\n);}/// summary/// 计算所有行如果每行都有开始处都有 \t 则每行除去 \t , 除去个数以最少 \t 行为准。/// 例/// \t\t abc/// \t bcd/// \t\t\t dd/// 运行函数后变成/// \t abc/// bcd/// \t\t dd/// /summary/// 创建时间 2022-11-05 最后一次修改时间 2022-11-05 void RemoveHeadTab(){int iMin 100000000;for (T s : *this) {if (s.Length 0){int iCount gs.s_headTabCount(s.Data);if (iCount iMin) { iMin iCount; }//log::d(iCount iCount.ToString(), s);}}//log::d(iMin iMin.ToString());if (iMin 0){for (T s : *this) {s s.SubStr(iMin, s.Length - iMin);}}}//-----------------------------------------------------------------------虚函数virtual _DListNodeT* Add(const T item) override{//_cout item \n;return _DListT::Add(item);}void Add(const _StrListT ls) //覆盖 父类重载函数 virtual bool Add(const T item);{_DListNodeT* pNode ls._First;while (pNode ! null){Add(pNode-Data);pNode pNode-Next;}}/// summary/// 添加拷贝nStartPos和nEndPos之间的字符包括nStartPos和nEndPos。/// /summary/// param namestr/param/// param namenStartPos/param/// param namenEndPos/param/// returns/returns/// 创建时间 ????-??-?? 最后一次修改时间????-??-?? 已测试2024-08-16 bool Add(const T str, int nStartPos, int nEndPos){if (str.Length 0 || nEndPos - nStartPos 0){Add(T());}else {int nLength nEndPos - nStartPos 1;/*_Mem_char m(nLength 1);for (int i 0; i nLength; i){m.Data[i] pStr[nStartPos i];}m.Data[nLength] 0;*/Add(str.SubStr(nStartPos, nLength));}return false;}_string ToSplitString(const _string sSplitString) const override{/** auto dn this-_First;T sResult;while (dn ! this-_Last){ sResult.std_append(dn-Data); sResult.std_append(sConnector);dn dn-Next;}if (this-_Last ! null){sResult.std_append(dn-Data);}char c \n;sResult.std_append(c );return sResult;*/return _DListT::ToSplitString(sSplitString);}
};////_UStrList//
/// summary
/// 不重复的字符串列表
/// /summary
/// typeparam nameT/typeparam
/// 创建时间 2023-05-11 最后一次修改时间2023-05-11
templateclass T
class _UStrList : public _StrListT
{
public:/// summary/// 加入一个串如果这个串存在则把这项移到最后。/// /summary/// param nameitem/param/// 创建时间 ????-??-?? 最后一次修改时间2024-09-23 (已测试_DListNodeT* Add(const T item)override{ bool bFind false;_DListNodeT* dnTemp this-_First;while (dnTemp ! null){if (dnTemp-Data item){return this-MoveLast(dnTemp); }dnTemp dnTemp-Next;}return _StrListT::Add(item); }};////_UStrListCI//
/// summary
/// 值都是唯一的字符串列表 Case Insensitive(不区分大小写)
/// /summary
templateclass T
class _UStrListCI : public _StrListT
{public:/// summary/// 加入一个串如果这个串存在则把这项移到最后。/// /summary/// param nameitem/param/// 创建时间 ????-??-?? 最后一次修改时间2024-09-23_DListNodeT* Add(const T item)override{bool bFind false;_DListNodeT* dnTemp this-_First;while (dnTemp ! null){if (dnTemp-Data.csharp_ToLower() item.csharp_ToLower()){return this-MoveLast(dnTemp);}dnTemp dnTemp-Next;}return _StrListT::Add(item); }/*/// summary/// 返回前面一个值/// /summary/// param nametCurrValue/param/// returns/returnsT GetForward(T sCurr){int iIndex BinarySearch(sCurr);if (iIndex ! -1){if (iIndex 1 _Count)return this[iIndex 1];}return null;}/// summary/// 返回后面的一个值/// /summary/// param namesCurr/param/// returns/returnsT GetBack(T sCurr){int iIndex BinarySearch(sCurr);if (iIndex ! -1){if (iIndex - 1 _Count iIndex - 1 0)return this[iIndex - 1];}return null;}*/
};////_SStrList//
/// summary
/// 已排序好的字符串列表
/// /summary
templateclass T
class _SStrList : public _StrListT
{
public:_SStrList(const _SortOrder so _SortOrder::s_Minmax){this-_so so;if (this-_so _SortOrder::s_null){throw _t(排序不能为空);}}//-------------------------------------------------------------------------------重写/// summary/// 快速添加字符串差不多用了8个小时(两天才写成。/// /summary/// param names/param/// returns/returnsbool Add(const T item) override{if (this-_Count 3){bool bInsert false;_DListNodeT* ld this-_First;while (ld ! null){if (this-_so _SortOrder::s_Maxmin){if (item ld-Data){_StrListT::InserNodeFront(ld, item); bInsert true;break;}}else{if (item ld-Data){_StrListT::InserNodeFront(ld, item); bInsert true; break;}}ld ld-Next;}if (!bInsert) _StrListT::Add(item);return true;}int nPos this-_Count / 2; //nPos在中间所以无素一定要大于等于3才行int nLeft 0; //左边远素int nRight this-_Count - 1; //右边远素if (this-_so _SortOrder::s_Maxmin){_DListNodeT* ld null;while (nRight 0 nLeft 0){ld this-IndexOfNode(nPos);if (item ld-Data){if (nRight nLeft || nPos nLeft){this-InserNodeFront(ld, item);return true;}nRight nPos - 1;}else{if (nRight nLeft || nPos nRight){this-InserNodeBack(ld, item);return true;}nLeft nPos 1;}nPos nLeft (nRight - nLeft 1) / 2;}}else{_DListNodeT* ld null;while (nRight 0 nLeft 0){ld this-IndexOfNode(nPos);if (item ld-Data){if (nRight nLeft || nPos nLeft){this-InserNodeFront(ld, item);return true;}nRight nPos - 1;}else{if (nRight nLeft || nPos nRight){this-InserNodeBack(ld, item);return true;}nLeft nPos 1;}nPos nLeft (nRight - nLeft 1) / 2;}}return true;}/// summary/// 确定某元素是否在列表中/// /summary/// param nameitem查找的对象。对于引用类型该值可以为 null。/param/// returns如果在列表中找到 item则为 true否则为 false。/returnsbool Contains(const T item) override{if (this-_Count 0) return false;if (this-_Count 1) return this-_First-Data item;if (this-_Count 2) return this-_First-Data item || this-_First-Next-Data item;int nPos (int)this-_Count / 2; //nPos在中间所以无素一定要大于等于3才行int nLeft 0; //左边远素int nRight (int)this-_Count - 1; //右边远素_DListNodeT* ld null;if (this-_so _SortOrder::s_Maxmin){while (nRight 0 nLeft 0){ld this-IndexOfNode(nPos);int iCom item.CompareTo(ld-Data);if (iCom 0){if (nRight nLeft || nPos nLeft){return false;}nRight nPos - 1;}else if (iCom 0){if (nRight nLeft || nPos nRight){return false;}nLeft nPos 1;}else{return true;}nPos nLeft (nRight - nLeft 1) / 2;}}else{while (nRight 0 nLeft 0){ld this-IndexOfNode(nPos);int iCom item.CompareTo(ld-Data);if (iCom 0){if (nRight nLeft || nPos nLeft){return false;}nRight nPos - 1;}else if (iCom 0){if (nRight nLeft || nPos nRight){return false;}nLeft nPos 1;}else{return true;}nPos nLeft (nRight - nLeft 1) / 2;}}return false;}};////_SUStrList//
/// summary
/// 值都是唯一的字符串列表,且已排好序区分大小写
/// /summary
templateclass T
class _SUStrList : public _SStrListT
{
public:bool Add(const T item)override{if (this-Contains(item))return false;return _SStrListT::Add(item);}_SUStrList(_SortOrder so _SortOrder::s_Minmax) : _SStrListT(so){}};////_SUStrListUI//
/// summary
/// _SUStrListUI 值都是唯一,且已排序的字符串列表不区分大小写
/// /summary
templateclass T
class _SUStrListUI : public _SUStrListT
{
public:_SUStrListUI(_SortOrder st) : _SUStrListT(st){}/// summary/// 确定某元素是否在列表中/// /summary/// param nameitem查找的对象。对于引用类型该值可以为 null。/param/// returns如果在列表中找到 item则为 true否则为 false。/returnsbool Contains(const T item) override{if (this-_Count 0) return false;if (this-_Count 1) return this-_First-Data.ToLower().CompareTo(item.ToLower()) 0;if (this-_Count 2) return this-_First-Data.ToLower().CompareTo(item.ToLower()) 0 || this-_First-Next-Data.ToLower().CompareTo(item.ToLower()) 0;int nPos (int)this-_Count / 2; //nPos在中间所以无素一定要大于等于3才行int nLeft 0; //左边远素int nRight (int)this-_Count - 1; //右边远素_DListNodeT* ld null;if (this-_so _SortOrder::s_Maxmin){while (nRight 0 nLeft 0){ld this-IndexOfNode(nPos);int iCom item.ToLower().CompareTo(ld-Data.ToLower());if (iCom 0){if (nRight nLeft || nPos nLeft){return false;}nRight nPos - 1;}else if (iCom 0){if (nRight nLeft || nPos nRight){return false;}nLeft nPos 1;}else{return true;}nPos nLeft (nRight - nLeft 1) / 2;}}else{while (nRight 0 nLeft 0){ld this-IndexOfNode(nPos);int iCom item.ToLower().CompareTo(ld-Data.ToLower());if (iCom 0){if (nRight nLeft || nPos nLeft){return false;}nRight nPos - 1;}else if (iCom 0){if (nRight nLeft || nPos nRight){return false;}nLeft nPos 1;}else{return true;}nPos nLeft (nRight - nLeft 1) / 2;}}return false;}};// _SUStrListUI_LF_END_
#endif
