数据结构之顺序表

（一）顺序表

（1）概念：一种顺序存储结构；顺序表上的元素按照一定逻辑顺序存储一段连续的存储空间相邻的两个元素在物理位置上也相邻 可以随机访问顺序表中的元素(下标访问)。

（2）分类

定长顺序表，其存储单元大小不变，具有局限性；

不定长顺序表，其存储单元大小可变，当存储空间满了之后插入元素时可进行自动扩充；

（3）下列主要写出了不定长顺序表的代码，定长顺序表与不定长在操作上基本相同，除了不定长具有扩容机制

typedef int ElemType;
#define INITSIZE 10;
typedef struct Slist
{
	ElemType *data;//存放数据的数组
	int length;//有效数据的长度
	int size;//数组总大小
}Slist,*PSList;

//初始化顺序表
void Init_list(PSList plist)
{
	if(plist == NULL)
		return ;
//分配存储空间
	plist->data = (ElemType*)malloc(sizeof(ElemType)*10);
	plist->length = 0;
	plist->size = INITSIZE;
}
//判满
bool IsFull(PSList plist)
{
	if(plist == NULL)
		return false;
	return plist->length == plist->size;
}
//判空
bool IsEmpty(PSList plist)
{
	return plist->length == 0;
}
//扩容
static void  Inc(PSList plist)
{
	plist->data = (ElemType*)realloc(plist->data,plist->size*2*sizeof(ElemType));;
	plist->size *= 2;
}
//在顺序表指定的位置插入元素
bool Insert_Pos(PSList plist,int pos ,int val)
{
	if(plist == NULL || pos < 0 || pos > plist->length)
	{
		return false;
	}
	if(IsFull(plist))
	{
		 Inc( plist);
	}
	//从pos位置挪元素
	for(int i=plist->length-1;i>=pos;i--)
	{
		plist->data[i+1] =plist->data[i];
	}
	//在pos插入元素
	plist->data[pos] = val;
	plist->length++;
	return true;
}
//在顺序表中查找某元素的下标
int Search_Val(PSList plist,int val)
{
	int pos = -1;
	if(plist == NULL)
		return pos;
	for(int i = 0 ; i < plist->length-1;++i)
	{
		if(plist->data[i] == val)
		{
			pos = i;
			break;
		}
	}
	return pos;
}

//删除某个位置:先判断此位置是否合法 不合法即刻返回  
//如果合法，将pos位置之后的元素往前挪一位，覆盖掉pos位置的值
bool Del_Pos(PSList plist,int pos)
{
	if(plist == NULL || pos < 0 || pos > plist->length)
	{
		return false;
	}

	for(int i = pos ;i < plist->length;++i)
	{
		plist->data[i] = plist->data[i+1];
	}
	plist->length--;
	return true;
}

//删除指定的数据
//先查找此数据是否在顺序表上  在的话返回数据的下标 删除此位置即可
bool Del_Val(PSList plist,int val)
{
	if(plist == NULL)
		return false;
	int index = Search_Val(plist,val);
	if(index == -1)
		return false;
	Del_Pos(plist,index);
	return  true;
}

//得到有效数据的长度
int Get_Length(PSList plist)
{
	if(plist != NULL)
	{
		return plist->length;
	}
	return -1;
}
//得到顺序表的长度
int GetLength(PSList plist)
{
	if(plist != NULL)
	{
		return plist->size;
	}
	return false;
}

//清空数据
bool CLear(PSList plist)
{
	if(plist != NULL)
	{
		plist->length = 0;
	}
	return true;
}
//销毁顺序表
void Destroy(PSList plist)
{
	if(plist==NULL)
	{
		return ;
	}
	free(plist->data);
	plist->length=0;
	plist->size=0;
}

void Show(PSList plist)
{
	for(int i = 0 ; i < plist->length -1;++i)
	{
		printf("%d ",plist->data[i]);
	}
	printf("\n");
}

int main()
{
	Slist ls;
	Init_list(&ls);
	for(int i = 0 ; i < 10;++i)
	{
		Insert_Pos(&ls,i,i+1);
	}
	printf("delete before::\n");
	printf("delete before length::%d\n",Get_Length(&ls));
	Show(&ls);
	Del_Val(&ls,5);
	printf("delete after::\n");
	Show(&ls);
	printf("delete after length::%d\n",Get_Length(&ls));
	CLear(&ls);
	printf("clear after length::%d\n",Get_Length(&ls));
	Show(&ls);
	return 0;
}

（4）总结

对于顺序表来说，其按位置插入元素和删除元素的时间复杂度都为O(n),获得顺序表大小长度的时间复杂度为O(1)，但是顺序表尾插尾删时间复杂度为O(1),如果要频繁的执行尾插和尾删，可以选择使用顺序表；由于顺序表具有连续的存储空间，可以用下标实现快速访问元素。