数据结构：顺序表的基本操作和还原

 

一、实验学时： 2学时

二、实验目的

实现顺序表的基本操作

三、实验内容

定义顺序表(可用结构体实现)、所需要的符号常量以及在该顺序表上所进行的操作（用函数实现）初始化、插入新元素、删除指定元素、查找（返回指定元素位置）、检索指定位置的元素。

  要求：1、在主函数中调用各个函数实现相应操作，首先定义顺序表对象L，调用函数对顺序表进行初始化，再通过多次插入方式动态创建一个长度为10的顺序表（可通过在循环中调用插入函数来实现。之后再进行删除、查找、检索指定元素操作。

        2、事先写出算法和程序，并加上相应注释。

        3、主函数中可通过输出语句实现友好提示操作。

        4、具体设计结果参考如下图所示：

     

根据上面这些实验要求，我结合郝斌老师数据结构视频上的代码，完成了这次作业。

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h> 
#define MAXSIZE 10	 

struct Arr
{
	int * pBase; 								//存储的是数组第一个元素的地址
	int len; 									//数组所能容纳的最大元素的个数
	int cnt; 									//当前数组有效元素的个数
};

void init_arr(struct Arr *pArr, int length);				//创建顺序表
bool append_arr(struct Arr * pArr);							//输入数值 
void show_arr(struct Arr * pArr); 							//输出 
bool delete_arr(struct Arr * pArr, int pos, int * pVal);	//删除 
bool insert_arr(struct Arr * pArr, int pos, int val);		//插入 注：pos为第pos个数 
bool search_val(struct Arr * pArr, int pos);
bool search_pos(struct Arr * pArr, int val);

int main (void)
{
	Arr arr;
	int val;										//临时存放输入的值 
	int pos;
	
	init_arr(&arr, MAXSIZE); 						//创建长度存放10个整型数的顺序表 
	for(int i = 1; i <= 10; i++){					//向表中添加值 
		printf("please input the %d th list elme:", i);
		append_arr(&arr); 
	}
	printf("表长为：%d\n", MAXSIZE);				//显示表长 
	show_arr(&arr);
	delete_arr(&arr, pos, &val);
	show_arr(&arr);
	insert_arr(&arr, pos, val);
	show_arr(&arr);
	search_val(&arr, pos);
	search_pos(&arr, val);
	
	return 0;
} 

void init_arr(struct Arr *pArr, int length)
{
	length = MAXSIZE;
	pArr->pBase = (int *)malloc(sizeof(int) * length);	//创建动态数组 
	pArr->cnt=0; 										//给cnt初始化 
	return; 
}

bool append_arr(struct Arr * pArr)	
{	
	int val;
	scanf("%d", &val);								//输入val值 
	pArr->pBase[pArr->cnt] = val;					//val赋值给动态数组中的存储单元 
	
	(pArr->cnt)++;									//cnt的最终结果为 MAXSIZE = 10 
	
	return true; 
}

void show_arr(struct Arr * pArr)
{ 
	for (int j = 0; j < pArr->cnt; j++){
		printf("%d  ", pArr->pBase[j]); 
	}												//for循环输出	
	printf("\n");			
} 

bool delete_arr(struct Arr * pArr, int pos, int * pVal)
{
	if(pos < 1 || pos > pArr->cnt) {				//位置pos小于1或大于cnt均无效 
		printf("无效位置\n");
		return false;
	}
	printf("请输入删除元素的位置：");
	scanf("%d", &pos); 
	*pVal = pArr->pBase[pos-1]; 					//pos-1为该数的下标 
	for (int i=pos; i < pArr->cnt; ++i){
		pArr->pBase[i-1] = pArr->pBase[i];			//前移一位 
	} 
	pArr->cnt--;									//有效位数减1 
	printf("删除的位置：%d\n", pos);
	printf("删除元素的值为：%d\n", *pVal);
	printf("删除后的表： ");
	
	return true; 
}

bool insert_arr(struct Arr * pArr, int pos, int val)
{
	if(pos < 1 || pos > pArr->cnt) {				//位置pos小于1或大于cnt均无效 
		printf("无效位置\n");
		return false;
	}
	printf("请输入插入元素的位置：");
	scanf("%d", &pos);
	printf("请输入插入元素的值：") ;
	scanf("%d", &val);
	for(int i = pArr->cnt-1;i >= pos-1; i--  ){		//只能从后往前 
		pArr->pBase[i+1] = pArr->pBase[i];
	}
	pArr->pBase[pos-1] = val; 
	(pArr->cnt)++;
	printf("插入以后的表：");
	
	return true;
}
 
bool search_val(struct Arr * pArr, int pos)
{
	if(pos < 1 || pos > pArr->cnt) {				//位置pos小于1或大于cnt均无效 
		printf("无效位置\n");
		return false;
	}
	printf("要检索的元素的位置：");
	scanf("%d", &pos); 
	printf("该元素的值为：%d\n", pArr->pBase[pos-1]);
	
	return true;
}

