c++问题，实现双向循环链表的插入删除等基本功能，以及构造函数和析构函数 2C

template
struct DoubleNode
{

T data;
DoubleNode *right;
DoubleNode *left;

DoubleNode() {}
DoubleNode(const T& data)
{this->data = data;}
DoubleNode(const T& data, DoubleNode* right,DoubleNode* left)
{this->data = data;
this->right = right;
this->left = left;}
};

template //类的声明
class HDoubleCircular {

public:
HDoubleCircular() {}//构造函数不会写
~HDoubleCircular();//析构函数不会
int Length() const;
bool Find(int k, T& x) const;
T Get(int k)const;
int Indexof(const T& x) const;
int Search(const T& x) const;
HDoubleCircular& Delete(int k);
HDoubleCircular& Insert(int k, const T& x);
void Output(ostream& out) const;

private:
int size
};

2个回答

#include "List.hpp"
#include
#include
#include
#include

void list::clear() {
listPointer q = NULL;
while (p != NULL) {
q = p;
p = p->next;
delete q;
}
this->_size = 0;
}

list::list() {
this->_size = 0;
}

list::list(const list& another) {
this->_size = 0;
this->assign(another);
}

list::list(const data_type datas[], int length) {
this->_size = 0;
this->assign(datas, length);
}

list& list::operator=(const list& another) {
this->assign(another);
return *(this);
}

list::~list() { this->clear(); }

bool list::empty() const { return this->_size == 0; }

list::size_type list::size() const { return this->_size; }

list::data_type& list::front() const {
return this->empty() ? reinterpret_cast<data_type>(NULL) : head->data;
}

list::data_type& list::back() const {
return this->empty() ? reinterpret_cast<data_type>(NULL) : tail->data;
}

inline std::string int2String(int a) {
std::stringstream ss;
ss << a;
return ss.str();
}

std::string list::toString(void) const {
if (this->_size == 0) {
return "NULL";
}
std::string ret;
ret += "NULL<-";
while (p != NULL) {
ret += int2String(p->data);
if (p != this->tail) {
ret += "<->";
}
p = p->next;
}
ret += "->NULL";
return ret;
}

void list::assign(const list& another) {
if (!(this == &another)) {
this->clear();
while (p != NULL) {
this->push_back(p->data);
p = p->next;
}
}
}

void list::assign(const data_type datas[], int length) {
this->clear();
for (int i = 0; i < length; i++) {
this->push_back(datas[i]);
}
}

void list::push_front(const data_type& data) {
this->insert(0, data);
}

void list::push_back(const data_type& data) {
this->insert(this->_size, data);
assert(this->tail->data == data);
}

void list::pop_front(void) { this->erase(0); }

void list::pop_back(void) { this->erase(this->_size - 1); }

void list::insert(int position, const data_type& data) {
if (position == 0) {
listPointer temp = new listNode(data, this->head);
if (this->_size == 0) {
} else {
}
this->_size++;
} else if (position == this->_size) {
listPointer temp = new listNode(data, NULL, this->tail);
this->tail->next = temp;
this->tail = this->tail->next;
this->_size++;
} else {
listPointer p = at(position - 1);
if (p != NULL) {
listPointer temp = new listNode(data, p->next, p);
p->next->prev = temp;
p->next = temp;
this->_size++;
assert(this->at(position)->data == data);
}
}
}

void list::erase(int position) {
if (this->empty()) return;
if (position == 0) {
if (this->_size == 1) {
} else {
this->_size--;
}
} else if (position == this->_size - 1) {
this->tail = this->tail->prev;
assert(tail != NULL);
delete this->tail->next;
this->tail->next = NULL;
this->_size--;
} else {
listPointer p = at(position);
if (p != NULL) {
p->prev->next = p->next;
p->next->prev = p->prev;
delete p;
this->_size--;
}
}
}

void list::split(int position, list* dest1, list* dest2) {
if (dest1 == dest2) {
throw dest1;
return;
}
if (position < 0 || position > this->_size) return;
int counter = 0;
list temp1, temp2;
while (p != NULL) {
if (counter == position) {
break;
}
temp1.push_back(p->data);
p = p->next;
counter++;
}
while (p != NULL) {
temp2.push_back(p->data);
p = p->next;
}
(*dest1) = temp1;
(*dest2) = temp2;
}

list& list::merge(const list& src1, const list& src2) {
list temp;
if (src1.empty()) {
temp = src2;
} else {
temp = src1;
while (p != NULL) {
temp.push_back(p->data);
p = p->next;
}
}
*(this) = temp;
return *(this);
}

list& list::remove_if(bool (*condition)(list::listPointer)) {
while (p != NULL) {
if (condition(p)) {
}
delete p;
this->_size--;
if (p == NULL) {
this->tail = NULL;
}
} else if (p == this->tail) {
this->tail = this->tail->prev;
this->tail->next = NULL;
delete p;
this->_size--;
p = NULL;
} else {
p->prev->next = p->next;
p->next->prev = p->prev;
listNode* q = p->next;
delete p;
p = q;
this->_size--;
}
} else {
p = p->next;
}
}
return *(this);
}

