关于线性表

线性表类模板：

template < class T >
class List
{y
	void clear();		//线性表置空
	bool isEmpty();		//线性表为空时，返回true
	bool append(const T value);	//在表尾添加一个元素value，表的长度增1
	bool insert(const int p, const T value);
						//在位置p上插入一个元素value，表的长度增1
	bool delete(const int p);	//删除位置p上的元素value，表的长度减1
	bool getPos(int & p, const T value);
						//查找值为value的元素并返回其位置
	bool getValue(const int p, T& value);
						//把位置p上的元素值返回到变量value中
	bool setValue(const int p, const T value);	
						//用value修改位置p的元素值
};

顺序表类定义

class arrList :public List <T>
{
private:
	T *aList;
	int maxSize;
	int curLen;
	int postion;
public:
	arrList(const int size)
	{
		maxSize = size;
		aList = new T[maxSize];
		curLen = postion = 0;
	}
	~arrList()
	{
		delete[] aList;
	}
	void clear()
	{
		delete[] aList;
		curLen = postion = 0;
		aList = new T[maxSize];
	}
	int length();
	bool append(const T value);	//在表尾添加一个元素value，表的长度增1
	bool insert(const int p, const T value);
	//在位置p上插入一个元素value，表的长度增1
	bool delete(const int p);	//删除位置p上的元素value，表的长度减1
	bool getPos(int & p, const T value);
	//查找值为value的元素并返回其位置
	bool getValue(const int p, T& value);
	//把位置p上的元素值返回到变量value中
	bool setValue(const int p, const T value);
	//用value修改位置p的元素值
};

顺序表的插入算法

//设元素的类型为T，aList是存储顺序表的数组，maxSize是其最大长度
//p是新元素value的插入位置，插入成功则返回true，否则返回false
template <class T> bool arrList<T>::insert(const int p, const T value)
{
	int i;
	if (curLen >= maxSize)
	{
		cout << "The List is overflow" << endl;
		return false;
	}
	if (p < 0 || p > curLen)
	{
		cout << "Insertion point is illegal" << endl;
		return false;
	}
	for (i = curLen; i > p; i--)
		aList[i] = aList[i - 1];
	aList[p] = value;
	curLen++;
	return true;
}

顺序表的删除算法

template <class T>
bool arrList<T>::delete(const int p)
{
	int i;
	if (curLen <= 0)
	{
		cout << "No element to delete \n" << endl;
		return false;
	}
	if (p < 0 || p > curLen - 1)
	{
		cout << "deletion is illegal \n" << endl;
		return false;
	}
	for (i = p; i < curLen - 1; i++)
		arrList[i] = arrList[i + 1];
	curLen--;
	return true;
}

单链表的节点定义

template<class T>
class Link
{
public: 
	T data;	//用于保存节点元素的内容
	Link<T> *next;	//指向后继节点的指针
	Link(const T info, const Link<T>* nextValue = NULL)
	{
		data = info;
		next = nextValue;
	}
	Link(const Link<T>* nextValue)
	{
		next = nextValue;
	}
};

 

单链表定义

template<class T>
class lnkList : public List<T>
{
private:
	Link<T> *head, *tail;
	Link<T> *setPos(const int p);
public:
	lnkList(int s);
	~lnkList();
	void clear();		//线性表置空
	bool isEmpty();		//线性表为空时，返回true
	bool append(const T value);	//在表尾添加一个元素value，表的长度增1
	bool insert(const int p, const T value);
	//在位置p上插入一个元素value，表的长度增1
	bool delete(const int p);	//删除位置p上的元素value，表的长度减1
	bool getPos(int & p, const T value);
	//查找值为value的元素并返回其位置
	bool getValue(const int p, T& value);
	//把位置p上的元素值返回到变量value中
	bool setValue(const int p, const T value);
	//用value修改位置p的元素值
};

查找单链表中的第i个节点

//函数返回值是找到的节点指针
template<class T>
Link<T> *lnkList<T>::setPos(int i)
{
	int count = 0;
	if (i == -1)
		return head;
	Link<T> *p = new Link<T>(head->next);
	while (p != NULL && count < i)
	{
		p = p->next;
		count++;
	}
	return p;
}

单链表删除算法

template<class T>
bool lnkList::delete(const int i)
{
	Link<T> *p, *q;
	if ((p = setPos(i - 1)) == NULL || p == tail)
	{
		cout << "非法删除点" << endl;
		return false;
	}
	q = p->next;
	if (q == tail)
	{
		tail = p;
		p->next = NULL;
		delete q;
	}
	else if (q != NULL)
	{
		p->next = q->next;
		delete q;
	}
	return true;
}