数据结构 单链表 C++模板

数据结构 单链表 C++模板

#pragma once
#include<iostream>

using namespace std;

template<class C>
class LinkNode
{
	C data;
	LinkNode* next;

public:
	LinkNode();
	LinkNode(const C& data);

	void setData(const C& data) { this->data = data; }
	C& getData() { return this->data; }
	void setNext(LinkNode* next) { this->next = next; }
	LinkNode* getNext()const { return this->next; }
};

template<class C>
LinkNode<C>::LinkNode()
{
	next = NULL;
}

template<class C>
LinkNode<C>::LinkNode(const C& data)
{
	next = NULL;
	this->data = data;
}



template<class C>
class LinkList
{
	LinkNode<C> head;
	int length;

	//搜索到指定位置
	LinkNode<C>* search(int index);
public:
	LinkList();
	~LinkList();
	int getLength()const { return length; }
	bool insert(const C& data, int index);
	bool insertFirst(const C& data);
	bool insertLast(const C& data);
	bool del(const int index);
	bool isEmpty()const { return length == 0 ? true : false; }
	void print()const;

	//根据数据查找对应下标，未找到返回-1
	int indexOf(const C& data);

	//根据下标查找数据
	C& valueOf(int index);

	//寻找目标元素，找到返回指针，未找到返回NULL
	C* find(C& data);
};

template<class C>
LinkList<C>::LinkList()
{
	head.setNext(NULL);
	length = 0;
}

template<class C>
LinkList<C>::~LinkList()
{
	LinkNode<C>* p = head.getNext();
	LinkNode<C>* q;
	while (p != NULL)
	{
		q = p->getNext();
		delete p;
		p = q;
	}
}

//搜索到指定位置
template<class C>
LinkNode<C>* LinkList<C>::search(int index)
{
	LinkNode<C>* p = &head;
	int count = 0;
	while (p && count < index)
	{
		p = p->getNext();
		count++;
	}
	if (!p || count > index)
		return NULL;
	return p;
}

template<class C>
bool LinkList<C>::insert(const C& data, int index)
{
	if (index > getLength() + 1 || index < 1)
		return false;
	LinkNode<C>* p = search(index - 1);
	if (!p)
		return false;
	LinkNode<C>* s = new LinkNode<C>(data);
	s->setNext(p->getNext());
	p->setNext(s);
	length++;
	return true;
}

template<class C>
bool LinkList<C>::del(int index)
{
	if (isEmpty())
		return false;
	if (index > getLength() || index < 1)
		return false;
	LinkNode<C>* p = search(index - 1);
	if (!p)
		return false;
	LinkNode<C>* q = p->getNext();
	p->setNext(p->getNext()->getNext());
	length--;
	delete q;
	return true;
}

template<class C>
void LinkList<C>::print()const
{
	if (isEmpty())
		cout << "LinkList is NULL";
	LinkNode<C>* p = head.getNext();
	while (p)
	{
		cout << p->getData() << endl;
		p = p->getNext();
	}
	cout << endl;
}

//根据数据查找对应下标，未找到返回-1
template<class C>
int LinkList<C>::indexOf(const C& data)
{
	LinkNode<C>* p = head.getNext();
	int index = 1;
	if (!p)
		return -1;
	while (p)
	{
		if (p->getData() == data)
			return index;
		p = p->getNext();
		index++;
	}
	return -1;
}

//寻找目标元素，找到返回指针，未找到返回NULL
template<class C>
C* LinkList<C>::find(C& data)
{
	LinkNode<C>* p = head.getNext();
	int index = 1;
	if (!p)
		return NULL;
	while (p)
	{
		if (p->getData() == data)
			return &p->getData();
		p = p->getNext();
		index++;
	}
	return NULL;
}

//根据下标查找数据
template<class C>
C& LinkList<C>::valueOf(int index)
{
	LinkNode<C>* p = search(index);
	if (!p)
		exit(-1);
	return p->getData();
}

template<class C>
bool LinkList<C>::insertFirst(const C& data)
{
	if (insert(data, 1))
		return true;
	return false;
}

template<class C>
bool LinkList<C>::insertLast(const C& data)
{
	if (insert(data, length + 1))
		return true;
	return false;
}