C++_MyList

main.cpp中

#include <iostream>
#include <string>
#include "List.h"
#include "node.h"

using namespace std;

void main()
{
	List<char *> cmdlist;
	cmdlist.add("china");

	cmdlist.show();

	cin.get();
}

 

node.h

#pragma once

template <class T>
class node
{
public:
	T t;	// 数据
	node *pNext;	// 指针域
};

List.h

#pragma once
#include "node.h"

using namespace std;

template <class T>
class List
{
public:
	node<T> *pHead;

public:
	List();
	void add(T t);	// 尾部插入
	void show();	// 显示
	node<T> * find(T t);//查找
	void change(node<T> *p, T newt);//修改
	int getnum();	// 获取个数
	bool deletet(T t);	// 删除
	void sort();	// 排序

	void deletesame();	// 删除相同的元素
	bool clear();	// 删除全部	
	void rev();	//逆转
	
	void insert(T oldt, T newt);
	
	void merge(List & list);

	~List();
};

list.cpp

#include "List.h"

template<class T>

List<T>::List()
{
	this->pHead = nullptr;	// 设置空节点
	cout << "链表创建" << endl;
}

template<class T>
List<T>::~List()
{
	cout << "链表销毁" << endl;
}

template<class T>
void List<T>::add(T t)
{
	node<T> *pnew = new node<T>;	// 分配节点
	pnew->t = t;	// 赋值
	pnew->pNext = nullptr;

	if (pHead == nullptr)
	{
		
		this->pHead = pnew;	// 头节点

	}
	else
	{
		node<T> *p = pHead;	// 获取头节点位置
		while (p->pNext != nullptr)	// 循环到尾部
		{
			p = p->pNext;
		}
		p->pNext = pnew;
	}
}

template<class T>
void List<T>::show()
{
	node<T> *p = pHead;	// 获取头节点位置
	while (p != nullptr)
	{
		cout << p->t << " ";
		p = p->pNext;

	}
	cout << endl;
}

template<class T>
node<T> * List<T>::find(T t)
{
	node<T> *p = pHead;	// 获取头节点位置
	while (p != nullptr)
	{
		if (p->t == t)
		{
			return p;
		}
		p = p->pNext;

	}
	return nullptr;
}

template<class T>
void List<T>::change(node<T> *p, T newt)
{
	if (p == nullptr)
	{
		return ;
	}

	p->t = newt;
}

template<class T>
int List<T>::getnum()
{
	int i = 0;
	node<T> *p = pHead;	// 获取头节点位置
	while (p != nullptr)
	{
		i++;
		p = p->pNext;
	}
	return i;
}

template<class T>
bool List<T>::deletet(T t)
{
	node<T> *p = this->find(t);
	if (p == nullptr)
	{
		return false;
	}
	else
	{
		if (p == pHead)
		{
			pHead = p->pNext;
			delete p;
		}
		else
		{
			node<T> *p1, *p2;
			p1 = pHead;
			p2 = p1->pNext;
			while (p2 != p)	//删除一个节点，获取前一个节点
			{
				p1 = p2;
				p2 = p2->pNext;

			}
			p1->pNext = p2->pNext;	//跳过P2
			delete p2;

		}
		return true;
		
	}
}

template<class T>
void List<T>::sort()
{
	for (node<T> *p1 = pHead; p1 != nullptr; p1 = p1->pNext)
	{
		for (node<T> *p2 = pHead; p2 != nullptr; p2 = p2->pNext)
		{
			if (p1->t < p2->t)
			{
				T temp;
				temp = p1->t;
				p1->t = p2->t;
				p2->t = temp;
			}
		}
	}
}

template<class T>
void List<T>::deletesame()
{
	node<T> *p1, *p2;
	p1 = pHead->pNext;
	p2 = pHead;
	while (p1 != nullptr)
	{
		if (p1->t == p2->t)
		{
			p2->pNext = p1->pNext;
			delete p1;
			p1 = p2->pNext;
		}
		else
		{
			p2 = p1;
			p1 = p1->pNext;
		}
	}

}

template<class T>
bool List<T>::clear()
{
	if (pHead == nullptr)
		return false;
	node<T> *p1, *p2;
	p1 = pHead->pNext;
	while (p1 != nullptr)
	{
		p2 = p1->pNext;
		delete p1;
		p1 = p2;
	}
	delete pHead;
	pHead = nullptr;

	return true;
}

// 链表逆转
template <class T>
void List<T>::rev()
{
	if (pHead == nullptr || pHead->pNext == nullptr)
		return ;
	else
	{
		node<T> *p1, *p2, *p3;
		p1 = pHead;
		p2 = p1->pNext;
		while (p2 != nullptr)
		{
			p3 = p2->pNext;
			p2->pNext = p1;

			p1 = p2;
			p2 = p3;
		}
		pHead->pNext = nullptr;
		pHead = p1;
	}
}

template <class T>
void List<T>::insert(T oldt, T newt)
{
	node<T> *p = find(oldt);
	if (p != nullptr)
	{
		node<T> *pnew = new node<T>;
		pnew->t = newt;
		pnew->pNext = p->pNext;
		p->pNext = pnew;
	}
	else
	{
		cout << "没有找到该数" << endl;
		return;
	}
}

template<class T>
void List<T>::merge(List & list)
{
	node<T> *p = pHead;	// 获取头节点位置
	while (p->pNext != nullptr)	// 循环到尾部
	{
		p = p->pNext;
	}
	p->pNext = list.pHead;
}