数据结构——链表

链表定义

链表：用于存储逻辑关系为“一对一”的数据。把若干的对象用指针串联起来。
特点：链表不限制数据的物理存储状态，通俗点讲，使用链表存储的数据元素，它的物理存储位置是随机的。这就导致一个问题，位置随机的数据怎么访问？为了解决这个问题，链表中的每个数据元素存储时，都配备了一个指针，指向与自己相邻的后边的元素。
为了更清晰的描述链表数据元素之间的逻辑关系：每个位置除了保存想要的数据，同时还要保存下一个元素的位置，并且末尾元素的位置设为NULL（作为结束的标志）这样，我们就可以根据链表的第一个元素顺次访问到它之后的所有元素，并在遇到NULL时结束。

特征

1. 链表的实现：必须在struct中添加一个指针作为成员，该指针指向一个对象。如果该指针为NULL，表示它是最后一个对象。
2. 链表的特征：我们用链表头来代表一个链表。仅仅需要一个链表头，就能够访问所有穿起来的对象
3. 链表尾：指链表中的最后一个对象，它的next必须设为空指针NULL，否则链表无法判断是否结束。

链表的演示

Student *student=&ss[0];

5. 链表的遍历：通过当前元素的指针得到下一个对象。

用struct语法定义一个类型。用student来存储一个学生的学号和姓名：

struct Student
{
	int id;//定义int型变量id表示学号
	char name[16];//定义char型变量name表示姓名
	//添加成员变量*next，用于指向链表中的下一个对象
	Student *next;//等价于Student *next：定义Student型指针next;
};

补充：对于Student *next的理解，其实质就是一个指针变量(类似 int *pt)，指针就是一个整数，即在结构体中包含一个整形的成员。此处的唯一的特别之处就是，数据类型为自定义的结构Student；其他并无区别，这也是链表定义的核心部分。注意与Student next的区别。
构建一个简单的链表：
第一步：

//使用全局变量，定义一个长度为4的数组，数据类型为Student
Student ss[4] =
{
	{201801,"Allen",0},
	{201802,"Balen",0},
	{201803,"Cansa",0},
	{201804,"Danne",0},
};

第二步：以上独立的对象，通过指针串起来

//链表的构造
	ss[0].next = &ss[1];
	ss[1].next = &ss[2];
	ss[2].next = &ss[3];
	ss[3].next = 0;

通过一二步，就完成了一个链表的构造。

• 将元素串起来的原因，我们只需要知道“链表头”就可以访问到链表的每一个对象。
• 实现的方法：从链表头开始，依次访问，使用next指针来访问下一个对象。

链表的遍历

通过一个简单的while循环，就可以遍历整个链表。

Student *p=&ss[0];     //首先定义指针p指向第一个对象ss[0];
	while (p)
	{
		printf("ID:%d,name:%s\n", p->id, p->name);//打印结果;
		p=p->next;         //指向下一个对象;      
	}

链表的常见操作

• 查找链表中的对象

//定义链表中的对象
//输入：参数一：链表的第一个对象（链表头），参数二：要查找学生的学号
//输出：
Student* find(Student* head, int id)
{
	Student* p = head;
	while (p)//while循环遍历链表
	{
		if (p->id==id)//符合条件
			return p;//返回对象的指针

		p = p->next;//不符合，遍历下一个元素
	}
	return NULL;
}

完整的代码：

#include<stdio.h>
#include<string>
struct Student
{
	int id;//定义int型变量id表示学号
	char name[16];//定义char型变量name表示姓名
	//添加成员变量*next，用于指向链表中的下一个对象
	Student *next;//等价于Student *next：定义Student型指针next;
};

//使用全局变量
Student ss[4] =
{
	{201801,"Allen",0},
	{201802,"Balen",0},
	{201803,"Cansa",0},
	{201804,"Danne",0},
};

