简单的顺序存储节构
template<class T>
class MyList
{//顺序存储结构
private:
int m_length; //数组长度
int m_Max; //数组最大上限
T * m_element; //元素
public:
MyList(int max = 10)
{//构造函数
m_length = 0;
m_Max = max;
m_element = new T[max];
}
~MyList()
{//析构函数
delete[] m_element;
}
public: //属性
//当前长度
int Length() const { return m_length; }
//是否为空
bool IsEmpty() const { return m_length == 0; }
//是否满
bool IsFull() const { return m_length == m_Max; }
public: //方法
int Add(T & x)
{//在尾部增加
if (IsFull())
{//如果满了, 添加失败
return -1;
}
m_element[m_length] = x;
return m_length++;
}
bool Remove(const T & x)
{//通过元素删
int index = Search(x);
if (index == -1)
{//如果元素不存在, 删除失败
return false;
}
return RemoveAt(index);
}
bool RemoveAt(int index)
{//通过下标删
if (index >= m_length || index < 0)
{//当给定下标超出范围, 删除失败
return false;
}
for (int i = index, n = m_length; i < n; i++)
{//将给定下标后的元素前移
m_element[i] = m_element[i + 1];
}
m_length--; //减少当前长度
return true;
}
int Insert(int index, const T & x)
{//在指定位置插入
if (index < 0 || index > m_Max)
{//index如果超出正确取值范围, 插入失败
return -1;
}
if (IsFull())
{//数组满了, 插入失败
return -1;
}
for (int i = m_length - 1, n = index; i >= n; i--)
{//从最后元素开始后移
m_element[i + 1] = m_element[i];
}
m_element[index] = x; //插入元素
m_length++; //长度加1
return index;
}
T & operator[](int index)
{//查找元素
return m_element[index];
}
int Search(const T& x) const
{//给定元素, 查找下标
for (int i = 0, n = m_length; i < n; i++)
{
if (m_element[i] == x)
{
return i;
}
}
return -1;
}
};
链式存储节构
template<class T>
class LinkList;
template<class T>
class LinkNode
{//节点
T value; //值
LinkNode<T> * next; //下一节点
friend LinkList<T>;
};
template<class T>
class LinkList
{//链式存储结构
private:
LinkNode<T> * first; //头节点
int m_len; //链表长度
public: //构造
LinkList()
{//构造函数
first = 0;
m_len = 0;
}
~LinkList()
{//析构函数
LinkNode<T> * temp;
while (first)
{//当前节点不为空时, 释放当前节点空间
temp = first; //next指向first
first = first->next; //first指向下一节点
delete temp; //释放next
}
}
public: //属性
//连表是否为空
bool IsEmpty() const { return first == 0; }
//当前链表长度
int Length() const { return m_len; }
public: //方法
int Insert(int index, const T & x)
{//在指定信置添加
if (index < 0 || index > m_len)
{//超出范围
return -1;
}
LinkNode<T> * node = new LinkNode<T>;
node->value = x;
if (!index)
{//下标为0,
if (IsEmpty())
{//链表为空
node->next = NULL;
first = node;
}
else
{//链表不为空
LinkNode<T> * current = first;
node->next = current;
first = node;
}
}
else
{//下标不为0
LinkNode<T> * pnext = first;
LinkNode<T> * ppre = pnext;
for (int i = 0; i != index; i++)
{
ppre = pnext;
pnext = pnext->next;
}
ppre->next = node;
node->next = pnext;
}
m_len++;
return index;
}
bool RemoveAt(int index)
{//通过下标删除
if (index <0 || index >= m_len)
{//超出范围
return false;
}
LinkNode<T> * current = first;
if (!index)
{//删除头节点
first = first->next;
}
else
{//删除非头节点
LinkNode<T> * ppre = current;
for (int i = 0; i != index; i++)
{
ppre = current;
current = current->next;
}
ppre->next = current->next;
}
m_len--;
delete current;
return true;
}
bool Remove(const T & x)
{//通过给定元素删除
LinkNode<T> * current = first;
int index = Search(x);
if (index == -1)
{
return false;
}
return RemoveAt(index);
}
int Search(const T & x) const
{//给定元素找下标
int index = 0;
LinkNode<T> * current = first;
while (current)
{
if (x == current->value)
{
return index;
}
current = current->next;
index++;
}
return -1;
}
T & operator[](int index)
{//给定下标找元素
if (index <0 || index >m_len)
{//超出取值范围
throw "excption";
}
LinkNode<T> * current = first;
for (int i = 0; i != index; i++)
{
current = current->next;
}
return current->value;
}
};