数据结构之单链表

Platform：ubuntu , C Language

在一个项目中，数据结构使用的类型不会很多，并且结构一旦稳定，基本都很少对其改动。所以对于我个人而言，数据结构很少用到，但又及其重要。当前的项目使用的是队列，但究其根本，也只不过是操作受限的链表。从简单的单链表开始，做一知识点的整理。如有不足，还请指教！

链表（Linked list）

          链表是通过指针将一组零散的内存块串联在一起。其中，我们把内存块称为链表的“结点”。为了能将所有的结点串起来，每个链表的结点除了存储数据外，还需要记录链表上的下一个结点地址。如下图所示，我们把这个记录下个结点的指针叫作后继指针next。其中有2个结点是比较特殊的，分别是第一个结点（头结点）和最后一个结点（尾结点），头结点记录链表基地址，尾结点指向一个空地址（NULL)。

          相比数组，链表是一中稍微复杂一点的数据结构，也是非常基础、常用的数据结构。

        数组需要一块连续的内存空间来存储，对内存的要求比较高，如果我们申请一个100MB大小的数组，当内存中没有连续的、足够大的存储空间时，即便内存的剩余总可用空间大于100MB，仍会申请失败。（由此拓展malloc等内存函数也是分配连续性的内存空间）。

        而链表恰恰相反，它并不需要一块连续的内存空间，它通过“指针”将一组零散的内存串联起来使用，所以如果我们申请的是100MB大小的链表，根本不会有问题。

       与数组一样，链表也支持数据的查找、插入和删除操作。在数组中，插入、删除操作时，为了保持内存数据的连续性，需要做大量的数据搬移，所以时间复杂度为O(n)。而对于链表，由于存储空间不是连续的，只需要考虑相邻结点的指针改变，所以复杂度为O(1)。

       但是，链表要想访问第k个元素，就没有数组那么高效了，因为链表中的数据并非连续存储的，所以无法像数组一样，根据首地址和下标，通过寻址公式就能直接计算出对应的内存地址，而是根据指针一个结点一个结点的依次遍历，直到找到相应的结点。可以把链表想象成一个队伍，队伍中每个人只知道自己后面的人是谁，所以当我们希望知道排在第k位人是谁，我们就需要从第一个人开始，一个个往下数。所以链表随机访问的性能没有数组好，需要O(n)的时间复杂度。

链表步骤

       1.构建节点的结构（ListNode）；

       2.创建头结点(head)；

       3.数据操作：插入，删除，遍历操作；

/*****************************************************
*	@FileName 		:	list.c
*	@Creator		:	Donkey
*	@Date 			:	2019-02-13
*	@Description	        :	单向链表实现
*	@Api			:	主要的几个接口
		.init_list 	:	初始化链表
		.insert_list    :	插入数据
		.remove_list    :	删除数据
		.clear_list	:	清除链表
		.Display 	:	遍历链表
******************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define Debug() printf("[%d %s]\n",__LINE__,__FUNCTION__)
#define DATATYPE int

/* 节点结构 ： 根据需求设计数据结构 */
typedef struct node
{
	DATATYPE data;
	struct node * next;	
}ListNode;

