线性表--单链表（2）

链表程序设计（链式存储的顺序表）单链表

在内存中随机存储，需要通过指针建立数据元素之间的逻辑结构

实现 - 节点定义  相关概念
typedef int data_t;
typedef struct node{
	data_t data;  //保存数据
	struct node *next;   //保存下一个节点的地址
}link_node_t;

//带头结点 - 第一个节点不存储数据   （用的多）
//不带头结点    单向链表 - 最后一个节点的指针域为NULL


创建空链表 - 带头结点的
1、定义头结点，在堆上分配空间
2、初始化头结点，给指针域赋值
//创建空链表
link_node_t *create_link_list(void)
{
	//定义头结点，在堆上分配空间
	link_node_t *h = NULL;
	h = (link_node_t *)malloc(sizeof(link_node_t));
	if(h == NULL){
		printf("create_link_list malloc error\n");
		return NULL;
	}
	//初始化头结点，给指针域赋值
	h->next = NULL;
	return h;
}

插入一个节点 - 首插法 - 在头结点后面插入一个节点
特点 - 先插入的数据会放到链表的最后面

新建一个节点，分配空间，保存要插入的数据元素
	建立新的连接

//插入一个节点 - 首插法 - 在头结点后面插入一个节点
int insert_frist(link_node_t *h, data_t x)
{
	//新建一个节点，保存要插入的数据元素
	link_node_t *new = (link_node_t *)malloc(sizeof(link_node_t));
	if(new == NULL){
		printf("insert_frist malloc failed\n");
		return -1;
	}
	new->data = x;
	//建立新的连接
	new->next = h->next;
	h->next = new;
	return 0;
}

插入一个节点 – 尾插法 - 在链表的最后面插入一个节点
特点 - 先插入的数据在链表的前面

	新建一个节点，分配空间，保存要插入的数据元素
	遍历链表，找到最后一个节点
	建立新的连接

//在链表的最后面进行插入 - 尾插法
int insert_last(link_node_t *h, data_t x){
	link_node_t *p = h;
	//新建一个节点，分配空间，保存要插入的数据元素
	link_node_t *new = (link_node_t *)malloc(sizeof(link_node_t));
	if(new == NULL){
		printf("insert_last malloc failed\n");
		return -1;
	}
	new->data = x;
	//遍历链表，找到最后一个节点
	while(p->next != NULL){
		//判断p的指针域的值是否为NULL，如果为NULL说明是最后一个节点
		//如果不为NULL，接着判断p的下一个节点
		p = p->next;
	}
	//建立新的连接
	p->next = new;
	new->next = NULL;
	return 0;
}

求链表的长度 - 有效节点个数
//求链表的有效元素的个数
int length_link_list(link_node_t *h)
{
	int len = 0;
	h = h->next;
	while(h != NULL){
		len++;
		h = h->next;
	}
	return len;
}

插入数据 - 在任意位置插入数据

判断pos是否有效 -    1  -  链表+1
	新建节点，存储数据
	遍历链表，找到要插入位置的前一个节点
	建立新的连接，连接的步骤和头插法一样
	
//插入数据 - 在任意位置插入数据
int insert_any_pos(link_node_t *h, data_t x, int pos){
	int i;
	link_node_t *p = h;
	//判断pos是否有效 - 1-链表+1
	if(pos<1 || pos >length_link_list(h)+1){
		printf("insert_any_pos pos error\n");
		return -1;
	}
	//新建节点，存储数据
	link_node_t *new = (link_node_t *)malloc(sizeof(link_node_t));
	if(new == NULL){
		printf("insert_any_pos malloc error\n");
		return -1;
	}
	new->data = x;
	//遍历链表，找到要插入位置的前一个节点
	for(i=1; i<=pos-1; i++){
		p = p->next;
	}
	//建立新的连接，连接的步骤和头插法一样
	new->next = p->next;
	p->next = new;
	return 0;
}

删除链表中最后一个节点

判断链表是否为空链表
	保存要删除的节点，头结点的下一个
	建立新的连接，给头结点的指针域重新赋值
	释放要删除的节点

//删除一个节点 - 删除链表中第一个节点
int delete_frist_node(link_node_t *h)
{
	//判断链表是否为空链表
	if(h->next == NULL){
		printf("link_list is NULL\n");
		return -1;
	}
	//保存要删除的节点，头结点的下一个
	link_node_t *p = h->next;
	//建立新的连接，给头结点的指针域重新赋值
	h->next = p->next;
	//释放要删除的节点
	free(p);
	return 0;
}

