【数据结构c#】线性表

线性表是是具有相同数据类型的n个数据元素的有限序列

依据存储结构分为顺序表和链表（链表又分为单链表，循环链表，双向链表，静态链表）

 

顺序表 特点是表中元素的逻辑顺序与物理顺序相同

以下为顺序表基础操作

#include<stdio.h>

#define MAXSIZE 100//线性表存储空间的初始分配量
#define LISTINCREMENT//线性表存储空间的初始增量

typedef void Status;
typedef int ElemType;
//线性表的静态分配顺序存储结构
typedef struct{
	//动态分配不是直接指定数组，而是使用头指针，然后在创表时使用malloc分配空间
    //ElemType *elem;//存储空间基址（头指针）
	ElemType data[MAXSIZE];//顺序表的元素
	int length;//当前长度
	//int listsize;//当前分配的存储容量，以sizeof（ElemType）为单位
}SqList;

//线性表的基本操作
//构造一个空的线性表L
Status InitList(SqList L){
	//L->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));//动态分配空间
	//指针自身 = (指针类型*）malloc（sizeof（指针类型）*数据数量）
	//if(!L.elem) exit(0);//如果存储空间基址不存在，则存储分配失败
	L.length=0;//空表长度为0
	//L.listsize=MAXSIZE;//存储初始容量
	return OK;
}

//顺序表取值
Status GetElem(SqList L,int i,ElemType &e){
	if(i<1||i>L.length) return ERROR;//判断元素序号是否合理
	e=L.elem[i-1];//得到序号的值，线性表中元素下标是从0开始，下标为i-1的元素实际序号为i
	return OK;
}

//顺序表的按值查找
int LocateElem(SqList L,ElemType e){
	for(int i=0;i<L.length;i++){//遍历整个顺序表
		if(L.elem[i]==e) return i+1;//如果找到了，返回该元素序号
		}
	return 0;//没找到就返回0
	}
}

//顺序表插入元素
Status Listinsert(SqList &L,int i,ElemType e){
	if(i<0||i>L.length+1||L.length=MAXSIZE) return ERROR;
	for(int j=L.length;j>=i-1;j--){//序号为i，实际位置为i-1
		L.elem[j+1]=L.elem[j];//i后（包括i）的所有元素位置后移，留下了序号为i的位置
	}
	L.elem[i-1]=e;
	++L.length;
	return OK;
}

//顺序表删除元素
Status ListDelete(SqList &L,int i,ElemType e){
	if(i<0||i>L.length+1||L.length=MAXSIZE) return ERROR;
	for(int j=L.length;j>=i-1;j--){//序号为i，实际位置为i-1
		L.elem[j]=L.elem[j+1];//i后（包括i）的所有元素位置前移
	}
	--L.length;
	return OK;
}

还有求表长，判空，销毁操作 

 

单链表  通过一组任意的存储单元来存储线性表中的数据元素

为了操作方便，在单链表第一个结点之前附加一个结点，称作头结点，头结点的指针域指向线性表的第一个元素结点

头结点和头指针的区分：不管带不带头结点，头指针始终指向链表的第一个结点，而头结点是带头结点的链表中的第一个结点，结点内通常不存储信息

 建立单链表有两种方式：头插法和尾插法，分别是将插入的结点插在链表最前端或最后端

头插法

LinkList List_HeadInsert(LinkList &L){//逆向建立单链表
    LNode *s;int x;
    L=(LinkList)malloc(sizeof(LNode));//创建头结点
    L->next=NULL;
    scanf("%d",&x);//输入新结点的值
    while(x!=9999){//输入9999表示结束
    	s=(LNode*)malloc(sizeof(LNode));//创建新结点
    	s->data=x;
    	s->next=L->next;
    	L->next=s;
    	scanf("%d",&x);
	}
	return L;
}

尾插法 在头插法的基础上添加一个表尾指针

LinkList List_TailInsert(LinkList &L){//正向建立单链表
	int x;
	L=(LinkList)malloc(sizeof(LNode));//创建头结点
	LNode *s,*r=L;//s为要添加的结点，r为表尾指针
	scanf("%d",x);
	while(x!=9999){
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
		r->next=s;//尾指针指向新插入的元素
		r=s;//尾指针移动到新添加的元素上
		//尾指针所指的数据域为最后一个元素的数据域，现在最后一个元素变成了新插入的元素，尾指针所指的数据域也随之改变
		scanf("%d",&x);
	}
	r->next=NULL;//尾结点指针置空
	return L;
}

