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个结点,求链表的中间结点。