数据结构--3.2链表

注意：

• 表头和头结点的区别，个人理解表头的元素因为没用到所以可不初始化
• 清空链表是仍保留链表的头结点，此时L！= NULL;而销毁链表是整个链表为空，L==NULL
• 表头指针和链表指针同时指向链表所在的内存，使用时要注意，尤其delete时。

名词：前驱元，后继元，数据域，指针域；存放A1,A2,....An，有效数据下标从1开始
与数组的区别：链表存储非连续（避免插入和删除的线性开销），数组连续
实现方式：
单向链表：标准实现方式，最简单的链表，用一个头指针指向第一个元素A1
双链表：可以倒序扫描，简化了删除操作，不用使用指向前驱元的指针了。
循环链表：去除头指针，让双链表的尾元指针指向第一个元素A1。（最常用）
应用：
表示一元多项式；多项式的每一项含在一个单元中，单元以次数递减的顺序排列

typedef struct Node
{
    int Coefficient;
    int Exponent;
    Node* Next;
} *List,*Head;

在某些特殊情况下以线性时间排序（基数排序(卡式排序)，桶式排序的推广）：从低位到高位进行多趟排序。

第一趟，个位排序

0	1	512	343	64	125	216	27	8	729
0	1	2	3	4	5	6	7	8	9

第二趟，十位排序

8 1 0	216 512	729 27 125		343		64
0	1	2	3	4	5	6	7	8	9

第三趟，百位排序

64 27 8 1 0	125	216	343		512		729
0	1	2	3	4	5	6	7	8	9

用于大学的课程注册：有40000名学生和2500门课程的大学需要生成两种类型的报告，第一个列出每个班的注册者，第二个列出每个学生注册的班级即课程。
方法一：利用二维数组，数组将有1亿项，因为一个学生平均注册3门，有意义的数据只有12000项，大约占0.1%，浪费；
方法二：每一个班级（表头）和对应的学生们组成一个循环链表，每一个学生（表头）和注册的课程们组成一个循环链表。
单向链表的实现代码：可直接运行

#include <iostream>
using namespace std;

typedef struct ListNode
{
	int m_element;
	ListNode* m_pNextNode;
} *List,*Node;

List CreatList();
bool IsEmpty(List l);
List MakeEmpty(List l);
void InsertNode(List l, int num, int insNum);//前插到num
void DeleteNode(List l, int delNode);
void Traverse(List L);
Node FindPrevious(List l, int num);
Node isFind(List L, int num);
//删除、插入、遍历
int main() 
{
	char key;
	int num = 0;
	List L = CreatList();
	Traverse(L);
	cout << "输入查找数字：";
	cin >> num;
	Node numPos = isFind(L, num);
	if (numPos)
		cout << "查找成功，位置;" << numPos << endl;
	else
		cout << "没有" << endl;
	cout << "输入删除的数字：";
	cin >> num;
	DeleteNode(L, num);
	cout << "删除后的链表：" << endl;
	Traverse(L);

	cout << "在谁前面插入以及插入的数字（重复不处理）：" << endl;
	cin >> num;
	int insNum = 0;
	cin >> insNum;
	InsertNode(L, num, insNum);
	cout << "插入后的链表：" << endl;
	Traverse(L);

	cout << "输入c让链表置空:" << endl;
	cin >> key;

	if (key == 'c' || key == 'C')
		L = MakeEmpty(L);
	if (IsEmpty(L))
		cout << "置空成功" << endl;

	system("pause");
	return 0;
}

List CreatList()
{
	//带表头的空链表
	List pHead = new ListNode;
	List L = pHead;
	L->m_pNextNode = nullptr;
	int val = 0;
	cout << "Input data(-999 to quit) to creat List:" << endl;
	while (1)
	{
		cin >> val;
		if (val == -999)
			break;
		if (isFind(pHead, val))
			continue;
		ListNode* newNode = new ListNode;
		newNode->m_element = val;
		newNode->m_pNextNode = nullptr;
		L->m_pNextNode = newNode;
		L = L->m_pNextNode;//更新位置
	}
	return pHead;
}

bool IsEmpty(List L)
{
	L = L->m_pNextNode;
	if (L == nullptr)
		return true;
	else
		return false;
}
//清空链表，但仍保留头结点
List MakeEmpty(List l)
{
	List pHead = l;
	l = l->m_pNextNode;
	while(!IsEmpty(l))//链表非空
	{
		List nodeTmp = new ListNode;
		nodeTmp = l;
		pHead = l->m_pNextNode;
		l = l->m_pNextNode;
		delete nodeTmp;
	}
	return pHead;
}

void InsertNode(List l, int num, int insNum)//前插
{
	Node nodePos = isFind(l, num);
	Node preNumNode = FindPrevious(l, num);
	Node newNode = new ListNode;

	newNode->m_element = insNum;
	newNode->m_pNextNode = nodePos;

	preNumNode->m_pNextNode = newNode;

	//delete nodePos;
	//delete preNumNode;
}

void DeleteNode(List l, int num)
{
	Node preDelNode = FindPrevious(l, num);
	if (preDelNode)
	{
		Node numPos = preDelNode->m_pNextNode;
		if (numPos->m_pNextNode != NULL)
		{
			Node tmp = numPos->m_pNextNode;
			preDelNode->m_pNextNode = tmp;
			delete numPos;
		}
		else
			preDelNode->m_pNextNode = nullptr;
	}
	else
		cout << "没有要删除的元素,无需删除" << endl;
}

void Traverse(List L)
{
	cout << "顺序遍历结果：";
	L = L->m_pNextNode;
	while (L != nullptr)
	{
		cout << L->m_element << " ";
		L = L->m_pNextNode;
	}
	cout << endl;
}

Node FindPrevious(List l, int num)
{
	Node preNumNode = new ListNode;
	Node numPos = isFind(l, num);
	preNumNode = l;//有可能返回头结点
	l = l->m_pNextNode;
	if (numPos)
	{
		while (l->m_element != num && l->m_pNextNode != nullptr)
		{
			preNumNode = l;
			l = l->m_pNextNode;
		}
		return preNumNode;
	}
	else
		return nullptr;
}

Node isFind(List L, int num)
{
	L = L->m_pNextNode;
	while (L != nullptr)
	{
		if (L->m_element == num)
			return L;
		L = L->m_pNextNode;
	}
	return nullptr;
}