list& list::unique(void) {
listPointer slow, fast;
while (slow != NULL) {
fast = slow->next;
while (fast != NULL) {
if (fast->data == slow->data) {
} else {
this->tail = NULL;
}
} else if (fast == this->tail) {
this->tail = this->tail->prev;
this->tail->next = NULL;
delete fast;
fast = NULL;
} else {
fast->next->prev = fast->prev;
fast->prev->next = fast->next;
listPointer temp = fast;
fast = fast->next;
delete temp;
}
this->_size--;
} else {
fast = fast->next;
}
}
slow = slow->next;
}
return *(this);
}

list& list::reverse(void) {
while (p != NULL) {
listPointer q = p->prev;
p->prev = p->next;
p->next = q;
p = p->prev;
}
listPointer q = this->tail;
return *(this);
}

list::data_type& list::operator {
listPointer p = at(index);
assert(p != NULL);
return p->data;
}

list& list::operator+=(const list& another) {
return this->merge(*this, another);
}

std::ostream& operator<<(std::ostream& os, const list& li) {
return (os << li.toString());
}

Johnny_Law #include <string>， #include <sstream>
3 年多之前 回复
Johnny_Law 还要多包含两个库，显示出了点问题。。。。
3 年多之前 回复

c++问题，实现双向循环链表的插入删除等基本功能，以及构造函数和析构函数

``` #pragma once #define V_TPLS template<class T>\ void MyList<T>:: template<class T> class MyList { T data; MyList* next, *back; public: MyList() { next = this; back = this; data = 0; } //在链表后插入数据 void push_back(T data); //在链表前插入数据 void push_front(T data);//前继 //清空整个链表 void _clear() { while (this->next!=this) { MyList *temp = this->next; this->next = this->next->next; delete temp; } } void put() { MyList *p = this->next; while (p!=this) { cout << p->data << ends; p = p->next; } } ~MyList() { _clear(); } }; //在链表后插入数据 V_TPLS push_back(T data) { MyList *temp = new MyList; temp->data = data; static MyList*p_n = this; temp->next = p_n->next; temp->back = p_n; p_n->next = temp; p_n = p_n->next; this->back = temp; } //在链表前插入数据 V_TPLS push_front(T data) { MyList *temp = new MyList; temp->data = data; temp->next = this->next; temp->back = this; this->next->back = temp; this->next = temp; } ``` 为什么我的_clear()运行的时候this指针的地址为什么会改变呢? 每次运行到_clear()函数时就会报错

ARM开发中，用C语言 实现双向链表

【数据结构】在c++平台上用循环链表实现节点删除操作
【数据结构】在c++平台上用循环链表实现节点删除操作，求大神解答，
c#链表问题，包括最基础的单链表双链表以及循环链表的使用

C语言单链表的插入求解了

C语言双向链表求中点

Java语言设计实现一个链表的数据结构，不要使用现有的库的代码，并且插入5个数字再输出
Java语言设计实现一个链表的数据结构，不要使用现有的库的代码，并且插入5个数字再输出

HashMap链表的插入方式

Java学习的正确打开方式

linux系列之常用运维命令整理笔录

Python十大装B语法
Python 是一种代表简单思想的语言，其语法相对简单，很容易上手。不过，如果就此小视 Python 语法的精妙和深邃，那就大错特错了。本文精心筛选了最能展现 Python 语法之精妙的十个知识点，并附上详细的实例代码。如能在实战中融会贯通、灵活使用，必将使代码更为精炼、高效，同时也会极大提升代码B格，使之看上去更老练，读起来更优雅。

2019年11月中国大陆编程语言排行榜
2019年11月2日，我统计了某招聘网站，获得有效程序员招聘数据9万条。针对招聘信息，提取编程语言关键字，并统计如下： 编程语言比例 rank pl_ percentage 1 java 33.62% 2 cpp 16.42% 3 c_sharp 12.82% 4 javascript 12.31% 5 python 7.93% 6 go 7.25% 7 p...

《奇巧淫技》系列-python！！每天早上八点自动发送天气预报邮件到QQ邮箱

Docker 从入门到掉坑
Docker 介绍 简单的对docker进行介绍，可以把它理解为一个应用程序执行的容器。但是docker本身和虚拟机还是有较为明显的出入的。我大致归纳了一下，可以总结为以下几点： docker自身也有着很多的优点，关于它的优点，可以总结为以下几项： 安装docker 从 2017 年 3 月开始 docker 在原来的基础上分为两个分支版本: Docker CE 和 Doc...

SQL-小白最佳入门sql查询一

Nginx 原理和架构
Nginx 是一个免费的，开源的，高性能的 HTTP 服务器和反向代理，以及 IMAP / POP3 代理服务器。Nginx 以其高性能，稳定性，丰富的功能，简单的配置和低资源消耗而闻名。 Nginx 的整体架构 Nginx 里有一个 master 进程和多个 worker 进程。master 进程并不处理网络请求，主要负责调度工作进程：加载配置、启动工作进程及非停升级。worker 进程负责处...
Python 编程开发 实用经验和技巧
Python是一门很灵活的语言，也有很多实用的方法，有时候实现一个功能可以用多种方法实现，我这里总结了一些常用的方法和技巧，包括小数保留指定位小数、判断变量的数据类型、类方法@classmethod、制表符中文对齐、遍历字典、datetime.timedelta的使用等，会持续更新......
Idon’t know what that dream is that you have, I don't care how disappointing it might have been as you've been working toward that dream,but that dream that you’re holding in your mind, that it’s po...
“狗屁不通文章生成器”登顶GitHub热榜，分分钟写出万字形式主义大作

《程序人生》系列-这个程序员只用了20行代码就拿了冠军