数据结构的奇妙冒险（C语言版）——线性结构（上）

目录

一、线性表（Linear_List）

1、定义

2、线性表的抽象数据类型描述

二、线性表的顺序存储实现

三、线性表的链式存储实现

---

一、线性表（Linear_List）

1、定义

        由同类型的数据元素构成有序序列的线性结构

        （1）表中元素个数称为线性表的长度

        （2）线性表没有元素时，称为空表

        （3）表的起始位置称为表头，表结束位置称为表尾

2、线性表的抽象数据类型描述

（1）类型名称：线性表

（2）数据对象集：线性表是n（>=0）个元素构成的有序序列（a1，a2，a3......，an）

（3）操作集：线性表LList，整数i表示位置，元素XElementType，线性表基本操作有： 

List MakeEmpty();初始胡一个空线性表L

ElementType FindKth(int K,List L);根据位序K，返回相应的元素

int Find(ElementType X,List KL);在线性表L中查找X的第一次出现的位置

void Insert(ElementType X,int i,List L);在位序i前插入一个新元素

void Delete(int i,List L);删除指定位序i的元素

int Length(List L);返回线性表L的长度n

二、线性表的顺序存储实现

        利用数组的连续存储空间顺序存放线性表的各元素

#include <stdio.h>
#include <stdlib.h>
//注意，ElementType 为数组存储的数据格式
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
typedef struct LNode * List;
struct LNode 
{
	ElementType Date[MAXSIZE];//存储的数组 
	int Last;//表示数组含有几个元素（-1表示为没有元素，0表示1个元素......） 
};//定义结构体 

struct LNode L;//创建结构体 
List PtrL;//创建结构体指针 

 
int main(int argc, char *argv[]) {
	
	return 0;
}
//初始化，创建空的顺序表 
List MakeEmpty()
{
	List Ptrl;
	PtrL=(List)malloc(sizeof(struct LNode));//开辟内存空间 
	PtrL->Last=-1;//将last初始化为-1 
	return PtrL;
}
//安值查找元素 
int Find(ElementType X,List PtrL)
{
	int i=0;
	while(i<=PtrL->Last&&PtrL->Date[i]!=x)//当没有遇到数组尾部或者没有遇到所查找的值时，i++ 
	i++;
	if(i>PtrL->Last)return -1;//如果遇到数组尾部，返回-1，表示错误 
	else return i;//否则返回该值在第几个元素 
}
//在第i（1<=i<=n+1）个元素上插入X 
void INsert(ElementType X,int i,List PtrL)
{
	int j;
	if(PtrL->Last==MAXSIZE-1)//检查表满 
	{
		printf("表满");
		return; 
	}
	if(i<1||i>PtrL->Last+2)//检查插入位置的合法性 
	{
		printf("位置不合法")；
		return; 
	}
	for(j=PtrL->Last;j>=i-1;j--)
		PtrL->Date[j+1]=PtrL->Date[j];//将所在位置的ai~an均往后移动 
	PtrL->Date[i-1]=x;//将新元素插入 
	PtrL->Last++;//Last+1 
}
//删除表的第i（1<=i<=n）个位置上的元素 
void Delete(int i,List PtrL)
{
	int i;
	if(i<1||i>PtrL->Last+1)//检查空表以及删除位置的合法性 
	{
		printf("不存在第%d个元素",i);
		return;
	}
	for(j=i;j<PtrL->Last;j++)//将ai+1~an顺序向前移动 
	{
		PtrL->Date[j-1]=PtrL->Date[j];
		}	
	PtrL->Last--;//Last-1 
	return;
}

三、线性表的链式存储实现

        链式存储不要求逻辑上相邻的两个元素物理上也相邻，即不必像数组一样，存储地址是连续的，链式存储通过“链”建立起数据元素之间的逻辑关系。这样子，插入，删除数据不需要移动数据，只需要修改”链“，使用链表建立这种联系。

#include <stdio.h>
#include <stdlib.h>
//注意ElementType为链表存储的数据类型
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

typedef struct LNode * List;
struct LNode
{
	ElementType Data;
	List Next;
 };

struct LNode L;
List PtrL;

