关于数据结构中顺序表的问题

Posted 2023-03-24

1.建立顺序表
2.在表中插入元素
3.在表中查找元素
4.在表中删除元素
注：要建表、插入、查找、删除分开的，能在VC下运行并带注释的。
急急...

把这个直接粘到VC里运行, 看一下就知道~

#include <iostream.h>
#include<stdlib.h>
#define MAX 100
typedef int datatype;
typedef struct List

datatype elem[MAX];
int Last;
*SeqList;
SeqList InitList() //初始化顺序表

SeqList L;
L=(SeqList)malloc(sizeof(List));
L->Last=-1;
return L;

void CreateList(SeqList L) //创建顺序表

int n;
cout<<"请输入你要创建的顺序表元素个数n= ";
cin>>n;
cout<<"请输入你要创建的顺序表:";
for(int i=0;i<n;i++)

cin>>L->elem[i];
L->Last++;


int Location(SeqList L,datatype x) //查找某元素所在位置

int i=0;
while(L->elem[i]!=x&&i<=L->Last)

i++;

if(i>L->Last)
return -1;
else
return i;

void Insertelem(SeqList L,datatype m) //插入元素

int n;
cout<<"请输入你要插入的位置n=";
cin>>n;
if((L->Last+1)>MAX)
cout<<"表以满,能插入"<<endl;
else

L->Last++;
for(int i=L->Last;i>=n-1;i--)

L->elem[i+1]=L->elem[i];

L->elem[n-1]=m;


void Deleteelem(SeqList L,datatype m) //删除表中某元素

int i;

i=Location(L,m);
while(i==-1)

datatype n;
cout<<"你所查找的元素不在表中,请重新输入你要删除的元素"<<endl;
cin>>n;
i=Location(L,n);

for(int j=i;j<=L->Last;j++)

L->elem[i]=L->elem[i+1];

L->Last--;

void ShowList(SeqList L) //显示当前顺序表

cout<<"当前顺序表元素为:";
for(int i=0;i<=L->Last;i++)

cout<<L->elem[i]<<" ";

cout<<endl;

void main()

SeqList L;
L=InitList();
CreateList(L);
int Opration;
cout<<"输入操作(1)为删除某元素(2)为插入(3)为查找(4)为输出当前顺序表(5)为退出"<<endl;
while(Opration!=5)

cin>>Opration;
if(Opration==1)

int n;
cout<<"请输入你要删除的元素n=";
cin>>n;
Deleteelem(L,n);

if(Opration==2)

int n;
cout<<"请输入你要插入的元素n=";
cin>>n;
Insertelem(L,n);

if(Opration==3)

datatype x;
cout<<"请输入你要查找的元素x=";
cin>>x;
cout<<"此元素在顺序表中的位置为:"<<Location(L,x)+1<<endl;

if(Opration==4)

ShowList(L);

if(Opration==5)

break;


参考技术A //以前写的，你自己改改吧。
#define max 50//定义数组长度
#include<iostream>
using namespace std;
typedef int elem;//定义数组元素的类型
struct sqlist

elem a[max];
int length;
;
///用1表示操作能完成，0表示不能
void Init_list(sqlist *&L)//建立

L=new sqlist;
L->length=0;

void Destory_list(sqlist *&L)//摧毁

delete L;

int List_empty(sqlist *L)//判断是否为空

return L->length==0;

int List_length(sqlist *L)//有多少个元素

return L->length;

void Dis_list(sqlist *L)//显示元素

int i;
if(List_length(L)==0) cout<<"There is no elem in the list"<<endl;
else

for(i=0;i<L->length;i++)
cout<<L->a[i]<<endl;


int Get_listelem(sqlist *L,int i,elem &e)//求出表中第i个元素

if(i>L->length+1||i<1) return 0;
e=L->a[i-1];
return 1;

int Locate_listelem(sqlist *L,elem x,elem &e)//判断x是表中第几个元素

int i;
for(i=0;i<L->length;i++)
if(x==L->a[i]) e=i+1;return 1;
return 0;

int Insert_listelem(sqlist *&L,elem x,int i)//在第i个位置插入新元素x

if(i<1||i>L->length) return 0;
i--;
int j;
for(j=L->length;j>i;j--)

L->a[j]=L->a[j-1];

L->a[i]=x;
L->length++;
return 1;

void Listinsert(sqlist *&L,elem x) //如果表为顺序表(从小到大)，插入一个元素也使之为顺序表

int i,t;
for(i=0;i<L->length;i++)
if(x<L->a[i]) break;
t=i;
for(i=L->length;i>t;i--)

L->a[i]=L->a[i-1];

L->a[t]=x;
L->length++;

int Delete_listelem(sqlist *&L,int i)//删除第i个元素

int j;
if(i<1||i>L->length) return 0;
i--;
for(j=i;j<L->length-1;j++)
L->a[j]=L->a[j+1];
L->length--;
return 1;

数据结构_关于顺序表的深入思考

顺序表

---

文章目录

• 顺序表
• 一、顺序表
• • 1、顺序表的实现
  • 2、顺序表的初始化
  • 3、对顺序表的具体操作

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、顺序表

1、顺序表的实现

顺序表一般采用结构体的方式来实现
下面展示一些 内联代码片。

typedef struct SeqList
{
	SLDateType* base;
	size_t capacity;
	size_t size;
}SeqList;

