连续存储数组的算法

#include<stdio.h> 
#include<malloc.h>//包含了malloc函数 
#include<stdlib.h>//包含了exit函数 
//定义了一个数据类型，名字是struct arr,该数据类型有三个成员 ，分别是 ph,cnt.len 
struct arr{
	int*ph;//储存的是数组第一个元素的地址 
	int len;// 该数组所能容纳最大元素的个数 
	int cnt;//该数组的有效元素的个数 
};
void liit_arr(struct arr*p,int length);//初始化数组 
void show_arr(struct arr*p);//分号不能省  
bool is_empty(struct arr*p);//判断有效元素是否为空 
bool append_arr(struct arr*p,int val);//追加 
bool insert_arr(struct arr*p,int pos,int val) ;//pos的值从1开始 
bool delete_arr(struct arr*p,int pos,int *pval);
void inversion_arr(struct arr*p);
void sort_arr(struct arr*p);
int main(void){
	int val;
	struct arr st;
	liit_arr(&st,6);
	show_arr(&st);
	append_arr(&st, 1);
	append_arr(&st, 2);
	append_arr(&st, 3);
	append_arr(&st, 4);
if(	delete_arr(&st, 4,&val)){
	printf("删除成功！\n");
	printf("你删除的元素是：%d\n",val);
}
else{
	printf("删除失败！\n") ;
}
	show_arr(&st);
	inversion_arr(&st);
	printf("倒置之后的数组内容是：\n");
	show_arr(&st);
	sort_arr(&st);
	show_arr(&st);
	return 0;
}

初始化数组

void liit_arr(struct arr*p,int length){
	p->ph=(int*)malloc(sizeof(int)*length);
	if(NULL==p->ph){
		printf("动态内存分配失败\n");
		exit(-1);//终止整个程序 
	}
	else{
		p->len=length;
		p->cnt=0;
	} 
	return;//表示函数终止 
}

判断数组是否为空or为满

bool is_empty(struct arr*p){
	if(0==p->cnt)
	return true;
	else
	return false;
}
bool is_full(struct arr*p) {
	if(p->cnt==p->len)
	return true;
	else return false;
}

输出

void show_arr(struct arr*p){
	if(is_empty(p)){
		printf("数组为空！\n");
	}
	else
	{
		for(int i=0;i<p->cnt;++i)//输出数组的有效元素 
		printf("%d",p->ph[i]);//需要一个整形数组的地址int* 
		printf("\n"); 
	}
}

追加

bool append_arr(struct arr*p,int val){
	if(is_full(p))
	return false;
	else{
		p->ph[p->cnt]=val;
		(p->cnt)++;
		return true;
	}
	
}

插入

bool insert_arr(struct arr*p,int val,int pos) {
	int i;
	if(is_full(p))
	return false;
	if(pos<1||pos>p->cnt+1)
	return false;
	for(i=p->cnt-1;i<=pos-1;--i){
	p->ph[i+1]=p->ph[i];
	p->ph[pos-1]=val;
	(p->cnt)++;
	return true;
	}
}

删除

bool delete_arr(struct arr*p,int pos,int *pval){
	if(is_empty(p))
	return false;
	if(pos<1||pos>p->cnt)
	return false;
	*pval=p->ph[pos-1];
	for(int i=pos;i<p->cnt;--i){
		p->ph[i-1]=p->ph[i];
	}
	p->cnt--; 
	return true;
}

倒置

void inversion_arr(struct arr*p){
	int i=0;
	int j=p->cnt-1;
	int t;
	while(i<j){
		t=p->ph[j];
		p->ph[j]=p->ph[i];
		p->ph[i]=t;
		++i;
		--j;
	}
	return;
}

排序

void sort_arr(struct arr*p){
	int i,j;
	for(i=0;i<p->cnt;++i){
		for(j=i+1;j<p->cnt;++j){
			if(p->ph[i]>p->ph[j]){
				int t;
			t=p->ph[i];
			p->ph[i]=p->ph[j];
			p->ph[j]=t;
			}
		}
	}
}