数据结构——链表及链表功能实现

链表

• 将线性表L=(a0,a1,……,an-1)中各元素分布在存储器的不同存储块，称为结点，通过地址或指针建立元素之间的联系。
• 链表为线性表的一种

---

线性表的链式 存储结构

• 结点的data域存放数据元素ai，而next域是一个指针，指向ai的直接后继ai+1所在的结点。
  

• 带头结点的单链表：
  

• 结点类型描述：

typedef   struct  node
 {   
 data_t   data;   //结点的数据域//
 struct node *next;  //结点的后继指针域//
}listnode, *linklist; 

举例

1.设p指向链表中结点ai

• 通过指针访问结构体成员用‘‘->’’
• 获取ai，写作：p->data；
• 而取ai+1,写作：p->next->data
• 注意：若指针p的值为NULL，则它不指向任何结点, 此时取p->data或p->next是错误的，将产生段错误。

2.可调用C语言中malloc()函数向系统申请结点的存储空间

linklist  p; 
p = (linklist)malloc(sizeof(listnode));//强制类型转换

则创建一个类型为linklist的结点，该结点的地址已存入指针变量p中，且存储空间由栈转到堆中

链表基本运算的相关算法

链表创建

• 举例：
  依次读入表L=(a0,…,an-1)中每一元素ai(假设为整型)，若ai≠结束符（-1），则为ai创建一结点，然后插入表尾，最后返回链表的头结点指针H。
  设L=(2，4，8，-1)，则建表过程如下：
  
  链表的结构是动态形成的，即算法运行前，表结构是不存在的

实现创建链表代码

linklist list_create(){
	linklist H;

	H = (linklist)malloc(sizeof(listnode));
	if (H == NULL){
		printf("malloc failed\n");
		return H;
	}

	H->data = 0;
	H->next = NULL;

	return H;
}
// H--head

链表遍历

• 将链表中的数据打印在终端上

链表遍历实现代码

int list_show(linklist H){
	linklist p;

	if(H == NULL){
		printf("H is NULL\n");
	}

	p = H;
	while(p->next != NULL){
		printf("%d ",p->next->data);
		p = p->next;
	}
	puts("");
	return 0;
}

获取链表中数据位置

• 即实现linklist list_get(linklist H,int pos)，在链表中找到位置为pos的数据，并作为函数返回值返回。
• 算法思路：通过循环访问成员变量，赋值给linklist list_get函数内部变量，再将内部变量返回即可。

获取位置实现代码

linklist list_get(linklist H,int pos){
	linklist p;
	int i;
	if (H == NULL){
		printf("H is NULL\n");
		return NULL;
	}

	if(pos == -1){
		return H;
	}
	
	if(pos < -1){
		printf("pos is invalid\n");
		return NULL;
	}
	p = H;
	i = -1;
	while(i < pos){
		p = p->next;
		if(p == NULL){
			printf("pos is invalid\n");
			break;
		}
		i++;
	}
	
	return p;
}

链表插入

尾部插入

• 链表的尾部插入，即实现list_tail_insert(linklist H,data_t value)。将value插入到已定义链表linklist H的尾部。
• 算法思路：1.建立一个新节点。（^1 malloc新节点 ^2对其进行赋值）2.找到链表linklist H的尾节点。3.完成尾部插入。

链表尾插实现代码

int list_tail_insert(linklist H,data_t value){
	linklist p;
	linklist q;
	if(H == NULL){
		printf("H is empty");
		return-1;
	}
	//1.new node
	if((p = (linklist)malloc(sizeof(listnode))) == NULL){
		printf("malloc failed\n");
		return -1;
	}
	p->data = value;
	p->next = NULL;

	//2.locate tail node
	q = H;
	while(q->next != NULL){
		q = q->next;
	}
	
	//3.insert
	q->next = p;

	return 0;
}

按位置插入

• 即实现list_insert(linklist H,data_t value,int pos)。将data_t value插入表中结点int pos之前的情况。
• 算法思路：调用算法list_get(linklist H,int pos)，获取结点pos的指针p(int pos的前驱)，然后申请一个q结点，存入linklist H，并将其插入p指向的结点之后。
  

链表按位置插入实现代码

int list_insert(linklist H,data_t value,int pos){
	linklist p;
	linklist q;
	
	if(H == NULL){
		printf("H is NULL");
	}
	//1. locate node p(pos-1)
	p = list_get(H,pos-1);
	if(p ==NULL){
		return -1;
	}
	//2. new node q
	if((q = (linklist)malloc(sizeof(listnode))) == NULL){
			printf("malloc failed\n");
			return -1;
	}
	q->data = value;
	q->next = NULL;

	//3. insert p->q
	q->next = p->next;
	p->next = q;
	return 0;
}

