数据结构——线性表之顺序表的完整详细操作（实验报告）

数据结构

一、顺序表的基本操作

先新建一个项目，就叫SeqList
再新建三个文件

SeqList.h文件

#ifndef SEQLIST_H_INCLUDED
#define SEQLIST_H_INCLUDED
#include
#define OK 1
#define LIST_INIT_SIZE 100	//线性表初始化存储空间的初始分配量
#define LISTINCREMENT 10	//线性表存储空间的分配增量
using namespace std;
//顺序表数据结构
typedef int Status;
typedef int ElemType;
typedef struct
{
	ElemType* data;     //顺序表元素
	int length;         //顺序表当前长度
	int listsize;       //当前分配的存储容量
}SqList;

//初始化顺序表函数，构造一个空的顺序表
Status InitList(SqList &L);
//创建顺序表函数 初始化前n个数据
Status CreateList(SqList &L, int n);
//插入函数
bool InsertList(SqList &L, int i, ElemType e);
//删除函数
bool ListDelete(SqList &L, int i);
//顺序查找函数
int SeqLocateElem(SqList L, ElemType e);
//二分查找函数
int BinLocateElem(SqList L, ElemType e);
//快排
void QuickSort(SqList& L);
//倒置函数
void Reverse(SqList &L);
//清空顺序表
void ClearList(SqList &L);

//输出功能函数 按位置从小到大输出顺序表所有元素
void PrintList(SqList L);
//创建顺序表函数
void Create(SqList &L);
//插入功能函数
void Insert(SqList &L);
//删除功能函数
void Delete(SqList &L);
//查找功能函数 调用SeqLocateElem查找元素
void SequentialSearch(SqList L);
//查找功能函数 调用BinLocateElem查找元素
void BinarySearch(SqList L);
//排序 调用QuickSort排序
void Sort(SqList& L);
//菜单
void menu();

#endif // SEQLIST_H_INCLUDED

//注意 顺序表从0开始 代表的是第1个元素

SeqList.cpp文件

#include"SeqList.h"
//***************************基本操作函数*******************************//

//初始化顺序表函数，构造一个空的顺序表
Status InitList(SqList &L)
{
	L.data = (ElemType*)malloc(sizeof(ElemType)*LIST_INIT_SIZE);
	if(!L.data)exit(OVERFLOW);
	L.length = 0;                //初始化长度为0
	L.listsize = LIST_INIT_SIZE;
	return OK;
}

//创建顺序表函数 初始化前n个数据
Status CreateList(SqList &L, int n)
{
    ElemType* newbase;
	if(n>=L.listsize){
        newbase=(ElemType*)realloc(L.data,sizeof(ElemType)*(n+LISTINCREMENT));
        if(!L.data)exit(OVERFLOW);
        L.data=newbase;
        L.listsize=n+LISTINCREMENT;
	}
	for (int i = 0; i<n; i++)
	{
		scanf("%d", &L.data[i]);
		L.length++;
	}
	return OK;
}

//插入函数 位置i插入数据 i及之后元素后移  1=
bool InsertList(SqList &L, int i, ElemType e)
{
    ElemType* newbase;
	if (i<1 || i>L.length + 1) //判断位置是否有效
	{
		printf("位置无效！！！\n");
		return false;
	}
	if (L.length >= L.listsize)//判断存储空间是否已满
	{
		newbase=(ElemType*)realloc(L.data,sizeof(ElemType)*(L.listsize+LISTINCREMENT));
        if(!L.data)exit(OVERFLOW);
        L.data=newbase;
        L.listsize+=LISTINCREMENT;
	}
	for (int j = L.length; j >= i; j--)//位置i及之后元素后移
	{
		L.data[j] = L.data[j - 1];
	}
	L.data[i - 1] = e;
	L.length++;
	return true;
}

//删除函数 删除位置i的元素 i之后的元素依次前移
bool  ListDelete(SqList &L, int i)
{
	if (i<1 || i>L.length)
	{
		printf("位置无效！！！\n");
		return false;
	}
	for (int j = i; j <= L.length - 1; j++)//位置i之后元素依次前移覆盖
	{
		L.data[j - 1] = L.data[j];
	}
	L.length--;
	return true;
}

//顺序查找函数
int SeqLocateElem(SqList L, ElemType e)
{
	for (int i = 0; i<L.length; i++)//从低位置查找
	{
		if (L.data[i] == e)
			return i + 1;
	}
	return 0;
}

//二分查找函数
int BinLocateElem(SqList L, ElemType e){
    int low=0,high=L.length;
    int mid;
    while(low<=high){
        mid=(low+high)/2;
        if(e==L.data[mid])return mid+1;
        else if(e>L.data[mid])low=mid+1;
        else high=mid-1;
    }
    return 0;
}