如上展示的就是一段我简单构造顺序表的代码，其中我定义了SLDateType为int，所以base的类型就是int类型的数组，用它可以来储存要存放的数据，而capacity则代表了顺序表的最大容量，size代表的是当前存放数据的个数；

2、顺序表的初始化

对于一个顺序表来说，初始化是必不可少的；
下面展示一些 内联代码片。

void SeqListInit(SeqList* ps, size_t capacity);
void SeqListInit(SeqList* ps, size_t capacity)
{
	ps->capacity = capacity;
	ps->base = (SLDateType*)malloc(sizeof(SLDateType) * ps->capacity);
	assert(ps->base != NULL);
	memset(ps->base, 0,sizeof(SLDateType)*(ps->capacity));
	ps->size = 0;
}

这里我用malloc为ps->base 开辟了数据存储空间(记得要类型转换！！)开辟了空间后还要进行判空(重点），之后我使用了memset对新开辟的空间进行了初始化，然后对ps->size进行了赋0操作，这样顺序表的初始化就好了；

3、对顺序表的具体操作

因为我用的是C语言构造顺序表，所以我个人习惯于用"->"来访问顺序表中的元素:
下面展示一些 内联代码片。

void SeqListPrint(SeqList* ps);//展示顺序表中的元素
void SeqListPrint(SeqList* ps)
{
	for (int i = 0; i< ps->size; i++) {
		printf(" %d", ps->base[i]);
	}
	printf("\\n");
}


void SeqListPushBack(SeqList* ps, SLDateType x);//在尾部添加元素
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	//检查容量
	if (ps->size == ps->capacity) {
		printf("顺序表的容量不足,%d不能插入\\n", x);
		return;
	}
	ps->base[ps->size] = x;
	ps->size++;

}
void SeqListPushFront(SeqList* ps, SLDateType x);  //在首部添加元素
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	if (ps->size == ps->capacity) {
		printf("顺序表的容量不足,%d不能插入\\n", x);
		return;
	}
	for (int i = ps->size; 0<i ; i--) {
		ps->base[i] = ps->base[i - 1];
	}
	ps->base[0] = x;
	ps->size++;
}
void SeqListPopFront(SeqList* ps);//在首部删除元素
void SeqListPopFront(SeqList* ps)
{
	if (ps->size == 0)
		printf("无元素，不可删除\\n");
	for (int i = 0; i < ps->size; i++) {
		ps->base[i] = ps->base[i + 1];
	}
	ps->size--;
}
void SeqListPopBack(SeqList* ps);//在尾部删除元素
void SeqListPopBack(SeqList* ps)
{   
	if (ps->size == 0)
		printf("无元素，不可删除\\n");
	ps->size--;
}

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);
int SeqListFind(SeqList* ps, SLDateType x)
{   
	int count = 0;
	for (int i = 0; i< ps->size; i++) {
		if (x == ps->base[i]) {
			count++;
			printf(" %d", i);
		}
	}
	if (count == 0)
	{
		printf("没有此元素\\n");
	}
	else
	{
		printf("\\n");
	}
}
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, size_t pos, SLDateType x);
void SeqListInsert(SeqList* ps, size_t pos, SLDateType x)
{
	if (pos > ps->size)
	{
		printf("操作有误");
		return;
	}

	for (int i = ps->size; i > pos; i--)
	{
		ps->base[i] = ps->base[i-1];
	}
	ps->base[pos] = x;
		ps->size++;
}
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, size_t pos);
void SeqListErase(SeqList* ps, size_t pos) {
	if (pos < 0 ||pos > ps->size)
	{
		printf("操作有误");
		return;
	}
	for (int i = pos; i < ps->size; i++) {
		ps->base[i] = ps->base[i + 1];
	}
	ps->size--;
}
void SeqListDestory(SeqList* ps);
void SeqListDestory(SeqList* ps)
{
	free(ps->base);
	ps->base = NULL;
	ps->capacity = ps->size = 0;
}
void SeqListClear(SeqList* ps);
void SeqListClear(SeqList* ps)
{
	ps->size = 0;
}
int SeqListFindByVal(SeqList* ps, SLDateType key);
int SeqListFindByVal(SeqList* ps, SLDateType key)
{
	for (int i = 0; i < ps->size; i++)
	{
		if (key == ps->base[i])
			return i;
	}
}
void SeqListSort(SeqList* ps);
void SeqListSort(SeqList* ps)
{
	for (int i = 0; i < ps->size - 1; i++)
	{ 
		bool is_sawp = false;
		for (int j = 0; j < ps->size - i - 1; j++)
		{
			if (ps->base[j] > ps->base[j + 1])
				Sawp(&(ps->base[j]), &(ps->base[j + 1]));
			is_sawp = true;
		}
		if (!is_sawp)
			break;
	}	
}
bool _IsFulll(SeqList* ps);
bool _IsFulll(SeqList* ps)
{
	return ps->capacity = ps->size;
}
bool _IsEmpty(SeqList* ps);
bool _IsEmpty(SeqList* ps)
{
	return ps->size = 0;
}
bool _IsFull(SeqList* ps);
bool _IsFull(SeqList* ps)
{
	ps->base = (SLDateType*)realloc(ps->base, sizeof(SLDateType) * (ps->capacity + INC));
	if (ps->base = NULL)
		return false;
	ps->capacity += INC;
}