链表查找

按序号查找

• 即实现list_get(linklist H,int pos)运算。
• 算法思路：从链表的a0起，判断是否为第pos结点，若是则返回该结点的指针，否则查找下一结点,依次类推。

链表按位置插入实现代码

linklist list_get(linklist H,int pos){
	linklist p;
	int i;
	if (H == NULL){
		printf("H is NULL\n");
		return NULL;
	}

	if(pos == -1){
		return H;
	}
	
	if(pos < -1){
		printf("pos is invalid\n");
		return NULL;
	}
	p = H;
	i = -1;
	while(i < pos){
		p = p->next;
		if(p == NULL){
			printf("pos is invalid\n");
			break;
		}
		i++;
	}
	
	return p;
}

链表的删除

按位置删除

• 即实现int list_delete(linklist H,int pos)， 算法对应的链表结构如图所示。
  
• 算法思路：同插入法，先调用函数list_get(linklist H,int pos),找到结点pos的前驱，然后将结点pos删除之。

链表按位置删除实现代码

int list_delete(linklist H,int pos){
	linklist p;
	linklist q;
	if(H == NULL){
		printf("H is NULL");
		return -1;
	}
	p = list_get(H,pos-1);
	if(p == NULL)
		return-1;
	if(p->next == NULL){
		printf("delete pos is invalid");
		puts("");
		return -1;
	}
	
	q = p->next;
	p->next = q->next;

	printf("free:%d\n",q->data);
	free(q);
	q = NULL;

	return 0;
}

链表的释放

• 程序结束后将链表所申请的空间释放
• 算法思路：通过free（）函数与循环结合，依次释放链表中的数据。

链表释放实现代码

linklist list_free(linklist H){
	linklist p;
	
	if(H == NULL)
		return NULL;

	p = H;

	printf("free:");
	while(H != NULL){
		p = H;
		printf("%d ",p->data);
		H = H->next;
		free(p);
	}
	puts("");

	return NULL;
}

链表复杂操作实现

单链表的反转

• 设计算法，将单链表H倒置
• 算法思路：依次取原链表中各节点，将其作为新链表首尾结点插入H结点之后，如图所示。

单链表反转实现代码

int list_reverse(linklist H){
	linklist p;
	linklist q;

	if (H == NULL){
		printf("H is NULL\n");
		return -1;
	}

	if (H->next == NULL||H->next->next == NULL){
		return 0;	
	}
	
	p = H->next->next;
	H->next->next = NULL;
	
	while(p != NULL){
	q = p;
	p = p->next;
	
	q->next = H->next;
	H->next = q;
	}
	return 0;
}

链表中求相邻两个结点最大值

• 设结点data域为整型，求链表中相邻两结点data值之和为最大的第一结点的指针。
• 算法思路：设p,q 分别为链表中相邻两结点指针，求p->data+q->data为最大的那一组值，返回其相应的指针p即可。

求相邻两个结点最大值实现代码

linklist list_adjmax(linklist H,data_t *value){
	linklist q;
	linklist p;
	linklist r;
	data_t sum;
	if(H == NULL){
		printf("H is NULL\n");
		return NULL;
	}
	if(H->next == NULL || H->next->next == NULL || H->next->next->next == NULL){
		return H;
	}

	q = H->next;
	p = H->next->next;
	r = q;
	sum = q->data + p->data;
	
	while(p->next == NULL){
		p = p->next;
		q = q->next;
		if(sum < q->data + p->data){
			sum = q->data + p->data;
			r = q;
		}
	}
	*value = sum;
	return r;
}

有序链表合并

• 设两单链表A、B按data值（设为整型）递增有序，将表A和B合并成一表A，且表A也按data值递增有序。
• 算法思路：设指针p、q分别指向表A和B中的结点，若p->data ≤q->data则p结点进入结果表，否则q结点进入结果表。
  

有序链表合并实现代码

int list_merge(linklist H1,linklist H2){
	linklist p,q,r;
	if(H1 == NULL || H2 == NULL){
		printf("H1 || H2 is NULL\n");
		return -1;
	}

	p = H1->next;
	q = H2->next;
	r = H1;
	H1->next = NULL;
	H2->next = NULL;

	while(q && p){
		if (p->data <= q->data){
			r->next = p;
			p = p->next;
			r = r->next;
			r->next = NULL;

		}else{
			r->next = q;
			q = q->next;
			r = r->next;
			r->next = NULL;
		}
	

	}
	
	if(p == NULL){
		r->next = q;
	}else{
		r->next = p;
	}



	return 0;
}

写在最后

• 此篇文章对链表功能实现方式为“自定义头文件函数声明文件‘linklist.h’ + 函数功能实现文件’linklist.c’ + 测试文件’test.c’”
• 附上截图