//快排
void QuickSort(SqList& L,int low,int high){
    if(low>=high)return;
    int i=low,j=high;
    int key=L.data[low];
    while(i<j){
        while(i<j&&key<=L.data[j])j--;
        if(i<j)L.data[i++]=L.data[j];
        while(i<j&&key>L.data[i])i++;
        if(i<j)L.data[j--]=L.data[i];
    }
    L.data[i]=key;
    QuickSort(L,low,i-1);
    QuickSort(L,i+1,high);
}

//倒置函数
void Reverse(SqList &L)
{
	if (L.length)
		for (int i = 0; i<L.length - 1 - i; i++)
		{
			int t = L.data[i];
			L.data[i] = L.data[L.length - 1 - i];
			L.data[L.length - 1 - i] = t;
		}
}

//清空顺序表
void ClearList(SqList &L) {
	L.length = 0;
}

//********************************功能函数*****************************************//

//输出功能函数 按位置从小到大输出顺序表所有元素
void PrintList(SqList L)
{
	printf("当前顺序表所有元素:");
	for (int i = 0; i<L.length; i++)
	{
		printf("%d ", L.data[i]);
	}
	printf("\n");
}

//创建顺序表函数
void Create(SqList &L)
{
	int n;
	printf("请输入要创建的顺序表长度(>1):");
	scanf("%d", &n);
	printf("请输入%d个数（空格隔开,可无序输入）:", n);
	if(CreateList(L, n)) {
		printf("创建成功！\n");
		QuickSort(L,0,n-1);
		PrintList(L);
	}
}

//插入功能函数 调用InsertList完成顺序表元素插入 调用PrintList函数显示插入成功后的结果
void Insert(SqList &L)
{
	int place; ElemType e; bool flag;
	printf("请输入要插入的位置(从1开始)及元素:");
	scanf("%d%d", &place, &e);
	flag = InsertList(L, place, e);
	if (flag)
	{
		printf("插入成功！！！\n");
		PrintList(L);
	}
}

//删除功能函数 调用ListDelete函数完成顺序表的删除 调用PrintList函数显示插入成功后的结果
void Delete(SqList &L)
{
	int place; bool flag;
	printf("请输入要删除的位置(从1开始):");
	scanf("%d", &place);
	flag = ListDelete(L, place);
	if (flag)
	{
		printf("删除成功！！！\n");
		PrintList(L);
	}
}

//查找功能函数 调用SeqLocateElem查找元素
void SequentialSearch(SqList L)
{
	ElemType e; int flag;
	printf("请输入要查找的值:");
	scanf("%d", &e);
	flag = SeqLocateElem(L, e);
	if (flag)printf("该元素位置为:%d\n", flag);
	else printf("未找到该元素！\n");
}

//查找功能函数 调用BinLocateElem查找元素
void BinarySearch(SqList L){
    ElemType e; int flag;
	printf("请输入要查找的值:");
	scanf("%d", &e);
	flag = BinLocateElem(L, e);
	if (flag)printf("该元素位置为:%d\n", flag);
	else printf("未找到该元素！\n");
}

//排序 调用QuickSort排序
void Sort(SqList& L){
    QuickSort(L,0,L.length-1);
    cout<<"排序成功！！！"<<endl;
    PrintList(L);
}

//菜单
void menu()
{
    cout<<"\t\tHello,this is SeqList\n"
        "\t===================================\n"
        "\tplease select the operation you want:\n"
        "\t1. 创建\n"
        "\t2. 插入\n"
        "\t3. 删除\n"
        "\t4. 顺序查找\n"
        "\t5. 折半查找\n"
        "\t6. 倒置\n"
        "\t7. 输出\n"
        "\t8. 清空\n"
        "\t9. 排序\n"
        "\t0. 退出\n"
        <<endl;
}

main.cpp文件

#include "SeqList.h"
using namespace std;

int main()
{
    SqList L; int choice;
	InitList(L);
	menu();
	while (1)
	{
		printf("\n>>>请选择你的操作：");
		scanf("%d", &choice);
		switch (choice)
		{
		case 1:Create(L); break;
		case 2:Insert(L); break;
		case 3:Delete(L); break;
		case 4:SequentialSearch(L); break;
		case 5:BinarySearch(L);break;
		case 6:Reverse(L); break;
		case 7:PrintList(L); break;
		case 8:ClearList(L); break;
		case 9:Sort(L); break;
        case 0:exit(1);
		default:printf("输入错误！\n");
		}
	}
    return 0;
}

运行结果