//按值查找表结点
//从单链表的第一个结点开始，由前往后依次比较表中各结点数据域的值，若某数据域的值等于定值e，则返回该结点的指针
LNode *LocateElem_LinkList(LinkList L,ElemType e){
	LNode *p=GetElem_List(L,1);
	while(p->next!=NULL){//遍历
		if(p->data=e) return p;//找到后返回指针
		p=p->next;//指向下一个指针
	}
	rerun ERROR;//没找到就返回error
}

//按序号查找结点值
//从单链表的第一个结点开始，由前往后依次比较表中各结点数据域的值
//若某结点数据域的值等于定值e，则返回该结点的指针
//若整个单链表中没有这样的结点，则返回NULL
LNode *GetElem_LinkList(LinkList L,int i){
	int j=1;//计数，初始为1
	LNode *p=L->next;
	if(i==0) return L;//若i=0，则返回头结点
	if(i<1) return NULL;//若i无效，则返回null
	if(p&&j<i){//从第1个结点开始找，查找第i个结点
		p=p->next;
		j++;
		return p;//找到后返回第i个结点的指针
    }
	return NULL;//若i大于表长则返回null
	}
}

//插入结点操作,后插
//先检查插入位置的合法性，然后找到待插入位置的前驱结点，即第i-1个结点，再在其后插入新结点
LNode *InsertElem_LinkList(LinkList L,int i,LNode *s){
	if(i<0) return ERROR;
	GetElem_LinkList(L,i-1);
	s->next=p->next;
	p->next=s;
}    
//前插 交换位置
/*s->next=p->next;
  p->next=s;
  temp=p->data;
  p->data=s->data;
  s->data=temp;*/

//删除结点操作
LNode* DeleteElem_LinkList(LinkList L,int i,LNode *q){
	LNode *p=GetElem_List(L,i-1);//查找删除位置的前驱结点
	q=p->next;//令q指向被删除结点
	p->next=q->next;//将*q从链中断开
	free(q);//释放被删除结点的空间
}

//求表长操作，带头结点
//从第一个结点开始顺序访问每个结点，并设置计数器变量，每访问一个结点，计数器加1
//单链表的长度是不包括头结点的，对不带头结点的表，当表为空时，要单独处理
int Length_LinkList(LinkList L){
	int j=0;
	for(LNode *p=GetElem_List(L,1);p->next!=NULL;p->next){
		j++;
	}
	return j-1;
}

 

双向链表  双向链表在单链表的基础上加了一个指向其前驱的prior指针

单链表结点中只有一个指向其后继的指针，使得单链表只能从头结点开始依次顺序向后遍历，要访问某个结点的前驱结点时，只能从头开始遍历，访问后继结点时的时间复杂度为O（1），访问前驱结点的时间复杂度为O(n）。

为了克服上述缺点，引入了双向链表，双向链表有两个指针prior和next，分别指向其前驱结点与后继结点

//双链表的插入操作
Status LinkListInsert(DNode *p,DNode *s){//将结点s插入结点p之后
	s->next=p->next;
	p->next->prior=s;
	s->prior=p;	
	p->next=s;
}

//双链表的删除操作
Status LinkListDelete(DNode *p,DNode *q){//删除结点p的后继结点q
    p->next=q->next;
	q->next->prior=p;
    free(q);
}

 

循环双链表  头结点的prior指针指向表尾结点 

 

静态链表

静态链表借助数组来描述线性表的链式存储结构，结点也有数据域打他和指针域next，与前面所讲的链表中的指针不同的是，这里的指针是结点的相对地址（数组下标），又称游标，与顺序表一样，静态链表也要预先分配一块存储空间

#define MAXSIZE 100;//静态链表的最大长度
typedef struct{
	ElemType data;//数据域
	int next;//下一个元素的数组下标
}SLinkList[MAXSIZE];

 静态链表以next==-1作为结束标志。静态链表的插入，删除不操作与动态链表的相同，只需要修改指针，不需要移动元素

 

总结 

顺序表和链表在结构体上的区别是 顺序表定义表的长度，链表定义指针，二者都需定义数据域

两种存储方式各有长短，通常较稳定的线性表选择顺序存储，而频繁进行插入，删除操作的线性表宜选择链式存储