/* 初始化 */
int init_list(ListNode *head)
{
	Debug();
	head = (ListNode *)malloc(sizeof(ListNode));
	if(NULL == head)
	{
		printf("malloc failed!\n");
		return 1;
	}
	head->next = NULL;
	return 0;
}
/* 插入 */
int insert_list(ListNode *head,int n)
{
	Debug();

	ListNode * p = head;
	ListNode *d = (ListNode *)malloc(sizeof(ListNode));
	d->data = n;
	d->next = NULL;

	while(p->next != NULL)
	{
		p = p->next;
	}

	p->next = d;
	return 0;
}
/* 删除 */
int remove_list(ListNode * head,int n)
{
	Debug();
	if(NULL == head)
	{
		printf("list is Null\n");
		return 1;
	}
	int flag = 0;
	if(NULL == head)
	{
		printf("list is Null\n");
		return 1;
	}
	ListNode * p = head;
	ListNode * q = head;

	while(p->next != NULL)
	{
		printf("data = %d \n",p->next->data);
		if(p->next->data == n)
		{
			//delete
			flag = 1;
			q = p->next;
			p->next = p->next->next;
			free(q);
			break;
		}
		p = p->next;
	}

	if(flag == 0)
		return 1;

	return 0;
}
/* 清除 */
int clear_list(ListNode *head)
{
	Debug();
	if(NULL == head)
	{
		printf("list is Null\n");
		return 1;
	}
	ListNode *p = head,*q = head;
	p->next = head->next;
	while(p->next != NULL)
	{
		q = p->next;
		p->next = q->next;
		free(q);
	}
	free(p);
	return 0;
}
/* 遍历打印 */
int Display(ListNode *head)
{
	Debug();
	if(NULL == head->next)
	{
		printf("list is Null\n");
		return 0;
	}
	ListNode *p = head;
	p = p->next;

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

int main(int argc, char const *argv[])
{
	Debug();
	int ret = 0;//return value
	/* init */
	ListNode * test = (ListNode *)malloc(sizeof(ListNode));
	if(NULL == test)
	{
		printf("malloc failed !\n");
		return 1;
	}

	if((ret = init_list(test)) == 1)
	{
		printf("init list failed!\n");
		return 1;
	}
	
	if((ret = insert_list(test,1)) == 1)
	{
		printf("insert list failed!\n");
		return 1;
	}
	if((ret = insert_list(test,10)) == 1)
	{
		printf("insert list failed!\n");
		return 1;
	}
	if((ret = insert_list(test,100)) == 1)
	{
		printf("insert list failed!\n");
		return 1;
	}
	if((ret = insert_list(test,1000)) == 1)
	{
		printf("insert list failed!\n");
		return 1;
	}
	if((ret = insert_list(test,10000)) == 1)
	{
		printf("insert list failed!\n");
		return 1;
	}

	if((ret = Display(test)) == 1)
	{
		printf("Display list failed!\n");
		return 1;
	}
	
	if((ret = remove_list(test,10)) == 1)
	{
		printf("remove list failed!\n");
		return 1;
	}

	if((ret = Display(test)) == 1)
	{
		printf("Display list failed!\n");
		return 1;
	}

	if((ret = clear_list(test)) == 1)
	{
		printf("clear list failed!\n");
		return 1;
	}

	if((ret = Display(test)) == 1)
	{
		printf("Display list failed!\n");
		return 1;
	}
	Debug();

	return 0;
}

执行结果

 

 

补充

1.关于上述涉及到访问数组时，可以根据下标高效的获取地址。

从数组存储的内存模型上来看，“下标”最确切的定义应该是“偏移（offset）”。如果用a来表示数组的首地址，a[0]就是偏移为0的位置，也就是首地址，a[k]就表示偏移k个type_size的位置，所以计算a[k]的内存地址只需要用公式：

a[k]_address = base_address + k * type_size;

可参考文章：https://blog.csdn.net/localhostcom/article/details/86358593

2.技巧

      1）理解指针或引用的含义

                将某个变量赋值给指针，实际上就是将这个变量的地址赋值给指针，或者反过来说，指针中存储了这个变量的内存地址，指向了这个变量，通过指针就能找到这个变量。

       2）警惕指针的丢失和内存泄漏

                  C语言内存管理是由程序员负责的，如果没有手动释放结点对应的空间，就会产生泄漏，所以我们插入结点时，一定要注意操作的顺序。

       3）利用哨兵简化实现的难度

                 哨兵解决的是国家之间的边界问题，同理这里说的也是解决“边界问题”，不直接参与业务逻辑。我们引用哨兵结点，在任何时候，不管链表是否为空，head指针都会一直指向这个哨兵结点。我们也把这有哨兵结点的链表叫带头链表。相反，没有哨兵结点的链表就叫做不带头链表。

                  哨兵结点是不存储数据的，因为该结点一直存在，所以插入第一个节点和插入其它结点，删除最后一个结点和删除其它结点，都可以统一为相同的代码实现逻辑。

        4）重点留意边界条件处理

                        1>链表为空时，代码是否能正常工作？

                        2>链表只包含一个结点时，代码能否正常工作？

                        3>链表只包含2个结点时，代码能否正常工作？

                        4>代码逻辑在处理头结点和尾结点时，是否能正常工作？

                        5> and so on....

          5）举例画图，辅助思考

             6）多写多练，没有捷径

                    可以5个常见的操作练手：单链表反转，链表中环的检测，两个有序的链表合并，删除链表倒数第n个结点，求链表的中间结点。