数据结构（list、vector、queue、stack C++实现）
最近在复习数据结构的内容，模仿了stl中的list、vector、queue和stack.当然是精简版的了，只写了最基本的功能。
这里要注意一点，模板类的类声明和定义要在同一个文件内，最好是在头文件内。因为模板类和模板函数在使用的时候才会被实例化，所以编译器需要知道所有的实现代码，然后去实例化各种数据类型的类或者函数。所以如果把类定义放在单独的源文件中的话，编译器找不到相关定义。
list
代码如下，这里实现的是双向循环链表
// list头文件
#pragma once
#include * m_tailNode;
public:
// 获取元素值
T getElement(unsigned int index) const;
// 获取头节点值
T get_front() const;
// 获取尾节点值
T get_back() const;
// 插入元素
bool insert(unsigned int index, T elem);
// 插入首位
bool insert_front(T elem);
// 在尾部插入
bool insert_back(T elem);
// 设置某个位置的值
bool setValue(unsigned int index, T value);
// 删除某个节点并返回该节点的值
T deleteElement(unsigned int index);
// 删除头节点，返回该节点的值
T delete_front();
// 删除尾节点并返回该节点的值
T delete_back();
// 删除所有节点
void deleteAll();
// 获取链表长度
unsigned int getLength() const;
// 链表是否为空
bool empty() const;
};
template<typename T>
list * pnode = m_tailNode;
while (n++ <= index)
{
pnode = pnode->next;
}
temp = pnode->data;
}
else
{
unsigned int n = m_nLength - 1;
node * pnode = m_tailNode;
while (n-- > index)
{
pnode = pnode->pre;
}
temp = pnode->data;
}
return temp;
}
template<typename T>
T list * pnode = new node;
if (nullptr == pnode)
{
throw (std::exception("内存分配出错!"));
}
m_tailNode = pnode;
pnode->data = elem;
pnode->next = m_tailNode;
pnode->pre = m_tailNode;
}
else if (0u == index)// 插入第一位置
{
node * pnode = new node;
pnode->data = elem;
pnode->next = m_tailNode->next;
m_tailNode->next = pnode;
pnode->pre = m_tailNode;
pnode->next->pre = pnode;
}
else if (m_nLength == index)// 插入尾部
{
node * pnode = new node;
pnode->data = elem;
pnode->next = m_tailNode->next;
m_tailNode->next = pnode;
pnode->pre = m_tailNode;
pnode->next->pre = pnode;
m_tailNode = pnode;
}
else if (index <= m_nLength / 2)
{
node * pnode = m_tailNode;
unsigned int n = 0u;
while (n++ < index)// 定位到index上一个节点
{
pnode = pnode->next;
}
// 插入节点
node * pnodeElem = new node;
pnodeElem->data = elem;
pnodeElem->next = pnode->next;
pnode->next = pnodeElem;
pnodeElem->pre = pnode;
pnodeElem->next->pre = pnodeElem;
}
else
{
node * pnode = m_tailNode;
unsigned int n = m_nLength - 1;
while (--n > index )// 定位到index上一个节点
{
pnode = pnode->pre;
}
node * pnodeElem = new node;
pnodeElem->data = elem;
pnodeElem->pre = pnode->pre;
pnode->pre = pnodeElem;
pnodeElem->next = pnode;
pnodeElem->pre->next = pnodeElem;
}
// 长度增加
m_nLength++;
return true;
}
template<typename T>
bool list * pnode = m_tailNode;
while (n++ <= index)
{
pnode = pnode->next;
}
pnode->data = value;
}
else
{
unsigned int n = m_nLength - 1;
node * pnode = m_tailNode;
while (n-- > index)
{
pnode = pnode->pre;
}
pnode->data = value;
}
return true;
}
template<typename T>
T list * pnode;
pnode = m_tailNode->next;
m_tailNode->next = pnode->next;
pnode->next->pre = m_tailNode;
temp = pnode->data;
}
else if (m_nLength - 1 == index)// 删除尾部
{
node * pnode;
m_tailNode->pre->next = m_tailNode->next;
m_tailNode->next->pre = m_tailNode->pre;
pnode = m_tailNode;
m_tailNode = m_tailNode->pre;
temp = pnode->data;
delete pnode;
}
else if (index <= m_nLength / 2)
{
node * pnode = m_tailNode;
unsigned int n = 0u;
while (n++ < index)// 定位到index上一个节点
{
pnode = pnode->next;
}
// 删除节点
node * pnodeElem;
pnodeElem = pnode->next;
pnode->next = pnodeElem->next;
pnodeElem->next->pre = pnode;
temp = pnodeElem->data;
delete pnodeElem;
}
else
{
node * pnode = m_tailNode;
unsigned int n = m_nLength - 1;
while (--n > index)// 定位到index上一个节点
{
pnode = pnode->pre;
}
node * pnodeElem;
pnodeElem = pnode->pre;
pnodeElem->pre->next = pnode;
pnode->pre = pnodeElem->pre;
temp = pnode->data;
delete pnodeElem;
}
m_nLength--;
return temp;
}
template<typename T>
T list 测试代码如下：
#include "list.h"
#include 测试结果如下：
vector
实现代码：
// vector头文件
#pragma once
template<typename T>
class vector
{
public:
vector();
virtual ~vector();
vector(const vector测试代码如下：
#include "vector.h"
#include 测试结果如下：
queue
实现代码如下：
// queue头文件
#pragma once
template <typename T, template <typename N> class C>
class queue
{
public:
queue();
~queue();
queue(const queue * m_data;
public:
bool insert_back(T value);
T delete_front();
T get_front() const;
T getElement(unsigned int index) const;
unsigned int getLength() const;
bool empty() const;
};
template<typename T, template <typename N> class C>
queue;
}
template<typename T, template<typename N> class C>
queue;
unsigned int n = ob.m_data->getLength();
for (unsigned int i = 0u; i < n; i++)
{
m_data->insert_back(ob.m_data->getElement(i));
}
}
template<typename T, template<typename N> class C>
queue;
unsigned int n = ob.m_data->getLength();
for (unsigned int i = 0u; i < n; i++)
{
m_data->insert_back(ob.m_data->getElement(i));
}
return * this;
}
template<typename T, template<typename N> class C>
queue 测试代码如下：
#include "list.h"
#include "vector.h"
#include "queue.h"
#include 测试结果如下；
stack
实现代码如下：
// stack头文件
#pragma once
template <typename T, template <typename N> class C>
class stack
{
public:
stack();
~stack();
stack(const stack * m_data;
public:
bool insert_front(T value);
T delete_front();
T get_front() const;
bool empty() const;
};
template <typename T, template<typename N> class C>
stack;
}
template <typename T, template<typename N> class C>
stack;
unsigned int n = ob.m_data->getLength();
for (unsigned int i = 0u; i < n; i++)
{
m_data->insert_back(ob.m_data->getElement(i));
}
}
template <typename T, template<typename N> class C>
stack;
unsigned int n = ob.m_data->getLength();
for (unsigned int i = 0u; i < n; i++)
{
m_data->insert_back(ob.m_data->getElement(i));
}
return * this;
}
template <typename T, template<typename N> class C>
stack 测试代码如下:
#include "list.h"
#include "vector.h"
#include "stack.h"
#include 测试结果如下：
