顺序表代码实现

顺序表代码实现

定义宏

#define MaxSize 100

定义 MaxSize 为100，后续用来初始化顺序表

结构体来构建顺序表

typedef struct  
{
	DataType data[MaxSize];
	int length;
}SeqList;     //结构体重命名

创建 DataType 类型的数组，数组名为 data ，长度为100(MaxSize)
length 代表当前顺序表含有的元素个数 ，该变量在后续操作中有着极大的作用
将该结构重命名为 SeqList ，方便后续代码的书写

数据类型的重定义

typedef int DataType;   //数据类型的重命名

之后如果要使用其他的数据类型，只需要修改此处的 int 大大节省时间

初始化顺序表

void InitList(SeqList* L)   //初始化顺序表
{
	L->length = 0;   //顺序表初始长度位0;
}

只需要将其设置为 0 即可

建立顺序表

int CreatList(SeqList* L, DataType a[], int n)  //创建线性表
{
	if (n > MaxSize)
	{
		cout << "顺序表空间不足，无法构建顺序表";
		return 0;   //建立失败，返回0
	}
	else
	{
		for (int i = 0; i < n; i++)
		{
			L->data[i] = a[i];
		}
		L->length = n;
		return 1;   //建立成功，返回1
	}
}

将数组 a 中的元素依次载入顺序表，n为数组长度，若 n 大于 100(MaxSize) ，则说明该顺序表长度够，无法载入全部数据，返回 0，否则载入成功，返回1

注意：该函数用来将已有的数组中的元素载入顺序表

插入元素

int Insert(SeqList* L, int i, DataType x) //插入元素函数
{
	if (L->length >= MaxSize)
	{
		cout << "上溢错误，插入失败" << endl;
		return 0;
	}
	if (i<1 || i>L->length + 1)  //插入至数组最后一个元素的后面，则位置错误
	{
		cout << "位置错误，插入失败" << endl;
		return 0;
	}
	for (int j = L->length; j >= i; j--)//若插入的元素在线性表最后一个元素及之前，则执行改语句，否则不执行;直接对语句进行追加
	{
		L->data[j + 1] = L->data[j];
	}
	L->data[i-1] = x;  //线性表中插入第3个位置，则在数组则是下标-1的位置，所以要i-1
	L->length += 1;
	return 1;
}

L->length >= MaxSize 判断顺序表是否为满，若顺序表已满无法插入，返回0，并提示上溢错误

i<1 || i>L->length + 1 判断插入的位置是否正确，i 代表插入的位置，插入到小于 1 或者大于 length +1 的位置都是不正确的

（i 最多只能插入到 1 的位置，不能插入到小于 1 的地方；同时 i 最多插入到当前顺序表的最后，即有9个元素，L-> length 等于9 ，最多插入到10，不能插入到11，12等位置，所以要小于length+1）

若位置错误，返回0，并提示错误信息；若没有发生这两种情况，则可以插入，并返回 1

删除元素

int Delete(SeqList* L, int i, DataType* ptr)
{
	if (L->length==0)
	{
		cout << "下溢错误，删除失败" << endl;
		return 0;
	}
	if (i<1 || i>L->length)
	{
		cout << "位置错误，删除失败" << endl;
		return 0;
	}
	*ptr = L->data[i - 1];
	for (int j = i; j < L->length; j++)
	{
		L->data[i - 1] = L->data[i];
	}                              
	L->length -= 1;
	return 1;
}

与插入元素的函数类似，判断删除的位置 i 是否正确，这里与插入的思路相同，不再细讲
若删除成功，则返回 1，否则返回 0 ，和错误信息

查找（按位查找）

int Get(SeqList* L, int i, DataType* ptr)  //按位查找
{
	if (i<1 || i>L->length)
	{
		cout << "查找位置非法，查找失败" << endl;
		return 0;  //查找失败，返回0
	}
	else
	{
		*ptr =L->data[i-1];//线性表第i个元素储存在数组第[i-1]位上
		return 1;
	}
}

先判断查找的位置 i ，是否正确，若正确，则将 data [ i-1 ] 赋值给 *ptr ，并返回 1

解释下为什么是 i - 1，而不是 i ：
在数组中，数据元素存放是从下表 0 开始的，（比如存放 10，20，30这三个元素，在现实中，10在第一个位置，20在第二，30在第三，但在计算机中，10在下标 0 处，20在下表 1 处，30在下标 2处，所以查找第 i 个位置的元素，在数组中的第 i-1个位置处）

查找（按值查找）

int Locate(SeqList* L,DataType x)  //查找,按值查找
{
	for (int i = 0; i < L->length; i++)
	{
		if (x == L->data[i])
			return i + 1;  
	}
	return -1；
}