int main(int argc, char *argv[]) {
	
	return 0;
}
//求表长，时间复杂度：O(n) 
int Length(List PtrL)
{
	List p=PtrL;
	int j=0;
	while(P)//只有当P=NULL时（即到链表末尾） 跳出循环 
	{
		p=p->Next;
		j++;	
	}
	return j;
}
//按序号查找
List FindKth(int K,List PtrL)
{
	List p=PtrL;
	int i=1;
	while(p!=NULL&&i<K)
	{
		p=p->Next;
		i++;
	}
	if(i==K)return p;
	else return NULL;
 } 
//按值查找
List Find(ElementType X,List PtrL)
{
	List p=PtrL;
	while(p!=NULL&&p->Data!=x)
		p=p->Next;
	return p;
 } 
//插入（在第i-1（1<=i<=n+1）个结点后插入一个值为x的新结点）
//（1）先构造一个结点
//（2）再找到链表的第i-1个结点，用p指向
//（3）然后修改指针，插入结点（p之后插入新结点是s）
List Insert(ElementType X,int i,List PtrL)
{
	List p,s;
	if(i==1)//如果在第1结点前插入新结点 
	{
		s=(List)malloc(sizeof(struct LNode));//开辟内存，返回结点地址 
		s->Data=x;//将结点的Data设置为x 
		s->Next=PtrL;//将结点的Next指向PtrL，即第一个结点 
		return s;//返回该结点地址 
	}
	p=FindKth(i-1,PtrL);//查找第i-1个结点位置 
	if(p==NULL)//若该结点不存在 
	{
		printf("参数i错误");
		return NULL; 
	}
	else
	{
		s=(List)malloc(sizeof(struct LNode));//开辟内存 
		s->Data=x; 将结点的Data设置为x 
		s->Next=p->Next;//将结点的Next指向p的Next
		p->Next=s;//将p的Next指向S 
		return PtrL;//返回该结点地址 
	}
}
//删除（删除链表的第i（1<=i<=n）个位置上的结点） 
//（1）先找到链表的第i-1个结点，用p指向
//（2）再用指针s指向要被删除的点（p的下一个结点）
//（3）然后修改指针，删除s所指结点
//（4）释放s所指结点空间
List Delete(int i,List PtrL)
{
	List p,s;
	if(i==1)//如果删除表头（第一个结点） 
	{
		s=PtrL;
		if(PtrL!=NULL) PtrL=PtrL->Next;//如果该结点存在，将PtrL指向下一个结点 
		else return NULL;//否则返回NULL 
		free(s);//释放该结点 
		return PtrL;//返回下一个结点地址 
	}
	p=FindKth(i-1,PtrL)；//查找第i-1个结点 
	if(p==NULL)//如果i-1个结点不存在 
	{
		printf("第%d个结点不存在",i-1);
		return NULL;
	}
	else if(p->Next==NULL)//如果返回的i-1结点刚好是链表的最后一个结点（即该结点的next=NULL） 
	{
		printf("第%d个结点不存在",i);
		return NULL;
	}
	else
	{
		s=p->Next;//s指向第i个结点
		p->Next=s->Next; // 从链表中删除  
		fress(s);    // 释放 被删除结点  
		return PtrL;
	}
}

 

链表除了线性链表还有循环链表和双向链表：

循环链表：特点是，表中最后一个结点的指针域指向头结点，整个链表形成一个环，从任意一个结点出发，均能找到表中的其他结点。循环链表的操作和线性链表基本一致，差别仅在算法中的循环条件不是p或p->Next是否空，而是它们是否等于头指针。

双向链表：线性链表和循环链表的结点中只有一个指示直接后继的指针域，因而从某结点出发只能往后寻查其他结点，而双向链表中有两个指针域，一个指向后继结点，一个指向前面的结点。其结点定义如下：

typedef struct DuLNode
{
    ElemType data;
    struct DuLNode *prior;
    struct DuLnode *next;
}DuLNode,*DuLingkList;

---

数据结构的奇妙冒险持续更新中~

要是文章有帮助的话

就点赞收藏关注一下啦！

感谢大家的观看

欢迎大家提出问题并指正~