关于数组_2——数组的算法演示

下面的例子是使用结构体和一些函数来模拟数组的功能，即构造一个数组

讲这个程序，主要还是为了讲两个知识，一是数据的存储不一样，操作也不一样，泛型达到的效果是存储不一样，操作一样

    首先来说，要模拟一个数组，需要有长度、第一个元素首字节的地址，还有就是当前数组的有效长度（因为这里说的构造的数组是动态分配的数组），其实，严格说起来，还需要一个，就是自动增长因子，这个是什么呢？要知道，动态分配的数组是可以扩充容量的，假设一个动态分配的数组有10个元素，突然需要添加新的元素，它不会直接扩充一个元素的位置，因为万一又需要添加元素，还得再扩充，这样就会浪费时间；那数组会怎么做呢？当它元素个数已满需要扩充时，不会只扩充一个，而是根据增长因子扩充，假设他是扩充一倍，这样，虽然有可能浪费一些内存，但却大大减小了时间的浪费，增长因子就是因此而来

使用增长因子，需要用到allocate()这个函数，这里不打算讲，就不多说了

例1：

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

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;
	struct Arr * pArr;
	pArr = &arr;
	
	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");
	}
/*	append_arr(&arr, 2);
	append_arr(&arr, 3);
	append_arr(&arr, 4);
	append_arr(&arr, 5);
	insert_arr(&arr, -1, 99);
	append_arr(&arr, 6);
	append_arr(&arr, 7);
	if ( append_arr(&arr, 8) )
	{
		printf("追加成功\n");
	}
	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);
	free(pArr->pBase);
	system("pause");
	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;
			}
		}
	}
}

输出结果为：

    32行到37行驶插入了6个数组元素，分别是1、10、-3、6、88、11 

    第47到62行的注释部分，是判断追加是否成功是所写 

    第5行到第10行是定义了一个数据类型，该数据类型的名字叫做struct Arr, 该数据类型含有三个成员，分别是pBase, len, cnt，其中，pBase表示存储的是数组第一个元素的地址 ，len表示数组所能容纳的最大元素的个数，cnt表示 当前数组有效元素的个数（因为毕竟我们构造的是一个动态分配的数组） 

    从第12到21行，是声明了10个函数，每个函数都有其相应的功能 ，分别是 初始化、追加、插入（插入时，pos的值从1开始，即下标为0是第1个元素 ，比如说pos是4，就是在第4个元素之前插入 ）、删除、、判断是否为空、判断是否满、排序、显示输出、倒置 

    第78行使用了malloc()函数，使用这个函数需要用到 # include <malloc.h> 这个头文件

    第82行使用了exit()函数，它的功能是终止整个程序，使用这个函数需要用到 # include <stdlib.h> 这个头文件 

    第79到88行，判断 数组是否已经被初始化 

    第92到98行，判断数组是否为空，是则返回true，否则返回false 

    第100到106行，判断数组是否已满，是则返回true，否则返回false 

    第108到120行 ，先判断数组是否为空，是则输出“数组为空！”，否则输出数组的元素 

    第122到132行，是给数组追加元素，就是在数组末尾插入元素，先判断数组是否已满，是则返回false ，否则开始插入元素 

    同理，134到151行，也是先进行判断，后插入元素 

    另外，149行的(pArr->cnt)++，其实在这儿pArr->cnt不加括号也可以 ，但为了保证不犯错，一般最好加上 

    第153到169行是先将一些非法的情况排除，然后就是删除元素，38行的数字4表示删除的是数组的第四个元素  

    第171到186行是将数组元素倒置 

    第188行到 204行是 冒泡排序，以前说过，这里不说了 

【所有代码均在windows系统下C-Free5.0下运行通过】

（如有错误，敬请指正）