bool search_pos(struct Arr * pArr, int val)
{
	printf("要查找的元素值为：");
	scanf("%d", &val);
	printf("查找成功，元素位置为：");
	for(int i = 0; i < pArr->cnt; i++){				//如果多个位置上有val呢？？？
	 if(val == pArr->pBase[i]){
	 	printf("%d  ", i+1);
		}
	} 
	
	return true;
}

编译运行都通过了，也达到了题目的要求，不知道还有没有其他的问题。

下面附上郝斌老师数据结构视频上的代码

# include <stdio.h>
# include <malloc.h>  //包含了malloc函数
# include <stdlib.h>  //包含了exit函数

//定义了一个数据类型，该数据类型的名字叫做struct Arr, 该数据类型含有三个成员，分别是pBase, len, cnt
struct Arr
{
	int * pBase; //存储的是数组第一个元素的地址
	int len; //数组所能容纳的最大元素的个数
	int cnt; //当前数组有效元素的个数
};

void init_arr(struct Arr * pArr, int length);  //分号不能省
bool append_arr(struct Arr * pArr, int val); //追加
bool insert_arr(struct Arr * pArr, int pos, int val); // pos的值从1开始
bool delete_arr(struct Arr * pArr, int pos, int * pVal);
int get();
bool is_empty(struct Arr * pArr);
bool is_full(struct Arr * pArr);
void sort_arr(struct Arr * pArr);
void show_arr(struct Arr * pArr); 
void inversion_arr(struct Arr * pArr);

int main(void)
{
	struct Arr arr;
	int val;
	
	init_arr(&arr, 6);
	show_arr(&arr);
	append_arr(&arr, 1);
	append_arr(&arr, 10);
	append_arr(&arr, -3);
	append_arr(&arr, 6);
	append_arr(&arr, 88);
	append_arr(&arr, 11);
	if ( delete_arr(&arr, 4, &val) )
	{
		printf("删除成功!\n");
		printf("您删除的元素是: %d\n", val);
	}
	else
	{
		printf("删除失败!\n");
	}

	show_arr(&arr);
	inversion_arr(&arr);
	printf("倒置之后的数组内容是:\n");
	show_arr(&arr);
	sort_arr(&arr);
	show_arr(&arr);

	//printf("%d\n", arr.len);

	return 0;
}

void init_arr(struct Arr * pArr, int length)
{
	pArr->pBase = (int *)malloc(sizeof(int) * length);
	if (NULL == pArr->pBase)
	{
		printf("动态内存分配失败!\n");
		exit(-1); //终止整个程序
	}
	else
	{
		pArr->len = length;
		pArr->cnt = 0;
	}
	return;
}

bool is_empty(struct Arr * pArr)
{
	if (0 == pArr->cnt)
		return true;
	else
		return false;		
}

bool is_full(struct Arr * pArr)
{
	if (pArr->cnt == pArr->len)
		return true;
	else
		return false;
}

void show_arr(struct Arr * pArr)
{
	if ( is_empty(pArr) )   
	{
		printf("数组为空!\n");
	}
	else
	{
		for (int i=0; i<pArr->cnt; ++i)
			printf("%d  ", pArr->pBase[i]); //int *
		printf("\n");
	}
}

bool append_arr(struct Arr * pArr, int val)
{
	//满是返回false
	if ( is_full(pArr) )
		return false;

	//不满时追加
	pArr->pBase[pArr->cnt] = val; 
	(pArr->cnt)++;
	return true;
}

bool insert_arr(struct Arr * pArr, int pos, int val)
{
	int i;

	if (is_full(pArr))
		return false;

	if (pos<1 || pos>pArr->cnt+1)  //
		return false;

	for (i=pArr->cnt-1; i>=pos-1; --i)
	{
		pArr->pBase[i+1] = pArr->pBase[i];
	}
	pArr->pBase[pos-1] = val;
	(pArr->cnt)++;
	return true;
}

bool delete_arr(struct Arr * pArr, int pos, int * pVal)
{
	int i;

	if ( is_empty(pArr) )
		return false;
	if (pos<1 || pos>pArr->cnt)
		return false;

	*pVal = pArr->pBase[pos-1];
	for (i=pos; i<pArr->cnt; ++i)
	{
		pArr->pBase[i-1] = pArr->pBase[i];
	}
	pArr->cnt--;
	return true;
}

void inversion_arr(struct Arr * pArr)
{
	int i = 0;
	int j = pArr->cnt-1;
	int t;

	while (i < j)
	{
		t = pArr->pBase[i];
		pArr->pBase[i] = pArr->pBase[j];
		pArr->pBase[j] = t;
		++i;
		--j;
	}
	return;
}

void sort_arr(struct Arr * pArr)
{
	int i, j, t;

	for (i=0; i<pArr->cnt; ++i)
	{
		for (j=i+1; j<pArr->cnt; ++j)
		{
			if (pArr->pBase[i] > pArr->pBase[j])
			{
				t = pArr->pBase[i];
				pArr->pBase[i] = pArr->pBase[j];
				pArr->pBase[j] = t;
			}
		}
	}
}