数据结构-线性表的一些基础操作 c++代码

//线性表的顺序存储结构
template <class T>
class Linearlist
{
	public:
		Linearlist(int MaxListSize == 10);
		~Linearlist()
		{
			delete []element;
		}

		bool IsEmpty() const
		{
			return length == 0;
		}
		bool IsFull() const
		{
			return length == MaxSize;
		}
		int Length() const
		{
			return length;
		}

		bool Find(int k, T &item) const;
		int search(const T &item) const;
		void Delete(int k, T &item);
		void Insert(int k, const T &item);
	private:
		int MaxSize, length, T *element;
};

template <class T>
Linearlist<T>::Linearlist(int MaxListSize == 10)
{
	MaxSize = MaxListSize;
	element = new T[MaxSize];   //申请规模为MaxSize的数组空间
	length = 0;                // 初始时没有真正的表结点，故表长度为0
}

//存取：将下标为k的结点的字段值赋给item并返回true,若不存在则返回false;
template <class T>
bool Linearlist<T>::Find(int k, T &item)  const
{
	if (k < 0 || length == 0 || k >length-1)
	{
		cout << " unreasonable position or empty list!" << endl;
		return false;
	}
	else
	{
		item = element[k];
		return true;
	}
}

//查找：在表中查找字段值为item的结点并返回其下标；若表中没有item，则返回-1；
template <class T>
int Linearlist<T>::search(const T &item) const
{
	for (int k = 0; k <= length-1; k++)
	{
		if(element[k] == item)
			return k;
	}
	return -1;
}

//删除表中下表为k的结点并将其值赋给item
template <class T>
void Linearlist<T>::Delete(int k, T &item)
{
	if (find(k, item))   //若找到下标为k的结点，则将其后面所有结点均向前移动一个位置
	{
		for (int i=k; i<length; i++)
		{
			element[i] = element[i+1];
		}
		item = element[k];
		length--;
	}
}

//在下表为k的结点后插入item
template <class T>
void Linearlist<T>::Insert(int k, const T &item)
{
	if(IsFull())                   //若表已满，无法插入新结点
	{
		cout << "The list is full!" << endl;
		exit(1);
	}
	else if (k<0 || k>length-1)
	{
		cout << "The node does not exist!" << endl;
		exit(1);
	}
	else
	{
		for (i=length-1; i>=k+1; i--)
		{
			element[i+1] = element[i];
		}
	}
	element[k+1] = item;
	length++;
}

//单链表结点结构SLNode
template<class T>
struct SLNode
{
	T data;                      //数据域
	SLNode<T> *next;             //指针域

	SLNode(SLNode *nextNode = NULL)
	{
		next = nextNode;
	}

	SLNode(const T &item, SLNode *nextNode = NULL)
	{
		data = item;
		next = nextNode;
	}
};

// SLNode 的定义参考博文数据结构-栈的一些基础操作c++代码
//单链表的链式存储结构
template <class T>
class SLList
{
	public:
		SLList(){	head = new SLNode<T>()};   //构造函数，构造一个只有哨位结点的空表
		SLList(T &item);                       //构造函数
		~SLList();
		bool IsEmpty() const {return head->next == NULL;};
		int length() const;
//		bool Find(int k, T &item) const;
		int Search(const T &item) const;
		void Delete(int k, T &item);
		void Insert(int k, const T &item);
	private:
		SLNode<T> *head;
		SLNode<T> *tail;
		SLNode<T> *currptr;
};

//单链表的构造函数，生成一个只有哨位结点的空表
template<class T>
SLList<T>::SLList()
{
	head = tail = currptr = new SLNode<T>();
	size = 0;
}

//单链表的构造函数，生成含有哨位结点和一个表结点的表
template<class T>
SLList<T>::SLList(T &item)
{
	tail = currptr = new SLNode<T>(item);         //生成一个表结点
	head = new SLNode<T>(currptr);               //生成哨位结点
	size = 1;
}

//单链表的析构函数
template <class T>
SLList<T>::~SLList()
{
	while (!IsEmpty())
	{
		currptr =  head->next;
		head->next = currptr->next;
		delete currptr;
	}
	delete head;
}

//算法Insert
//在当前结点后插入一个data域值为item的结点
template <class T>
void SLList<T>::Insert(const T &item)
{
	currptr->next = new SLNode<T>(item, currptr->next);
	if (tail == currptr)
		tail = currptr->next;
	size++;
}

//在表尾插入一个data域值为item的结点
template <class T>
void SLList<T>::InsertFromTail(const T &item)
{
	tail->next = new SLNode<T>(item, NULL);
	tail = tail->next;
	size++;
}

//在哨位结点后插入
template <class T>
void SLList<T>::InsertFromHead(const T &item)
{
	if(IsEmpty())
	{
		head->next = new SLNode<T>(item, head->next);
		tail = head->next;
	}
	else
	{
		head->next = new SLNode<T>(item, head->next);
	}
	size++;
}

//算法Delete
//删除当前结点的后继结点并将其data值返回给变量de_item

template <class T>
bool SLList<T>::Delete(T &de_item)
{
	if(currptr == tail || IsEmpty())
	{
		cout << "No next node or empty list!";
		return false;
	}
	SLNode<T> *temp = currptr->next;
	currptr->next = temp->next;
	size--;
	de_item = temp->data;

	if(temp == tail)
		tail = currptr;
	delete temp;
	return true;
}

// 删除哨位结点后的第一个真正表结点并将其data值返回给变量de_item
template <class T>
bool SLList<T>::DeleteFromHead(T &de_item)
{
	if (IsEmpty())
	{
		cout << "Empty list!";
		return false;
	}

	SLNode<T> *temp = head->next;
	head->next = temp->next;
	size--;
	de_item = temp->data;
	if (temp == tail)
	{
		tail = head;
	}
	delete temp;
	return true;
}

//删除表尾结点并将其data值返回给变量de_item

template <class T>
bool SLList<T>::DeleteFromTail(T &de_item)
{
	if (IsEmpty())
	{
		cout << "Empty list!";
		return false;
	}
	//令当前指针指向表尾结点的前驱结点
	SetEnd();
	Prev();
	de_item = tail->data;
	currptr->next = NULL;
	size--;
	delete tail;
	tail = currptr;
	return true;
}