与按位查找不同，按值查找会遍历整个顺序表，直到找到该值的元素，返回其下标，若没找到，则返回 -1

与按位查找相同，数据在数组中是从0开始的，但我们返回的是现实中该元素的位置，现实中是从1开始的，所以需要加上1

遍历操作

void PrintList(SeqList* L) //遍历操作,输出顺序表中的各数据元素;
{
	for (int i = 0; i < L->length; i++)
	{
		cout << L->data[i] << " ";
	}
}

遍历整个数组，并打印数据到屏幕上

求线性表的长度

int Length(SeqList* L)  //求线性表的长度,输出线性表中元素个个数
{
	return L->length;
}

直接访问结构体的 length 即可

主函数

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	SeqList con;
	InitList(&con);
	CreatList(&con, arr, 10);
	PrintList(&con);
	cout << endl;
	Insert(&con, 1, 100);
	PrintList(&con);
	cout << endl;
	int num = 0;
	Delete(&con, 11, &num);
	cout << num << endl;
	PrintList(&con);
	cout << endl;
	cout << Length(&con) << endl;
	cout << Locate(&con, 2) << endl;
	Get(&con, 5, &num);
	cout << num << endl;
}

运行结果

全部代码

#include<iostream>
using namespace std;
#define MaxSize 100
typedef int DataType;   //数据类型的重定义
typedef struct   //结构体重定义
{
	DataType data[MaxSize];
	int length;
}SeqList;//SeqList : 线性表

void InitList(SeqList* L)   //初始化顺序表
{
	L->length = 0;   //顺序表长度位0;
}
int CreatList(SeqList* L, DataType a[], int n)  //创建线性表
{
	if (n > MaxSize)
	{
		cout << "顺序表空间不足，无法构建顺序表";
		return 0;   //建立失败，返回0
	}
	else
	{
		for (int i = 0; i < n; i++)
		{
			L->data[i] = a[i];
		}
		L->length = n;
		return 1;   //建立成功，返回1
	}
}
void PrintList(SeqList* L) //遍历操作,输出顺序表中的各数据元素;
{
	for (int i = 0; i < L->length; i++)
	{
		cout << L->data[i] << " ";
	}
}
int Length(SeqList* L)  //求线性表的长度,输出线性表中元素个个数
{
	return L->length;
}
int Locate(SeqList* L,DataType x)  //查找,按值查找
{
	for (int i = 0; i < L->length; i++)
	{
		if (x == L->data[i])
			return i + 1;  //顺序表是从1开始的，所以需要加1;
	}
	return -1;
}
int Get(SeqList* L, int i, DataType* ptr)  //按位查找
{
	if (i<1 || i>L->length)
	{
		cout << "查找位置非法，查找失败" << endl;
		return 0;  //查找失败，返回0
	}
	else
	{
		*ptr =L->data[i-1];  //线性表第i个元素储存在数组第[i-1]位上
		return 1;
	}
}
int Insert(SeqList* L, int i, DataType x) //插入元素函数
{
	if (L->length >= MaxSize)
	{
		cout << "上溢错误，插入失败" << endl;
		return 0;
	}
	if (i<1 || i>L->length + 1)  //插入至数组最后一个元素的后面，则位置错误
	{
		cout << "位置错误，插入失败" << endl;
		return 0;
	}
	for (int j = L->length; j >= i-1; j--)//若插入的元素在线性表最后一个元素及之前，则执行改语句，否则不执行;直接对语句进行追加
	{
		L->data[j + 1] = L->data[j];
	}
	L->data[i-1] = x;  //线性表中插入第3个位置，则在数组则是下标-1的位置，所以要i-1
	L->length += 1;
	return 1;
}
int Delete(SeqList* L, int i, DataType* ptr)
{
	if (L->length==0)
	{
		cout << "下溢错误，删除失败" << endl;
		return 0;
	}
	if (i<1 || i>L->length)
	{
		cout << "位置错误，删除失败" << endl;
		return 0;
	}
	*ptr = L->data[i - 1];
	for (int j = i; j < L->length; j++)
	{
		L->data[i - 1] = L->data[i];
	}                                     //感觉最后一个元素会残留
	L->length -= 1;
	return 1;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	SeqList con;
	InitList(&con);
	CreatList(&con, arr, 10);
	PrintList(&con);
	cout << endl;
	Insert(&con, 1, 100);
	PrintList(&con);
	cout << endl;
	int num = 0;
	Delete(&con, 11, &num);
	cout << num << endl;
	PrintList(&con);
	cout << endl;
	cout << Length(&con) << endl;
	cout << Locate(&con, 2) << endl;
	Get(&con, 5, &num);
	cout << num << endl;
}