数据结构_P11

# include <stdio.h>
# include <stdlib.h>
# include <malloc.h>
/*
*	数组：自己做一套数组相关的方法(插入、删除等操作功能)
*	2016年6月7日14:08:06 - 2016年6月7日20:32:52
*/
struct Arr	//定义了一个数据类型，名字叫Arr，该数据类型含有三个成员
{
	int *pBase;		//数组头结点指针
	int len;	//数组长度
	int	cnt;	//数组当前有效个数
};

void init_arr(struct Arr*, int);	//初始化
bool append_arr(struct Arr*, int);	//尾部追加，返回是否成功追加
bool insert_arr(struct Arr*, int pos, int val);	//注：这里定义pos从1开始，插入的值在pos值元素之前
void delete_arr(struct Arr*, int pos);	//删除成功与否要返回，同时把删除的元素输出
int get();		//获取数组中特定下标的值
bool is_empty(struct Arr*);	//判断数组是否为空
bool is_full(struct Arr*);		//判断数组是否为满
void sort_arr(struct Arr*);	//数组排序:这里练习冒泡排序(递增)
void show_arr(struct Arr*);	//输出显示数组
bool inversion_arr(struct Arr*);	//倒置数组

int main(void)
{
	struct Arr arr;		//定义一个数据类型Arr的变量arr,现在已经分配了内存，但是没有初始化，里面是垃圾值,也没有逻辑上的数组
	init_arr(&arr, 6);		//初始化后，arr成员中的pBase将指向一个整型数组头结点，数组生成，当前有效个数应该为零
//	show_arr(&arr);
	
	append_arr(&arr, 3);
	append_arr(&arr, 4);
	append_arr(&arr, 5);
	append_arr(&arr, 6);
//	append_arr(&arr, 6);
//	append_arr(&arr, 5);

	if(append_arr(&arr, 111))  //在用一个函数方法时，这样写更便于看到函数调用的情况
		printf("追加成功!\n");
	else
		printf("追加失败!\n");
	show_arr(&arr);

	if( insert_arr(&arr, 4, 542))
		printf("插入成功!\n");
	else
		printf("插入失败!\n");
	show_arr(&arr);

	delete_arr(&arr, 2);
	show_arr(&arr);

	if( inversion_arr(&arr) )
	{
		printf("倒置成功!\n倒置后的数组为：");
		show_arr(&arr);
	}
	else
		printf("倒置失败!\n");

	sort_arr(&arr);
	printf("排序后的数组为: ");
	show_arr(&arr);

	return 0;
}

void init_arr(struct Arr* pArr, int length)
{
//	pArr->len = 99;  //注意指针是这样访问成员的，不是用'.'；前面也没有*
//	(*pArr).len = 100;  //也可以这样
	pArr->pBase = (int*)malloc(sizeof(int) * length);
	if (NULL == pArr->pBase)    //如果内存满了,malloc申请失败，会把NULL赋给pBase
	{
		printf("动态内存分配失败！");
		exit(-1);		//终止整个程序,需要加头文件stdlib.h
	}
	else
	{
		pArr->len = length;
		pArr->cnt = 0;
	}
	return;		//这里的return表示一个函数在这里编写完成，方便别人阅读，不代表其他意义
}

bool is_empty(struct Arr* pArr)
{
	if(pArr->cnt == 0)
		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
	{
		printf("数组长度为: %d, 当前有效个数为: %d\n", pArr->len, pArr->cnt);
		for(int i=0; i<pArr->cnt; i++)
		{
			printf("%d ", pArr->pBase[i]);
		}
		printf("\n");
	}
}

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

bool insert_arr(struct Arr* pArr, int pos, int val)
{
	if(pos<1 || pos>pArr->len || is_full(pArr))
		return false;
	else
	{	
		for(int j=pArr->cnt; j>=pos; j--)
		{
			pArr->pBase[j] = pArr->pBase[j-1];
		}
		pArr->pBase[pos-1] = val;
		pArr->cnt++;
		return true;
	}
}

void delete_arr(struct Arr* pArr, int pos)
{
	if( is_empty(pArr) || pos<1 || pos > pArr->cnt )
		printf("删除失败!\n");
	else
	{
		printf("删除成功!\n");
		printf("删除的数为: %d\n", pArr->pBase[pos-1]);
		for(int y=pos; y<pArr->cnt; y++)
		{
			pArr->pBase[y-1] = pArr->pBase[y];
		}
		pArr->cnt--;
	}
}

bool inversion_arr(struct Arr* pArr)
{
	if( is_empty(pArr) || pArr->cnt<2 )
		return false;
	else
	{
		int p;
		int j = pArr->cnt;
		for(int i=1; i<=(pArr->cnt/2); i++)
		{
			p = pArr->pBase[i-1];
			pArr->pBase[i-1] = pArr->pBase[j-1];
			pArr->pBase[j-1] = p;
			j--;
		}
		return true;
	}
}

void sort_arr(struct Arr* pArr)		//冒泡排序:每次把最小数放到数组最前面
{
	int i;
	int j = pArr->cnt;
	int temp;
	for(i=0; i<j-1; i++)
	{
		for(int p=i+1; p<=j-1; p++)
		{
			if(pArr->pBase[p] < pArr->pBase[i])
			{
				temp = pArr->pBase[i];
				pArr->pBase[i] = pArr->pBase[p];
				pArr->pBase[p] = temp;
			}
		}
	}
}