《数据结构复习笔记》线性表

简介:

• 理解顺序表的逻辑与存储原理，并能实现简单顺序表
• 掌握单链表的逻辑与存储原理，并能实现单链表
• 掌握双链表的逻辑与存储原理
• 掌握循环链表的逻辑与存储原理

1，什么是线性表

    线性表是具有相同特性的数据元素组成的一个有限序列。线性表作为一种最简单的数据结构，有如下几个特征：

• 线性表中有且只有一个开始结点(头结点)，这个开始节点没有前驱结点。
• 线性表中有且只有一个末尾结点(尾结点)，这个末尾节点没有后继结点。
• 除去开始结点与末尾结点，其他结点都有一个前驱结点和后继结点。

    线性表在存储结构上有顺序存储和链式存储两种方式，但不管哪种存储方式，它们的结构都有如下特点：

1. 均匀性：虽然不同数据表的数据元素可以是各种各样的，但对于同一个线性表来说，数据元素必须具有相同的数据类型和长度。
2. 有序性：各数据元素在线性表中的位置只取决于它们的序号，数据元素之间的相对位置是线性的，即存在唯一的"第一个"和"最后一个"数据元素。除了第一个和最后一个外，其他元素前面均只有一个数据元素(直接前驱)，后面均只有一个数据元素(直接后继)。

    数据结构的目的是算法结合，实现各种操作。线性表是一种比较灵活的数据结构，它的长度可根据需要增删，它也可以进行插入，删除等操作。可对线性表进行的基本操作如下：

• 创建：create()
• 初始化：Init()
• 获取长度：GetLength()
• 判断表是否为空：IsEmpty()
• 获取元素：Get()
• 插入：Insert()
• 删除：Delete()
• 清空表：Clear()

2，线性表的顺序存储(顺序表)

2.1 顺序存储的原理

    顺序存储，就是在存储器中分配一段连续的存储空间，逻辑上相邻的数据元素，其物理存储地址也是相邻的。

2.2 顺序存储的实现

    1，创建顺序表

    在创建顺序表时，需要先创建一个头结点来存放顺序表的长度，大小和地址等信息，然后再创建顺序表，同时将顺序表的地址保存在头结点中。

实现实录如下：

1. 定义一个struct来保存顺序表的信息
2. 为头结点分配空间
3. 为顺序表分配空间，将顺序表空间地址保存在头结点中
4. 将头结点地址返回给调用者。

具体代码如下：

typedef struct_tag_SeqList  //头结点
{
	int capacity;  //表容量
	int length;    //表长度
	int *node;     //node[capacity],为指针数组
}TSeqList;

//创建顺序表
SeqList* SeqList_Create(int capacity)  //返回值为SeqList* 类型，即顺序表的地址
{
	int ret;
	TSeqList *temp = NULL;
	temp=(TSeqList*)malloc(sizeof(TSeqList)); //为头结点分配空间
	if(temp==NULL)
	{
		ret = 1;
		printf("func SeqList_Create() error:%d\n",ret);
		return NULL;
	}
	memset(temp,0,sizeof(TSeqList));
	temp->capacity=capacity;
	temp->lenght=0;
	temp->node=(int*)malloc(sizeof(void*)*capacity);  //分配一个指针数组
	if(temp->node==NULL)
	{
		ret = 2;
		printf("func SeqList_Create error %d\n",ret);
		return NULL;
	}
	return temp;		//将分配好的顺序表地址返回
}

    2，求顺序表容量

    在实现顺序表时，一般将顺序表信息保存在头结点中，因此求顺序表容量时，可以直接从头结点中获取。代码实现如下：

int SeqList_Capacity(SeqList* list)
{
	TSeqList *temp = NULL;
	if(list == NULL)
	{
		return;
	}
	temp=(TSeqList *)list;
	return temp->capacity;
}

    3，求顺序表长度

//求顺序表长度
int SeqList_Length(SeqList* list)
{
	TSeqList *temp = NULL;
	if(list == NULL)
	{
		return;
	}
	temp = (TSeqList*)list;
	return temp->length;
}

    4,插入元素

    在线性表中插入元素时，元素和元素后面的元素都要后移。在插入过程中，需要考虑一些异常情况如下：

• 当顺序表已满时，表中的元素无法向后移动，需要作出特别处理(例如不插入，或者申请新开辟一块更大的空间来存储这些元素)
• 当插入的位置在空闲区域时，需要作出相应处理。

实现代码如下：

//插入元素
int SeqList_Insert(SeqList* list,SeqListNode *node,int pos)
//参数为顺序表地址，要插入的元素地址，插入位置
{
	int i;
	TSeqList *temp = NULL;
	//先做健壮性检查
	if(list == NULL || node == NULL)
	{
		return -1;
	}
	temp=(TSeqList *)list;
	//如果顺序表已满
	if(temp->length>=temp->capacity)
	{
		return -2;
	}
	
	//容错
	if(pos>temp->length)
		pos=temp->length;
	
	for(i=temp->length;i>pos;i--)
	{
		temp->node[i]=temp->node[i-1];
	}
	temp->node[i]=(int)node;
	temp->length++;
	return 0;
}

    5，删除元素

    从顺序表中删除某一个元素，则将某一个元素删除后，需要将后面的元素依次向前移动来补齐空位。

实现代码如下：

//删除元素
SeqList* SeqList_Delete(SeqList* list,int pos)
{
	int i;
	//先做健壮性检查
	TSeqList* tlist = NULL;
	SeqListNode * temp = NULL;
	tlist = (TSeqList *)list;
	if(list==NULL||pos<0||pos>=tlist->capacity)
	{
		printf("SeqList_Delete() error%d\n");
		return NULL
	}
	temp=(SeqListNode*)tlist->node[pos]; //要删除的元素
	
	for(i=pos+1;i<tlist->length;i++)
	{
		tlist->node[i-1]=tlist->node[i];
	}
	tlist->length--;
	return temp;
}

    6，查找某个位置上的元素

