考研数据结构之线性表

预备知识

typedef <数据类型> <命名>    typedef struct SqList
c++中的&（引用），指针指向被引用变量的存储地址
c——— malloc  free函数用于申请和释放内存空间(<stdlib.h>)
			malloc申请一整片连续 的内存空间，并返回一个该存储空间首地址，需要强制转换为指定的数据类型 
			L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize)
			free
c++  ————	new delete
基本数据类型可以直接用’==’判定，结构体类型数据要分别判断各个属性值是否相等

数据结构三要素 逻辑结构、存储结构、数据的运算
线性表定义：线性表是具有相同数据类型的n个数据元素的有限序列。（每个元素所占空间一样大，有次序）
notice：位序是从1开始

基本操作

初始化 InitList(&L) 构造一个空表并分配内存空间
销毁 DestoryList(&L) 销毁线性表，释放占用的内存空间
插入 ListInsert(&L,i,e) 在表的第i个位置插入元素e
删除 ListDelete(&L,i,&e) 删除第i个位置的元素，并用e返回删除元素的值
按值查找 LocateElem(L,e)
按位查找 GetElem(L,i)

其他常用操作
Length(L)
PrintList(L)
Empty(L)

顺序表(用顺序存储的方式实现的线性表)

//静态分配
#define MaxSize 10
typedef struct {
	ElemType data[MaxSize];	//一整片连续的存储空间
	int length;
}SqList;

//动态分配
#define ListSize 10
typedef struct{
	ElemType *data;
	int MaxSize;	//max capacity
	int length;		//current length
}SqList;

初始化

//初始化一个顺序表
void InitList(SqList &L)
{
	for(int i=0;i<MaxSize;i++)
	{
		L.data[i]=0;
	}
	L.length=0;
}

void InitList(SqList &L)
{
	L.data=(int *)malloc(ListSize*sizeof(int));
	L.length=0;
	L.MaxSize=ListSize;
}
//增加动态数组长度
void IncreaseSize(SqList &L,int len)
{
	int *p=L.data;
	L.data=(int *)malloc((ListSize+len)*sizeof(int));
	for(int i =0;i<L.length;i++)
	{
		L.data[i]=p[i];
	}
	L.MaxSize=L.MaxSize+len;
	free(p);
}

插入

//将第i个元素及之后的元素后移，在位置i处插入e
bool ListInsert(SqList &L,int i,int e)
{
	if(i<1||i>L.length+1||L.length>L.MaxSize)
		return false;
	for(int j=L.length;j>=i;j—-)
	{
		L.data[j]=L.data[j-1];
	}
	L.data[i-1]=e;
	L.length++;
	return true;
}

删除

bool ListDelete(SqList &L,int i,int&e)
{
	if(i<1||i>L.length)
		return false;
	e=L.data[i-1];
	for(int j=i;j<L.length;j++)
	{
		L.data[j-1]=L.data[j];
	}
	L.length—-;
	return true;
}

查找

//按位查找
ElemType GetElem(SqList L,int i)
{
	return L.data[i-1];
}

//按值查找
int LocateElem(SqList L,ElemType e)
{
	for(int i=0;i<L.length;i++)
	{
		if(L.data[i]=e)
			return i+1;  //返回位序
	}
	return 0;	//查找失败

}

线性表（单链表实现）

typeof struct LNode{
	ElemType data;//数据域
	struct LNode *next;//指针域
} LNode,*LinkList;

初始化单链表

//不带头节点
bool InitList(LinkList &L)
{
	L=null;
	return true;
}


//带头节点
bool InitList(LinkList &L)
{
	L=(LNode*)malloc(sizeof(LNode));
	if(L==null)//内存不足，分配失败
		return false;
	L->next=null;
	return true;
}

按照位序插入

//头插法,在第i个位置插入
bool ListInsert(LinkList &L,int i,ElemType e)
{
	if(i<1)		//i从1开始
		return false;
	LNode *p;
	int j=0;
	p=L;
	while(p!=null&&j<i-1)
	{
		p=p->next;
		j++;
	}
	if(p==null)
		return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	s->data=e;
	s->next=p->next;
	p-next=s;
	return true;
}





bool ListInsert(LinkList &L,int i,ElemType e)
{
	if(i<1)
		return false;
	if(i=1)
	{
		LNode *s=(LNode*)malloc(sizeof(LNode));
		s->data=e;
		s->next=L;
		L=s;
		return true;
	}
	LNode *p;
	int j=1;
	p=L;
	while(p!=null&&j<i-1)
	{
		p=p->next;
		j++;
	}
	if(p==null)
		return false;
	LNode *s=(LNode *)malloc(sizeof(LNode));
	s->data=e;
	s->next=p->next;
	p-next=s;
	return true;
}

删除

bool ListDelete(LinkList &L,int i,ElemType e)
{
	if(i<1)
		return false;
	LNode *p;
	int j=0;
	p=L;
	while(p!=null&&j<i-1)
	{
		p=p->next;
		j++;
	}
	if(p==null)
		return false;
	if(p->next==null)	
		return false;
		
	LNode *q=p-next;
	e=q->data;
	p-next=q-next;
	free(q);
	return true;
}

查找

//按位查找
LNode * GetElem(LinkList L,int i){
	if(i<0)
		return null;
	LNode *p;
	p=L;
	int j=0
	while(p!=null&&j<i-1)
	{
		p=p->next;
		j++;
	}
	return p;
}

//按值查找
LNode * LocateElem(linkList L,ElemType e)
{
	LNode *p = L->next;
	while(p!=null&&p->data!=e)
		p=p->next;
	return p;
}

单链表的建立

//尾插法
LinkList List_TailInsert(LinkList &L)
{
	int x;
	L=(LinkList)malloc(sizeof(LNode));
	LNode *s,*r=L;
	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;
}

//头插法创建单链表
LinkList_HeadInsert(LinkList &L)
{
	LNode *s;
	int x;
	L=(LinkList)malloc(sizeof(LNode));
	L->next=null;
	scanf(“%d”,&x);
	while(x!=9999)
	{
		s=(LNode*)malloc(sizeof(LNode));
		s->data=x;
		s->next=L->next;
		L->next=s;
		scanf(“%d”,&x);
	}
	return L;
}