数组

数组主要函数有：

初始化动态数组，数组的末尾添加元素，在指定位置前面添加元素，在指定位置删除元素，判断数组是否为空为满，打印数组元素，倒置数组元素，数组元素大小排序。

主要思想代码后有相应注释

#include<stdio.h>
#include<malloc.h>
struct Array
{
	int *parr;//存储数组首元素地址
	int count;//当前数组个数
	int len;//数组最大长度
};
void init(struct Array *a, int length)
{
    //*a就相当于主函数中的arr
    a->parr = (int *)malloc(sizeof(int)*length);//a这个指针变量所指向的结构体变量中的parr成员，为它分配内存
	if (NULL == a->parr)
	{
		printf("动态内存分配失败");
}
	else
	{
		a->count = 0;//当前元素个数为0
		a->len = length;//数组最大长度
	}
	return;
}
bool isempty(struct Array *a)
{
	if (a->count == 0)//元素个数为0，说明为空返回true
		return true;
	else
		return false;
}
bool isfull(struct Array *a)//元素个数为数组长度，说明为满返回true
{
	if (a->count == a->len)
		return true;
	else
		return false;
}
bool add(struct Array *a, int val)//向数组末尾添加元素
{
	if (isfull(a))
	{
		printf("元素已满");
		return false;
	}
	a->parr[a->count] = val;//下标为当前元素个数，因为在末尾加元素
	a->count++;//当前个数加一
	return true;
}
bool insert(struct Array *a, int index, int val)//index为插入位置，最小为1，在index前插入元素
{
	if (isfull(a))//满了话就不添加
	{
		return false;
	}
	if (index<1 || index>a->count+1)//等于count情况就相当于在末尾添加元素
	{
		return false;
	}
for (int i = a->count - 1; i >= index - 1; --i)//先将最后一个元素往后移，依次直到下标为index-1
		{
			a->parr[i + 1] = a->parr[i];//下标i+1的元素被下标i元素替代
		}
		a->parr[index-1] = val;//空出的位置为插入元素
		a->count++;//个数加一
	return true;
}
bool delet(struct Array *a, int index, int *val)
{
	if (isempty(a))//空了话就不删除
	{
		return false;
	}
	if (index<1 || index>a->count)
	{
		return false;
	}
	*val=a->parr[index-1];//*val就相当于主函数中的v，存储删除的元素
for (int i = index;i<a->count;i++)//从下标为index元素开始依次往前移直到最后一个
		{
			a->parr[i -1] = a->parr[i];//下标i-1的元素被下标i元素替代
		}
		a->count--;//个数减一
		return true;
}
void print(struct Array *a)
{
	int i;
	for (i = 0; i < a->count; i++)
	{
		printf("%d\n", a->parr[i]);//依次打印元素
	}
}
void reverse(struct Array *a)
{
    int i=0;
    int j=a->count-1;
    while(i<j)//i指向开始，j指向末尾，当i<j时候不断调换顺序
    {
        int t;
        t=a->parr[i];
        a->parr[i]=a->parr[j];
        a->parr[j]=t;
        ++i;
         --j;
}
}
void sort(struct Array *a)
{

    int i,j;
    for(int i=0;i<a->count;i++)//冒泡排序由小到大
    {
        for(j=i+1;j<a->count;j++)
        {
            if(a->parr[i]>a->parr[j])
            {
                   int t;
        t=a->parr[i];
        a->parr[i]=a->parr[j];
        a->parr[j]=t;
            }
        }
    }
}
int main()
{
    int v;
	struct Array arr;
	init(&arr, 6);
	add(&arr, 1);
	add(&arr, -3);
	add(&arr, 7);
	add(&arr, 9);
	add(&arr, 5);
	add(&arr, 2);
	insert(&arr, 3, 6);
	print(&arr);
	if(delet(&arr,3,&v))
	{
	    printf("删除成功\n");
	    printf("删除的元素是%d\n",v);
	}
	else{
	printf("删除失败\n");
	}
	printf("删除后元素\n");
    print(&arr);
	reverse(&arr);
		printf("转置后元素\n");
	print(&arr);
	sort(&arr);
		printf("排序后元素\n");
	print(&arr);
	return 0;
}

效果：