//查找某个位置上的元素
SeqList* SeqList_Get(SeqList * list,int pos)
{
	int i;
	TSeqList* tlist = NULL;
	SeqListNode* temp = NULL;
	tlist = (TSeqList*)list;
	if(list=NULL||pos<0||pos>tlist->capacity)
	{
		return NULL;
	}
	temp = (SeqListNode*)tlist->node[pos];
	return temp;
}

    7，清空表

    清空顺序表是将表中的内容全部置为0

//清空顺序表
void SeqList_Clear(SeqList*list)
{
	TSeqList*temp = NULL;
	if(list==NULL)
	{
		return;
	}
	temp=(TSeqList*)list;
	temp->length=0;
	memset(temp->node,0,(temp->capacity * sizeof(void*)));
	return;
}

    8，销毁表

    销毁表是将表整个销毁，无法再使用

//销毁表
void SeqList_Destroy(SeqList* list)
{
	TSeqList* temp = NULL;
	if(list == NULL)
	{
		return;
	}
	temp = (TSeqList*)list;
	if(temp->node!=NULL)
	{
		free(temp->node);
	}
	free(temp);
	return;
}

2，线性表的链式存储(链表)

2.1 链式存储的原理

    链式存储中每个节点都包含两个部分：存储元素本身的数据域和存储结点地址的指针域。与顺序表相比，在插入，删除元素方面，链表的效率要比顺序表高许多。

2.2 链式存储的实现

    1，创建链表

struct Header  //头结点
{
	int length;  //纪录链表大小
	struct Node* next;	//指向第一个节点的指针
}

struct Node   //结点
{
	int data;		//记录结点数据
	struct Node* next;		//指向下一个节点的指针
}

typedef struct Node List;  //将Node重命名为List
typedef struct Header pHead; 	//将Header重命名为pHead

//链表初始化
pHead* createList()
{
	pHead* ph =(pHead*)malloc(sizeof(pHead));
	ph->length = 0;
	ph->next = NULL;
	return ph;
}

    2，获取链表大小

int Size(pHead* ph)
{
	if(ph==Null)
	{	
		printf("参数传入有误");
		return 0 ;
	}
	return ph->length;
}

    3，插入元素

int Insert(pHead* ph,int pos,int val)
{
	//先做健壮性检查
	if(ph==NULL||pos<0||pos>ph->length)
	{
		printf("参数传入有误");
		return 0;
	}
	//在向链表中插入这个元素时，先找到这个元素
	List* pval=(List*)malloc(sizeof(List)); //先分配一块内存来存储要插入的数据
	pval->data=val;
	List *pCur = ph->next;			//当前指针指向头结点的第一个节点
	if(pos==0)
	{
		ph->next=pval;
		pval->next=pCur;
	}
	else
	{
		for(int i=1;i<pos;i++)
		{
			pCur=pCur->next;
		}
		pval->next=pCur->next;
		pCur->next=pval;
	}
	ph->length++;
	return 1;
}

    4，查找某个元素

    查找链表中的某个元素，其效率没有顺序表高，因为不管查找的元素在哪个位置，都需要将前面的元素都全部遍历才能找到它。

List* find(pHead*ph,int val)
{
	//先做健壮性检查
	if(ph == NULL)
	{
		printf("输入的参数有误");
		return NULL;
	}
	List *pTmp = ph->next;
	do{
		if(pTmp->data==val)
		{
			return pTmp;
		}
		pTmp=pTmp->next;
	}while(pTmp->next!=NULL);
	printf("没有值为%d的元素",val);
	return NULL;
}

    5，删除元素

    在删除元素时，首先将被删除元素与上下节点之间的连接断开，然后将这两个上下节点重新连接，这样元素就从链表中成功删除了。

List* Delete(pHead*ph,int val)
{
	//先做健壮性检查
	if(ph == NULL)
	{
		printf("链表为空，删除失败");
		return NULL;
	}
	//找到val值所在的节点
	List* pval=find(ph,val);
	if(pval == NULL)
	{
		printf("没有值为%d的元素",val);
		return NULL;
	}
	
	//遍历链表找到要删除的节点，并找出其前驱及后继结点
	List *pRe = ph->next;  //当前节点
	List *pCur = ph->NULL;
	if(pRe->data == pval)
	{
		ph->next=pRe->next;
		ph->length--;
		return pRe;
	}
	else
	{
		for(int i=0;i<ph->length;i++)
		{
			pCur=pRe->next;
			if(pCur->data == pval)
			{
				pRe->next = pCur->next;
				ph->length--;
				return pCur;
			}
			pRe = pRe->next;
		}
	}
}

    6，销毁链表

void Destory(pHead *ph)
{
	List *pCur=ph->next;
	list *pTmp;
	if(ph==NULL)
		printf("参数传入有误");
	
	while(pCur->next!=NULL)
	{
		pTmp = pCur->next;
		free(pCur);
		pCur=pTmp;
	}
	ph->length=0;
	ph->next=NULL;
}

    7，遍历打印链表

void print(pHead *ph)
{
	if(ph==NULL){
		printf("打印不了，这个链表是空的");
	}
	List *pTmp=ph->next;
	while(pTmp !=NULL)
	{
		printf("%d",p->data);
		pTmp = pTmp->next;
	}
	printf("\n");
}

3，双链表

4，循环链表

    实现起来都差不多，就不写了...