硬核！三千字肝了一晚上的数据结构线性表最全总结，超详细！

已同步微信公众号：

乐享Coding

期待你的关注！

前言

提到数据结构，可能会有很多人马上联想到栈，队列，树，哈希表，图等各种经常提到的数据结构，但是我们去忽略了本质，这些都是抽象的逻辑结构，追本溯源，数据结构中的存储方式只有两种：数组(顺序存储)和链表(链式存储)，而上述我们所提到的多样化的数据结构，都是在数组或链表上的一系列特殊操作。

今天我们提到的线性表可以通过数组或链表来实现，致于到底选哪个实现，根据不同的需求而定，二者并没有好坏之分，适合的才是最好的。本篇文章将详细叙述C语言用数组和链表的方式来实现线性表这种数据结构。从而理解顺序存储与链式存储的区别，可能大家比较疑惑为什么实现数据结构都是用c语言，还是那句话，语言不是关键，思想才最重要，而且像Java中已经自带了集合类，ArrayList和LinkedList，还有特殊的线性表如Stack类，直接去看源码即可，

线性表：零个或多个数据元素的有限序列。

抽象数据类型定义

ADT 线性表
Data 
	线性表的数据对象集合为{a1,a2,......an},每个元素的类型均为DataType。其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。
Operation
	InitList(*L);  初始化操作
	ListEmpty(L);  返回值True和False，判断线性表是否为空
	ClearList(*L); 清空线性表
	GetElem(L,i,*e); 将线性表L中的第i个位置元素值返回给e。
	LocateElem(L,e); 在线性表L中查找与给定值e相等的元素，如果查找成功，返回该元素在表中序号表示成功，否则，返回0表示失败。
	ListInsert(*L,i,e);在线性表中的第i个位置插入新元素e。
	ListDelete(*L,i,*e);删除线性表L中的第i个位置，并用e返回其值。
	ListLength(L);返回线性表L的元素个数。
endADT

Tips：大多数数据结构，其实我们可以发现增删改查是很必要的操作。改的操作其实也可理解为插入+删除！

顺序存储结构(数组)

线性表的顺序存储结构，就是在内存中找了块地，通过占位的形式，把一定内存空间给占了，然后把相同数据类型的数据元素依次存放在这块空地中。可以采用C语言的一维数组实现顺序存储结构。

为了减少性能上的损耗，这里我们不采用动态数组的方式，所以应该保证任意时刻，线性表的长度应该小于数组的长度。

结构代码

#define MAXSIZE 20		//储存空间分配初始量
typedef int ElemType;  		//假设为int类型
typedef struct
{
    ElemType data[MAXSIZE];		//数组存储数据元素，最大值为MAXSIZE
    int length;		//线性表当前的长度
}cList;

三个属性：

• 数组data：存储空间的存储位置
• 线性表最大存储量：数组长度MAXSIZE；
• 线性表当前长度：length

定义函数类型Status，其值是函数结果的状态码

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status;         /* Status是函数的类型,其值是函数结果状态代码，如OK等 */

获得元素操作

思路分析：因为数组有下标，只需插入的元素在数组的下标范围内，把数组[插入元素位置-1]下标的值返回即可。

时间复杂度：O(1)

Status GetElem(cList L,int i,ElemType *e)
{
    if(L.length==0 || i<1 || i>L.length)
            return ERROR;
    *e=L.data[i-1];
    return OK;
}

插入元素操作

思路分析：假设一个只能排5个人的队伍，队伍容量为5即数组长度为5，队伍中人的现有个数为线性表长度，若想要插队时如果已经5人满就不能插入，若想插在第6个位置超出了队伍的容量范围，也不能插入，无上述情况下，插入元素身后后面的人都要往后挪一位，前面的人不受影响，最后队伍人现有个数加1。

时间复杂度：O(n) 最坏的情况下 【插在队首】

/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(cList *L,int i,ElemType e)
{
	int k;
	if (L->length==MAXSIZE)  /* 顺序线性表已经满 */
		return ERROR;
	if (i<1 || i>L->length+1)/* 当i比第一位置小或者比最后一位置后一位置还要大时 */
		return ERROR;
	if (i<=L->length)        /* 若插入数据位置不在表尾 */
	{
		for(k=L->length-1;k>=i-1;k--)  /* 将要插入位置之后的数据元素向后移动一位 */
			L->data[k+1]=L->data[k];
	}
	L->data[i-1]=e;          /* 将新元素插入 */
	L->length++;
	return OK;
}

删除元素操作

思路分析：与插入同样，不过是一个人有事离开后，队伍现有人数减1，离开人的后面的人往前挪一位。

时间复杂度：O(n) 最坏的情况下【第一个人离开】

Status ListDelete(cList *L,int i,ElemType *e)
{
    int k;
    if (L->length==0)               /* 线性表为空 */
		return ERROR;
    if (i<1 || i>L->length)         /* 删除位置不正确 */
        return ERROR;
    *e=L->data[i-1];
    if (i<L->length)                /* 如果删除不是最后位置 */
    {
        for(k=i;k<L->length;k++)/* 将删除位置后继元素前移 */
			L->data[k-1]=L->data[k];
    }
    L->length--;
    return OK;
}

优点

• 元素只包含数据，不需要其他额外空间
• 根据索引可以迅速存取表中任一位置元素(查的快)