删除链表中最后一个节点
判断链表是否为空链表
	遍历链表，找到链表中倒数第二个节点
	释放最后一个节点
	给倒数第二个节点的指针域重新赋值为NULL

//删除链表中最后一个节点
int delete_last_node(link_node_t *h){
	link_node_t *p = h;
	//判断链表是否为空链表
	if(h->next == NULL){
		printf("link_list is NULL\n");
		return -1;
	}
	//遍历链表，找到链表中倒数第二个节点
	while(p->next->next != NULL){
		p = p->next;
	}
	//释放最后一个节点
	free(p->next);
	//给倒数第二个节点的指针域重新赋值为NULL
	p->next = NULL;
	return 0;
}

删除链表中任意位置的节点
对位置判断 1 - 表的长度
	判断链表是否为空链表
	遍历链表，找到要删除位置的前一个节点
	保存要删除的节点
	建立新的连接
	释放要删除的节点

int delete_any_node(link_node_t *h, int pos){
	int i;
	link_node_t *p = NULL;
	//对位置判断 1 - 表的长度
	if(pos<1 || pos>length_link_list(h)){
		printf("delete_any_node pos error\n");
		return -1;
	}
	//判断链表是否为空链表
	if(h->next == NULL){
		printf("link_list is NULL\n");
		return -1;
	}
	//遍历链表，找到要删除位置的前一个节点
	for(i=1; i<=pos-1; i++){
		h = h->next;
	}
	//保存要删除的节点
	p = h->next;
	//建立新的连接
	h->next = p->next;
	//释放要删除的节点
	free(p);
	return 0;
}

修改表中的元素 （根据位置修改元素的值）
		1. 根据位置修改元素的值
		判断位置是否有效 1-表的长度
		遍历表，找到修改的位置上的节点
		修改数据域的值

//修改表中的元素
//1. 根据位置修改元素的值
int update_pos_data(link_node_t *h, int pos, data_t x){
	int i;
	//判断位置是否有效 1-表的长度
	if(pos<1 || pos>length_link_list(h)){
		printf("update_pos_data pos error\n");
		return -1;
	}
	//遍历表，找到修改的位置上的节点
	for(i=1; i<=pos; i++){
		h = h->next;
	}
	//修改数据域的值
	h->data = x;
	
	return 0;
}

修改表中的元素 （根据数据项修改元素的值）
	2. 根据数据项修改元素
		遍历链表，根据要修改的数据项的值，找到要修改节点
		修改该节点的元素的值
	
//2. 根据数据项修改元素
int update_data(link_node_t *h, data_t odd, data_t new){
	h = h->next;
	//遍历链表，根据要修改的数据项的值，找到要修改节点
	while(h != NULL){
		if(h->data == odd){
			h->data = new;
			return 0;
		}
		h = h->next;
	}
	printf("not found data is %d\n", odd);
	return -1;

遍历链表 - 将链表中所有的值打印出来
void print_link_list(link_node_t *h)
{
	//从第一有效节点开始遍历
	h = h->next;
	while(h != NULL){
		printf("%d ", h->data);
		h = h->next;
	}
	printf("\n");
}

链表的倒序
int rever_link_list(link_node_t *h)
{
	link_node_t *p = h->next;
	link_node_t *q = NULL;
	
	h->next = NULL;
	//p代表的是要进行头插的节点    以此向后便利每一个节点都是用P插入进去 p不断后移  用来记录原来的链表尚未完成倒序的部分
	while(p != NULL){
		q = p->next;
		p->next = h->next;
		h->next = p;
		p = q;
	}	
	return 0;
}

链表的合并 - 有序的
int fun(link_node_t *h1, link_node_t *h2)
{
	//p遍历第一个链表，q遍历第二个链表，t是保存新链表的最后一个节点
	link_node_t *p = h1->next;
	link_node_t *q = h2->next;
	link_node_t *t = h1;
	
	//遍历两个链表，直到其中一个链表遍历完
	while((p != NULL)&&(q != NULL)){
		//对p节点和q节点的数据域进行比较
		//1. p节点的数据域比较小
		if(p->data <= q->data){
			t->next = p;
			p = p->next;
		}
		//2. q节点的数据域比较小
		else{
			t->next = q;
			q = q->next;
		}
		t = t->next;
	}
	//判断是哪一个链表先遍历完，将剩下一个链表中的所有节点连接到新链表的末尾
	if(p == NULL){
		t->next = q;
	}else{
		t->next = p;
	}
	return 0;
}