顺序表

顺序表:

特点

1. 简单
2. 支持随机访问(下标);
3. 查找快;
   缺点:1.插入和删除慢(但是尾巴插入和删除O(1))

定长顺序表

#define SIZE 10//顺序表的总格子数

typedef struct SeqList//定长顺序表
{
	int elem[SIZE];
	int length;//有效数据个数
}SeqList,*PSeqList;//44


void InitSeqList(PSeqList ps)
{
	assert(ps!=NULL);
	if(ps==NULL)
	{
		return;
	}
	ps->length=0;//有效数据个数为0
}

//判断顺序表是否为满
static bool IsFull(PSeqList ps)
{
	return ps->length==SIZE;
}

//在顺序表ps中的第pos位置插入val
bool Insert(PSeqList ps,int pos,int val)
{
	if(pos<0||pos>ps->length||IsFull(ps))
	{
		return false;
	}
	for(int i=ps->length-1;i>=pos;i--)//1、移动后面的数据
	{
		ps->elem[i+1]=ps->elem[i];
	}
	ps->elem[pos]=val;//2、插入
	ps->length++;//3、长度+1
	return true;
}

//在顺序表ps中查找key，如果找到返回下标，没有找到返回-1
int Search(PSeqList ps,int key)
{
	for(int i=0;i<ps->length;i++)
	{
		if(ps->elem[i]==key)
		{
			return i;
		}
	}
	return -1;
}

//在ps中删除关键字key，成功返回true
bool DeleteVal(PSeqList ps,int key)
{
	int index=Search(ps,key);
	return DeletePos(ps,index);
}

//删除第pos位置的值
bool DeletePos(PSeqList ps,int pos)
{
	if(pos<0||pos>=ps->length)
	{
		return false;
	}
	for(int i=pos;i<ps->length-1;i++)
	{
		ps->elem[i]=ps->elem[i+1];
	}
	ps->length--;
	return true;
}

//获取pos位置的值
bool GetElem(PSeqList ps,int pos,int *rtval)
{
	if(pos<0||pos>ps->length)
	{
		return false;
	}
	*rtval=ps->elem[pos];
	return true;
}

//将pos位置的值设为val
bool SetElem(PSeqList ps,int pos,int val)
{
	if(pos<0||pos>ps->length)
	{
		return false;
	}
	ps->elem[pos]=val;
	return true;
}

//获取关键字key的前驱值
bool GetPrio(PSeqList ps,int key,int *rtval)
{
	int index=Search(ps,key);
	if(index<=0)
	{
		return false;
	}
	*rtval=ps->elem[index-1];
	return true;
}

//获取关键字key的后继值
bool GetNext(PSeqList ps,int key,int *rtval)
{
	int index=Search(ps,key);
	if(index<0&&index>=ps->length-1)
	{
		return false;
	}
	*rtval=ps->elem[index+1];
	return true;
}

//获取顺序表的有效长度
int GetLength(PSeqList ps)
{
	if(ps==NULL)
	{
		return -1;
	}
	return ps->length;
}

//判断ps是否为空
bool IsEmpty(PSeqList ps)
{
	if(ps->length==0)
	{
		return true;
	}
	return false;
}

//将ps数据清空
void Clear(PSeqList ps)
{
	ps->length=0;
}

//销毁ps
void Destroy(PSeqList ps)
{
	Clear(ps);
}


//打印顺序表                       
void show(PSeqList ps)
{
	for(int i=0;i<ps->length;i++)
	{
		printf("%d  ",ps->elem[i]);
	}
	printf("\n");
}

不定长顺序表

#define OK 0
#define INDEX_ERROR 1
#define POINT_NULL 2
#define FOUND_ERROR 3

typedef int State;

typedef struct DSeqList
{
	int *elem;
	int length;
	int listsize;
}DSeqList,*PDSeqList;
//初始化顺序表ps
State InitSeqList(PDSeqList ps)
{
	assert(ps!=NULL);
	if(ps==NULL)
	{
		return POINT_NULL;
	}
	ps->elem=(int *)malloc(INIT_SIZE*sizeof(int));
	ps->length=0;
	ps->listsize=INIT_SIZE;

	return OK;
}

static bool IsFull(PDSeqList ps)
{
	return ps->length==ps->listsize;
}

static void Inc(PDSeqList ps)
{
	ps->elem=(int *)realloc(ps->elem,ps->listsize*2*sizeof(int));
	ps->listsize *=2;
}

//在顺序表ps中的第pos位置插入val
State Insert(PDSeqList ps,int pos,int val)
{
	if(pos<0||pos>ps->length)
	{
		return INDEX_ERROR;
	}
	if(IsFull(ps))
	{
		Inc(ps);
	}

	for(int i=ps->length-1;i>=pos;i--)
	{
		ps->elem[i+1]=ps->elem[i];
	}
	ps->elem[pos]=val;
	ps->length++;

	return OK;
}


//在顺序表ps中查找key，如果找到返回下标，没有找到返回-1
int Search(PDSeqList ps,int key)
{
	for(int i=0;i<ps->length-1;i++)
	{
		if(ps->elem[i]==key)
		{
			return i;
		}
	}
	return -1;
}


//在ps中删除关键字key，成功返回true
State DeleteVal(PDSeqList ps,int key)
{
	int index=Search(ps,key);
	if(index<0)
	{
		return FOUND_ERROR;
	}
	return DeletePos(ps,index);
}


//删除第pos位置的值
State DeletePos(PDSeqList ps,int pos)
{
	if(pos<0||pos>ps->length)
	{
		return INDEX_ERROR;
	}
	for(int i=pos;i<ps->length-1;i++)
	{
		ps->elem[i]=ps->elem[i+1];
	}
	ps->length--;
	return OK;
}


//获取pos位置的值
State GetElem(PDSeqList ps,int pos,int *rtval)
{
	if(pos<0||pos>=ps->length)
	{
		return INDEX_ERROR;
	}
	if(rtval!=NULL)
	{
		*rtval=ps->elem[pos];
	}
	return *rtval;
}


//将pos位置的值设为val
State SetElem(PDSeqList ps,int pos,int val)
{
	if(pos<0||pos>=ps->length)
	{
		return INDEX_ERROR;
	}
	ps->elem[pos]=val;
	return OK;
}


//获取关键字key的前驱值
//rtval:输出参数
State GetPrio(PDSeqList ps,int key,int *rtval)
{
	int index=Search(ps,key);
	if(index<=0||index>ps->length)
	{
		return INDEX_ERROR;
	}
	if(rtval!=NULL)
	{
	    *rtval=ps->elem[index-1];
	}
	return *rtval;
}


//获取关键字key的后继值
int GetNext(PDSeqList ps,int key,int *rtval)
{
	int index=Search(ps,key);
	if(index<0||index>ps->length-1)
	{
		return INDEX_ERROR;
	}
	if(rtval!=NULL)
	{
		*rtval=ps->elem[index+1];
	}
	return *rtval;
}


//获取顺序表的有效长度
State GetLength(PDSeqList ps)
{
	return ps->length;
}


//判断ps是否为空
bool IsEmpty(PDSeqList ps)
{
	if(ps->length==0)
	{
		return true;
	}
	return false;
}

//将ps数据清空
State Clear(PDSeqList ps)
{
	ps->length=0;
	return OK;
}


//销毁ps
State Destroy(PDSeqList ps)
{
	Clear(ps);
	return OK;
}


//打印顺序表
void Show(PDSeqList ps)
{
	for(int i=0;i<ps->length;i++)
	{
		printf("%d  ",ps->elem[i]);
	}
	printf("\n");
}