数据结构 2.1 单链表

1.单链表
线性表：1.有限的序列 2.序列中的每一个元素都有唯一的前驱和后继，除了开头和结尾的两个节点。

顺序表：分配一块连续的内存去存放这些元素，eg、数组

链表：内存是不连续的，元素会各自被分配一块内存，内存和内存之间用指针进行相连。

顺序表和链表的区别是内存的连续与否

 data域 | next指针域 ——> data域 | next指针域 ——> data域 | next指针域 ——> NULL

单链表的操作：
1.增加 ：1>头插法 2>尾插法
1>插入——> data域 | next指针域 ——> data域 | next指针域 ——> data域 | next指针域 ——> NULL
2>data域 | next指针域 ——> data域 | next指针域 ——> data域 | next指针域 ——> 插入——>NULL
2.删除：用前一个节点的指针直接指向对应节点的后一个节点的前驱，只操作一个指针。
为了使操作方便，在操作中添加一个头节点。头节点并不实际存储，只保存链表中的元素个数。
代码实现：

定义一个链表（结构体）：

typedef struct Node {//定义一个结构体链表
	int data;//data域
	struct Node* next;//next指针
}Node;

初始化一个链表：

Node* initList() {//初始化一个链表
	Node* list = (Node*)malloc(sizeof(Node));//给新节点开辟空间
	list->data = 0;//data域
	list->next = NULL;//next指针
	return list;
}

头插法：

void headInsert(Node* list,int data){//头插法 list是头节点 data域
	Node* node = (Node*)malloc(sizeof(Node));//开辟空间，定义一个新节点
	node->data = data;//新节点的data域
	node->next = list->next;//新节点的next指针等于原先链表的头指针的next
	list->next = node;//原先头节点next指向新插入的头节点
	list->data++;//代表当前链表之中插入元素
}

尾插法：

void tailInsert(Node* list, int data){//尾插法
	Node* head = list;//头指针为定义的list头节点
	Node* node = (Node*)malloc(sizeof(Node));//定义新节点，开辟空间
	node->data = data;//新节点的data域等于原先链表头节点的data域 
	node->next = NULL;//尾插的新节点next为空
	list = list->next;//原先头节点往后延续
	while (list->next) {//判断是否到了最后
		list = list->next;
	}
	list->next = node;//先将头节点指针指向最后 头节点的下一个等于新插入的node节点
	head->data++;
}

删除：

void Delete(Node* list, int data){//删除
	Node* head = list;
	Node* pre = list;
	Node* current = list->next;
	list = list->next;
	while (current)//循环遍历到最后
	{
		if (current->data == data)//判断与删除元素是否相等
		{
			pre->next = current->next;
			free(current);//删除结点
			break;//找到则跳出循环
		}
		pre = current;//向下遍历
		current = current->next;
	}
	list->data--;
}

遍历操作：

void printList(Node* list) {//遍历操作
	list = list->next;//向后遍历
	while (list)//判空循环
	{
		printf("%d ", list->data);
		list = list->next;
	}
	printf("\n");
}

main函数：

int main()
{
	Node* list = initList();
	headInsert(list, 1);
	headInsert(list, 2);
	headInsert(list, 3);
	headInsert(list, 4);
	headInsert(list, 5);
	tailInsert(list, 6);
	tailInsert(list, 7);
	tailInsert(list, 8);
	tailInsert(list, 9);
	tailInsert(list, 10);
	printList(list);
	Delete(list, 5);
	printList(list);
	Delete(list, 10);
	printList(list);
	Delete(list, 6);
	printList(list);
	return 0;
}

整体函数：

typedef struct Node {//定义一个结构体
	int data;
	struct Node* next;
}Node;

Node* initList() {//初始化一个链表
	Node* list = (Node*)malloc(sizeof(Node));
	list->data = 0;
	list->next = NULL;
	return list;
}

void headInsert(Node* list,int data){//头插法
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = list->next;
	list->next = node;
	list->data++;//代表当前链表之中插入元素
}

void tailInsert(Node* list, int data){//尾插法
	Node* head = list;
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	list = list->next;
	while (list->next) {
		list = list->next;
	}
	list->next = node;
	head->data++;
}

void Delete(Node* list, int data){//删除
	Node* head = list;
	Node* pre = list;
	Node* current = list->next;
	list = list->next;
	while (current)
	{
		if (current->data == data)
		{
			pre->next = current->next;
			free(current);
			break;
		}
		pre = current;
		current = current->next;
	}
	list->data--;
}

void printList(Node* list) {//遍历操作
	list = list->next;
	while (list)
	{
		printf("%d ", list->data);
		list = list->next;
	}
	printf("\n");
}

int main()
{
	Node* list = initList();
	headInsert(list, 1);
	headInsert(list, 2);
	headInsert(list, 3);
	headInsert(list, 4);
	headInsert(list, 5);
	tailInsert(list, 6);
	tailInsert(list, 7);
	tailInsert(list, 8);
	tailInsert(list, 9);
	tailInsert(list, 10);
	printList(list);
	Delete(list, 5);
	printList(list);
	Delete(list, 10);
	printList(list);
	Delete(list, 6);
	printList(list);
	return 0;
}

运行结果：