C++实现顺序表

顺序表：使用一维数组来存储数据

list.h

#pragma once
#define MAXSIZE 100			//表述顺序表可能达到的最大长度
#define OK 		1
#define ERROR 	0
#define TRUE 	1
#define FALSE 	0

typedef int ElemType;
typedef int Status;			//表示每次操作的状态

typedef struct
{
	ElemType *data;			//储存空间的基地址
		int MAXsize;		//顺序表的最大长度
		int length;			//顺序表的当前长度
}SqList;

Status Initlist(SqList &L);								//顺序表的初始化
void ListTraverse(const SqList L);						//顺序表的遍历
Status Insertlist(SqList &L,int p,int e);				//指定位置插入元素
Status GetElem(const SqList L, int p, int &e);			//查找指定位置元素
Status LocateElem(const SqList L, int &p, int e);		//查找指定元素,返回位置
Status DeleteElem(SqList &L, int p,int &e);				//删除指定位置元素
void Clearlist(SqList &L);								//清空顺序表

oper_func.cpp

#include "list.h"
#include<iostream>
Status Initlist(SqList &L)
{
	L.data = new ElemType[MAXSIZE];
	L.MAXsize = MAXSIZE;
	L.length = 0;
	return OK;
}

void ListTraverse(const SqList L)
{
	using std::cout;
	using std::endl;
	if (L.length == 0)
	{
		cout << "顺序表为空，无法遍历输出!" << endl;
		return;
	}
	cout << "顺序表中的数据为：";
	for (int i = 0; i < L.length; i++)
		cout << L.data[i] << '\t';
	cout << endl;
}

Status Insertlist(SqList &L, int p, int e)
{
	if (p<1 || p>(L.length+1))			//判断插入位置的合理性
	{
		return FALSE;
	}
	else if (L.length >= MAXSIZE)
	{
		return FALSE;
	}
	else
	{
		//先将位置p到后面的元素，往后移动一个位置
		for (int i = L.length; i >= p; i--)
		{
			L.data[i] = L.data[i - 1];
		}
		L.data[p - 1] = e;				//指定位置插入元素
		L.length++;
		return OK;
	}
}

Status GetElem(const SqList L, int p, int &e)
{
	if (L.length == 0 || p<1 || p>L.length)				//判断查找位置的合理性
	{
		return FALSE;
	}
	else
	{
		e = L.data[p - 1];								//使用引用返回查找的元素值
		return OK;
	}
}

Status LocateElem(const SqList L, int &p, int e)
{
	for (int i = 0; i < L.length; i++)
	{
		if (L.data[i] == e)
		{
			p = i + 1;
			return OK;
		}
	}
	return FALSE;
}

Status DeleteElem(SqList &L, int p, int &e)
{
	if (L.length == 0 || p<1 || p>L.length)			//判断删除位置的合理性
	{
		return FALSE;
	}
	else
	{
		e = L.data[p - 1];
		for (int i = p - 1; i < L.length-1; i++)
		{
			L.data[i] = L.data[i + 1];
		}
		L.length--;
		return	OK;
	}
}

void Clearlist(SqList &L)
{
	L.length = 0;
	L.MAXsize = 0;
	delete[]L.data;
}

main.cpp

// 顺序表.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
/*
顺序表的静态分配：顺序表长度确定之后，无法更改
#define MAXSIZE 10			表述顺序表的最大长度
typedef int ElemType;
typedef struct
{
	ElemType data[MAXSIZE];			存储数据
	int length;						顺序表的当前长度
}SqList;

顺序表的动态分配：动态分配顺序表长度
#define MAXSIZE 100			表述顺序表可能达到的最大长度
typedef int ElemType;
typedef struct
{
	ElemType *data;			储存空间的基地址
	int MAXsize;			顺序表的最大长度
	int length;				顺序表的当前长度
}SqList;

所有都要有反馈，是否成功，bool值
1、初始化顺序表：初始值初始化为0，长度为0
2、增加顺序表的长度
3、查找指定元素，返回位置：冗余操作（1、顺序表为空；2、位置是否合法；3、引用返回查找的值）
4、查找指定位置元素
5、指定位置插入元素：冗余操作（1、满了没有；2、位置是否合法）
6、删除指定位置元素：冗余操作（1、顺序表为空；2、位置是否合法；3、引用返回删除的值）
7、删除指定元素
8、遍历顺序表
9、合并顺序表
*/
#include <iostream>
#include "list.h"

void showMenu()
{
	using std::cout;
	using std::cin;
	using std::endl;
	cout << "*********************************************************" << endl;
	cout << "*** 1.指定位置插入元素			2.查找指定位置元素 ***" << endl;
	cout << "*** 3.查找指定元素，返回位置		4.删除指定位置元素 ***" << endl;
	cout << "*** 5.遍历顺序表			6.清空顺序表 ***" << endl;
	cout << "*********************  0.退出顺序表  ********************" << endl;
	cout << "*********************************************************" << endl;
}

int main()
{
	using std::cout;
	using std::cin;
	using std::endl;
	int select = 0,flag = -1;			//输入的选择
	SqList L_list;			//创建顺序表
	if (Initlist(L_list))
		cout << "顺序表初始化成功！" << endl;
	else
		cout << "顺序表初始化失败！" << endl;
	while (true)
	{
		showMenu();
		cout << "输入你的选择：";
		cin >> select;
		switch (select)
		{
		case 1: {	//指定位置插入元素
			int position = 0, elem = 0;
			cout << "输入插入的位置和元素:";
			cin >> position >> elem;
			if (Insertlist(L_list, position, elem))
			{
				cout << "指定位置插入元素成功！" << endl;
			}
			else
			{
				cout << "插入位置越界或者顺序表已经满了，无法插入元素！" << endl;
			}
		}
			break;
		case 2: {	//查找指定位置元素
			int position = 0, elem = 0;
			cout << "输入指定位置:";
			cin >> position;
			if (GetElem(L_list, position, elem))
			{
				cout << "查找指定位置元素成功！，元素为：" << elem << endl;
			}
			else
			{
				cout << "顺序表为空或者查找位置不合理！" << endl;
			}
		}
			break;
		case 3: {	//查找指定元素，返回位置
			int position = 0, elem = 0;
			cout << "输入指定元素:";
			cin >> elem;
			if (LocateElem(L_list, position, elem))
			{
				cout << "查找指定元素成功！位置为：" << position << endl;
			}
			else
			{
				cout << "顺序表不存在此元素！" << endl;
			}
		}
			break;
		case 4: {	//删除指定位置元素
			int position = 0,elem = 0;
			cout << "输入指定位置:";
			cin >> position;
			if (DeleteElem(L_list, position, elem))
			{
				cout << "删除指定位置元素成功！元素为：" << elem << endl;
			}
			else
			{
				cout << "顺序表为空或者删除位置不合理！" << endl;
			}
		}
			break;
		case 5:
			ListTraverse(L_list);
			break;
		case 6: {	//清空顺序表
			Clearlist(L_list);							//避免重复delete和忘记delete
			flag++;
		}
			break;
		case 0: {
			cout << "退出顺序表!" << endl;
			if (flag == -1)
			{
				Clearlist(L_list);						//避免重复delete和忘记delete
			}
			system("pause");
			return 0;
		}
			break;
		}
	}
	return 0;
}