缺点

• 插入和删除元素需要移动大量元素(改删慢)
• 线性表长度变化较大时，难以确定存储空间的容量(动态线性表不易确定)
• 造成存储空间的碎片

链式存储结构(链表)

为了解决顺序存储结构的缺点，我们发现，造成插入和删除元素慢的原因是为了保证连续，我们不得不移动大量元素，这个操作可不可以避免呢？因此，就有了链式存储这个结构。

链式结构规定了数据元素不一定连续，甚至可以是零散分布在内存中的任意位置上，因此不需要先估计存储空间大小，解决了顺序存储难以确定存储空间容量大小的缺点。

在逻辑关系上，我们可以看成这种形式：

举个简单例子-在医院排队等号时，你只需要知道你前一个是多少号，等前一个号叫到了，你才知道马上该到你了，排队期间你可以去任意地方，顺序存储是你必须要站在队伍中排队，从而，你前边插了多少人，中途离开了多少人，你都是不知道的，因此很好的弥补了顺序存储增删慢的缺点。

在链式结构中，除了要存储元素信息外，还要存储后继元素的地址。

存储数据元素信息的域称为数据域，把直接存储后继位置的域称位指针域，两部分信息合称为结点(Node)。

链表中第一个结点的存储位置叫做头指针，最后一个结点指针为空Null。

单链表中，我们在C语言中可用结构指针来描述

/*线性表的单链表存储结构*/
typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定义LinkList */

获得元素操作

思路分析：

• 声明一个结点p指向第一个结点，初始化一个变量j从1开始作为计数器
• 当j小于要获得的第i个元素，遍历链表，让p的指针向后移动，指向下一结点，j累加。
• 若到链表末尾p为空，则说明第i个元素不存在。
• 否则查找为空，返回结点p的数据。

Tips：由于单链表结构中没有定义表长，所以不方便用for来循环控制

时间复杂度：O(n) 最坏情况下【获得最后一个元素】

/* 操作结果：用e返回L中第i个数据元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
	int j;
	LinkList p;		/* 声明一结点p */
	p = L->next;		/* 让p指向链表L的第一个结点 */
	j = 1;		/*  j为计数器 */
	while (p && j<i)  /* p不为空或者计数器j还没有等于i时，循环继续 */
	{   
		p = p->next;  /* 让p指向下一个结点 */
		++j;
	}
	if ( !p || j>i ) 
		return ERROR;  /*  第i个元素不存在 */
	*e = p->data;   /*  取第i个元素的数据 */
	return OK;
}

插入元素操作

思路分析：

• 声明一结点p指向链表第一个结点，初始化j从1开始。
• 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1。
• 若到链表末尾p为空，则说明第i个元素不存在。
• 否则查找成功，在系统中生成一个空结点s。
• 将数据元素e赋值给s->data。
• 单链表的插入标准语句 s->next = p->next; 与 p->next = s;

Tips：s->next = p->next; 与 p->next = s; 顺序不可以交换，交换后就变成了s->next = s;

时间复杂度：O(n)

/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{ 
	int j;
	LinkList p,s;
	p = *L;   
	j = 1;
	while (p && j < i)     /* 寻找第i个结点 */
	{
		p = p->next;
		++j;
	} 
	if (!p || j > i) 
		return ERROR;   /* 第i个元素不存在 */
	s = (LinkList)malloc(sizeof(Node));  /*  生成新结点(C语言标准函数) */
	s->data = e;  
	s->next = p->next;      /* 将p的后继结点赋值给s的后继  */
	p->next = s;          /* 将s赋值给p的后继 */
	return OK;
}

删除元素操作

思路分析：

• 声明一结点p指向链表第一个结点，初始化j从1开始。
• 当j<i时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1。
• 若到链表末尾p为空，则说明第i个元素不存在。
• 否则查找成功，将要删除的结点的指针p->next赋值给q;
• 单链表的删除标准语句p->next=q->next;
• 将q结点中的数据赋值给e，作为返回；
• 释放q结点；(系统回收q结点，释放内存)

Tips：由于单链表结构中没有定义表长，所以不方便用for来循环控制

时间复杂度：O(n)

/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(LinkList *L,int i,ElemType *e) 
{ 
	int j;
	LinkList p,q;
	p = *L;
	j = 1;
	while (p->next && j < i)	/* 遍历寻找第i个元素 */
	{
        p = p->next;
        ++j;
	}
	if (!(p->next) || j > i) 
	    return ERROR;           /* 第i个元素不存在 */
	q = p->next;
	p->next = q->next;			/* 将q的后继赋值给p的后继 */
	*e = q->data;               /* 将q结点中的数据给e */
	free(q);                    /* 让系统回收此结点，释放内存 */
	return OK;
}

通过上述代码我们可以看到，插入和删除的时间复杂度(最坏情况)并没有明显的降低，那为什么说链表插入和删除快呢？通过分析我们发现，在链表的插入与删除的操作中，都进行了一次查找，对于频繁插入或删除的数据，在一次查询后，知道了结点的位置后，后续我们在进行增删的操作的时间复杂度仅仅是O(1)了！

优点

• 单链表在查找后某位置的指针后，插入和删除时间复杂度仅为O(1)。
• 不需要预先分配存储空间，元素个数理论上不受限制。

缺点

• 查询元素变慢
• 额外的空间去存储地址