数据结构 ——连续存储数组的算法

<pre name="code" class="cpp"><strong>//由于学习数据结构的时候感觉操作代码很乱，且不全，所以学习后整理如下，仅供参考：</strong>

<strong>//连续存储数组的算法：</strong>

<strong>
</strong>

#include<stdio.h>     //标准输入输出，百度百科很详细
#include<malloc.h>    //malloc函数头文件
#include<stdlib.h>    //exit(-1)函数头文件

struct Arr            //数组结构体定义
{
	int *pBase;       //第一个元素地址
	int len;          //数组最多长度
	int cnt;          //数组有效数的长度
};

void init_arr(struct Arr*pArr,int length);               //初始化函数声明
bool empty_arr(struct Arr*pARrr);                        //判断为空函数声明 
void show_arr(struct Arr*pArr);                          //显示函数声明
bool full_arr(struct Arr*pArr);                          //判断为满函数声明
bool append_arr(struct Arr*pArr,int val);                //追加函数声明 
bool insert_arr(struct Arr*pArr,int pos,int val);        //插入函数声明
bool delete_arr(struct Arr*pArr,int pos,int *pVal);      //删除函数声明
void inversion_arr(struct Arr*pArr);                     //倒置函数声明
void sort_arr(struct Arr*pArr);                          //排序函数声明

int main(void)
{
	struct Arr arr;                 //声明一个实参边量arr
	int val;

	init_arr(&arr,6);               //假设初始化数组长度为6
	append_arr(&arr,12);
	append_arr(&arr,23);
	append_arr(&arr,3);
	append_arr(&arr,34);
	append_arr(&arr,31);
	printf("原始数组是：\n");
	show_arr(&arr);

	if(insert_arr(&arr,1,99))
	{
		printf("插入成功！\n");
		printf("在位置1插入99:\n");
	}
	else
	{
		printf("插入失败！\n");
	}
	show_arr(&arr);

	if(delete_arr(&arr,3,&val))
	{
		printf("删除成功！\n");
		printf("删除的元素是: %d\n",val);
		printf("删除后数组内容是：\n");
	}
	else
	{
		printf("删除失败！\n");
	}
	show_arr(&arr);

	inversion_arr(&arr);
	printf("倒置后数组是：\n");
	show_arr(&arr);

	sort_arr(&arr);
	printf("冒泡排序后数组顺序是：\n");
	show_arr(&arr);

	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);
	}
	
	pArr->len=length;
	pArr->cnt=0;

	return ;
}

bool full_arr(struct Arr*pArr)
{
	if(pArr->cnt==pArr->len)         //有效个数等于长度
		return true;
	else
		return false;
}

bool append_arr(struct Arr*pArr,int val)
{
	if(full_arr(pArr))
		return false;
	else
	{
		pArr->pBase[pArr->cnt]=val;   //pBase[cnt]=val;
		(pArr->cnt)++;
		return true;
	}
}

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

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

bool insert_arr(struct Arr*pArr,int pos,int val)
{
	if(full_arr(pArr))
		return false;
	if(pos<1 || pos>pArr->cnt+1)               //在pos前插入 在有效数范围内
		return false;

	for(int i=pArr->cnt-1;i>=pos-1;--i)         //从后面开始下标i为有效数-1
	{
		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)
{
	if(empty_arr(pArr))
		return false;
	if(pos<1||pos>pArr->cnt)
		return false;
	*pVal=pArr->pBase[pos-1];
	for(int 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;                         //下表是有效数-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-1;++i)                 //排序趟次
	{
		for(j=0;j<pArr->cnt-i-1;++j)           //从前往后比较,一趟冒泡过程
		{
			if(pArr->pBase[j]>pArr->pBase[j+1])   
			{
				t=pArr->pBase[j];
				pArr->pBase[j]=pArr->pBase[j+1];
				pArr->pBase[j+1]=t;
			}
		}
	}
}