C++数据结构与算法笔记（2）

目录

一.什么是链表

二.链表的种类及实现

---

一.什么是链表

链表跟数组的相对的，可以把链表理解为不储存在连续内存的数组，有些人可能听说过链表有指针域跟数据域的说法，实际上，这只是链表的一种理解方式，没有错，链表的每个节点，数据存在数据域中，指向其他链表的（跟其他链表产生联系）指针存在指针域中。其实，当我们真正理解了链表之后，这种方式的理解在某种程度上就不是很确切了，因为当我们的数据存的是个指针呢？他是叫数据域还是指针域？这个时候我们需要重新审视一下链表这种数据结构，它本质上就是来存东西的，只不过它是分散的，不在连续的一块内存，那我们要怎么将它们联系在一起呢？用链子。这个链子的表现方式有很多种，可以是传引用，也可以是指针，都可以，只要能将它们连在一起就好。这个时候就不是所谓的指针域了。存的这些东西可以是任何东西，一个对象，一个指针，都可以，本质上就是来放东西的，没人限制你放什么。

二.链表的种类及实现

常见的有这几种：

那我们要怎么实现呢？其实很多东西都是相通的，能看懂一个，实现一个，其他的不在话下。

class MyList
{
public:
	struct Node
	{
		T data;
		Node* pNext;
		Node();
		Node(const T& data);
		Node(const Node& node);
		~Node();
	};
	MyList();
	//增加节点
	void push_front(const T& data);
	void push_back(const T& data);
	void insertBydata(const T& insertData, const T& findData);
	void insertBypos(const T& insertData, size_t pos);
	//删除节点
	void deleteByNode(Node* pDeleteNode);
	void deleteByData(const T& deleteData);
	void deleteByPos(size_t pos);
	//遍历
	void travel();
	~MyList();
private:
	Node* headNode;
	int size;
};

template<class T>
inline MyList<T>::Node::Node()
{
	pNext = nullptr;
}

template<class T>
inline MyList<T>::Node::Node(const T& data)
{
	this->data = data;
	this->pNext = nullptr;
}

template<class T>
inline MyList<T>::Node::Node(const Node& node)
{
	this->data = node.data;
	this->pNext = node.pNext;
}

template<class T>
inline MyList<T>::Node::~Node()
{
}

template<class T>
inline MyList<T>::MyList()
{
	headNode = new Node(-1);
	size = 0;
}

template<class T>
inline void MyList<T>::push_front(const T& data)
{
	Node* newNode = new Node(data);
	newNode->pNext = headNode->pNext;
	headNode->pNext = newNode;
	size++;
}

template<class T>
inline void MyList<T>::push_back(const T& data)
{
	Node* newNode = new Node(data);
	Node* pMove = headNode;
	while (pMove->pNext != nullptr)
	{
		pMove = pMove->pNext;
	}
	pMove->pNext = newNode;
	size++;
}

template<class T>
inline void MyList<T>::insertBydata(const T& insertData, const T& findData)
{
	Node* newNode = new Node(insertData);
	Node* pMove = headNode;
	while (pMove->pNext->data != findData )
	{
		pMove = pMove->pNext;
		if (pMove->pNext == nullptr) return;
	}
	
	newNode->pNext = pMove->pNext;
	pMove->pNext = newNode;
	size++;
}

template<class T>
inline void MyList<T>::insertBypos(const T& insertData, size_t pos)
{
	Node* newNode = new Node(insertData);
	if (pos >= size) return;
	Node* pMove = headNode;
	while (pos)
	{
		pMove = pMove->pNext;
		pos--;
	}
	newNode->pNext = pMove->pNext;
	pMove->pNext = newNode;
	size++;
}

template<class T>
inline void MyList<T>::deleteByNode(Node* pDeleteNode)
{
	Node* pMove = headNode;
	while (pMove->pNext != pDeleteNode)
	{
		pMove = pMove->pNext;
		if (pMove->pNext == nullptr) return;
	}
	Node* pDel = pMove->pNext;
	pMove->pNext = pDel->pNext;
	delete pDel;
	size--;
}

template<class T>
inline void MyList<T>::deleteByData(const T& deleteData)
{
	Node* pMove = headNode;
	while (pMove->pNext->data != deleteData)
	{
		pMove = pMove->pNext;
		if (pMove->pNext == nullptr) return;
	}
	Node* pDel = pMove->pNext;
	pMove->pNext = pDel->pNext;
	delete pDel;
	size--;
}

template<class T>
inline void MyList<T>::deleteByPos(size_t pos)
{
	if (headNode == nullptr) return;
	if (pos >= size) return;
	Node* pMove = headNode;
	while (pos)
	{
		pMove = pMove->pNext;
		pos--;
	}
	Node* pDel = pMove->pNext;
	pMove->pNext = pDel->pNext;
	delete pDel;
	size--;
}

template<class T>
inline void MyList<T>::travel()
{
	Node* pMove = headNode->pNext;
	while (pMove != nullptr)
	{
		cout << pMove->data << " ";
		pMove = pMove->pNext;
	}
	cout << endl;
}

template<class T>
inline MyList<T>::~MyList()
{
	Node* tempptr;
	while (headNode->pNext != NULL)
	{
		tempptr = headNode->pNext;
		delete headNode;
		headNode = tempptr;
	}
	delete headNode;
}