数据结构学习，顺序表

目录

预先要引用的头文件以及宏定义

所使用顺序表的结构

其基本操作接口

初始化顺序表

销毁顺序表

将顺序表L清空

若顺序表为空表，返回TRUE，否则返回ERROR

返回顺序表L中的元素个数

用e返回顺序表L中第i个元素

在顺序表L中顺序查找元素e，成功时返回该元素在表中的第一次出现的位置，否则返回-1；

遍历顺序表L

将顺序表L中第i个元素赋值为e

在顺序表L表尾添加元素e

删除顺序表L的表尾元素，并用参数e返回其值

一些接口的测试

---

预先要引用的头文件以及宏定义

#include<stdio.h>
#include<iostream>

using namespace std;

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
typedef int ElemType;
typedef int Status;

所使用顺序表的结构

typedef struct {
	ElemType* elem;	//存储空间基此
	int length;		//当前长度
	int size;		//存储容量//最大长度
	int increment;	//扩容的增量
}SqList;

其基本操作接口

Status InitList_Sq(SqList& L, int size, int inc);	//初始化顺序表L
Status DestroyList_Sq(SqList& L);					//销毁顺序表L
Status ClearList_Sq(SqList& L);						//将顺序表L清空
Status ListEmpty_Sq(SqList L);						//若顺序表为空表，返回TRUE，否则返回ERROR
int ListLength_Sq(SqList L);						//返回顺序表L中的元素个数
Status GetElem_Sq(SqList L, int i, ElemType& e);	//用e返回顺序表L中第i个元素
int Search_Sq(SqList L, ElemType e);				//在顺序表L中顺序查找元素e，成功时返回该元素在表中的第一次出现的位置，否则返回-1；
Status ListTraverse_Sq(SqList L);					//遍历顺序表L；
Status PutElem_Sq(SqList& L, int i, ElemType e);	//将顺序表L中第i个元素赋值为e
Status Append_Sq(SqList& L, ElemType e);			//在顺序表L表尾添加元素e
Status DeleteLast_Sq(SqList& L, ElemType& e);		//删除顺序表L的表尾元素，并用参数e返回其值

初始化顺序表

Status InitList_Sq(SqList& L, int size, int inc)
{
	L.elem = (ElemType*)malloc(size * sizeof(ElemType));
	if (L.elem == NULL)
	{
		return OVERFLOW;
	}
	else
	{
		L.increment = inc;
		L.size = size;
		L.length = 0;
	}
}

销毁顺序表

Status DestroyList_Sq(SqList& L)
{
	if (L.elem != NULL)
	{
		free(L.elem);
		L.length = 0;
		L.size = 0;
		L.increment = 0;
		return OK;
	}
	else
	{
		return ERROR;
	}
}

将顺序表L清空

Status ClearList_Sq(SqList& L)
{
	if (L.elem != NULL)
	{
		L.length = 0;
		return OK;
	}
	else
	{
		return ERROR;
	}
}

若顺序表为空表，返回TRUE，否则返回ERROR

Status ListEmpty_Sq(SqList L)
{
	if (L.elem != NULL)
	{
		if (L.length == 0)
		{
			return TRUE;
		}
		else
		{
			return ERROR;
		}
	}
	else
	{
		return OVERFLOW;
	}
}

返回顺序表L中的元素个数

int ListLength_Sq(SqList L)
{
	int sum = 0;
	sum = L.length;
	return sum;
}

用e返回顺序表L中第i个元素

Status GetElem_Sq(SqList L, int i, ElemType& e)
{
	if (L.elem != NULL)
	{
		if (i > L.length || i < 0)
		{
			return ERROR;
		}
		e = L.elem[i - 1];
		return OK;
	}
	else
	{
		return ERROR;
	}
}

在顺序表L中顺序查找元素e，成功时返回该元素在表中的第一次出现的位置，否则返回-1；

int Search_Sq(SqList L, ElemType e)
{
	int i = 0;
	while (i < L.length && L.elem[i] != e)
	{
		i++;
	}
	if (i < L.length)
	{
		return i;
	}
	else
	{
		return -1;
	}
}

遍历顺序表L

Status ListTraverse_Sq(SqList L)
{
	if (L.elem != NULL)
	{
		for (int i = 0; i < L.length; i++)
		{
			//printf("%d", L.elem[i]);
			cout << L.elem[i];
		}
		cout << "\n";
		return OK;
	}
	else
	{
		return ERROR;
	}
}

将顺序表L中第i个元素赋值为e

Status PutElem_Sq(SqList& L, int i, ElemType e)
{
	if (L.elem != NULL)
	{
		if (i > L.length || i < 0)
		{
			return ERROR;
		}
		else
		{
			L.elem[i - 1] = e;
			return OK;
		}
	}
	else
	{
		return OVERFLOW;
	}
}

在顺序表L表尾添加元素e

Status Append_Sq(SqList& L, ElemType e)
{
	if (L.elem != NULL)
	{
		if (L.length == L.size)
		{
			ElemType* elem1;
			elem1 = (ElemType*)realloc(L.elem, (L.size + L.increment) * sizeof(ElemType));
			L.elem = elem1;
			L.size = L.size + L.increment;
		}
		if (L.elem != NULL)
		{
			L.elem[L.length] = e;
			L.length = L.length + 1;
			return OK;
		}
		else
		{
			return OVERFLOW;
		}
	}
	else
	{
		return OVERFLOW;
	}
}

删除顺序表L的表尾元素，并用参数e返回其值

Status DeleteLast_Sq(SqList& L, ElemType& e)
{
	if (L.length == 0)
	{
		return ERROR;
	}
	else
	{
		e = L.elem[L.length - 1];
		L.length = L.length - 1;
		return OK;
	}
}

一些接口的测试

int main()
{
	//顺序表
	SqList L;
	InitList_Sq(L, 2, 5);
	cout<<ListEmpty_Sq(L)<<endl;
	for (int i = 0; i < 5; i++)
	{
		Append_Sq(L, i);
	}
	ListTraverse_Sq(L);
	for (int i = 0; i < 2; i++)
	{
		ElemType e;
		DeleteLast_Sq(L, e);
	}
	ListTraverse_Sq(L);
	ElemType num;
	GetElem_Sq(L, 3, num);
	cout << num << endl;
	PutElem_Sq(L, 2, 5);
	ListTraverse_Sq(L);
	cout<<DestroyList_Sq(L)<<endl;
	
}