///定义链表中的对象
//输入：参数一：链表的第一个对象（链表头），参数二：要查找的id
//输出：
Student* find(Student* head, int id)
{
	Student* p = head;
	while (p)//while循环遍历链表
	{
		if (p->id==id)//符合条件
			return p;//返回对象的指针

		p = p->next;//不符合，遍历下一个元素

	}
	return NULL;
}
int main()
{
	//链表的构造
	//此处是方便理解，实际使用链表时，并不知道要存储数据的大小和数量，是需要动态输入的
	ss[0].next = &ss[1];
	ss[1].next = &ss[2];
	ss[2].next = &ss[3];
	ss[3].next = 0;

	//链表的遍历
	//仅仅需要知道链表头（就能代表整个链表），就可以使用next指针访问下一个对象，直到结尾完成对链表的遍历
	Student *p=&ss[0];     //首先定义指针p指向第一个对象ss[0];
	while (p)
	{
		printf("ID:%d,name:%s\n", p->id, p->name);//打印结果;
		p=p->next;         //指向下一个对象;      
	}

	//查找链表中的对象
	Student* result = find(&ss[0], 201802);
	printf("ID:%d,name:%s\n", result->id, result->name);//打印结果;
	return 0;
}

链表的种类

问题：一个链表，当由N个对象穿起来时，使用第一个对象来指代整个链表。此时，可以向链表中添加对象，也可以删除对象。
思考一个特殊情况：如果链表中删除了所有对象，这个链表该怎么表示，也即是说，链表中有0个对象。该怎么表示这个链表？
上边问题引出了链表的两种表示方法：

• 无头链表：所有的节点都包含有效数据。
• 有头链表：用一个固定的头节点来指代整个链表，所有的对象那挂在这个头节点的后面，而头节点本身不包含有效数据。相当于坝头结点特殊化。
  使用固定的有头表头（很容易表示对象个数为0的情况）

定义虚拟头节点

只需定义一个对象作为头节点，将其成员next初始化为NULL;
Student m_head={0，“head”，NULL}
或者是写作：
Student m_head={0}；
当有对象加入时，直接加在它的后面就可以，但它的next为NULL时，表示该链表一个对象也没有。也就是说，头节点本身只用于挂接，本身是不算作长度的。

向链表中插入对象

有两种方式：
1.挂在到链表的头部
链表头->obj->x->y->z

//插入对象到链表中(头部)
void add1(Student* obj)
{
	obj->next = m_head.next;//
	m_head.next = obj;
}

2.将对象添加到链表的末尾
需要遍历链表，找到最后一个对象，将对象挂在该对象之后。

//插入对象到链表中(尾部)
void add2(Student* obj)
{
	Student* p=&m_head;

	while (p->next)
		p = p->next;  //找到最后一个对象

	p->next = obj;    //把obj挂到最后一个对象后面
	obj->next = NULL; //现在obj作为最后一个对象
}

链表的对象从哪来

链表中的对象，一般都是动态创建的，否则若已经知道有多少个对象，直接就用数组了。
注意：动态创建的对象的生命期，自malloc之时生效，到free之后失效。

//动态创建一个对象obj_2
Student* obj_2 =(Student*)malloc(sizeof(Student));
obj_2->id = 2;//为对象赋值
strcpy_s(obj_2->name, "Y");//为对象赋值
add1(obj_2);//将对象加入到链表中

完整的程序：
动态输入创建链表：

#include<stdio.h>
#include<string>
#include<stdlib.h>
//定义节点
struct Student
{
	int id;
	char name[16];
	Student* next;
};

//定义一个有头链表
Student m_head = {0};

//插入对象到链表中(头部)
void add1(Student* obj)
{
	obj->next = m_head.next;//
	m_head.next = obj;
}

//插入对象到链表中(尾部)
void add2(Student* obj)
{
	Student* p=&m_head;

	while (p->next)
		p = p->next;  //找到最后一个对象

	p->next = obj;    //把obj挂到最后一个对象后面
	obj->next = NULL; //现在obj作为最后一个对象
}

//用户输入数据
//返回值：0个成功；-1表示用户输入有误
int user_input(Student *obj)
{
	printf("学号： ");
	scanf_s("%d", &obj->id);
	printf("姓名： ");
	scanf("%s", obj->name);
	return 0;
}

int main()
{
	while (1)
	{
		Student* obj_1 = (Student*)malloc(sizeof(Student));
		if (user_input(obj_1) == 0)
		{
			add1(obj_1);
		}
		else
		{
			free(obj_1);
		}
		printf("AAA\n");
		delete obj_1;
	}
	return 0;
}

有头链表的遍历

在遍历有头链表时，不包含头结点本身

void show_all()
{
Student *p=m_head.next;
while(p)
{
printf("ID:%d,name:%s\n",p->id,p->name);
p=p->next;//下一个对象