连续存储数组的算法

模块一：线性结构[把所有的结点用一根直线穿起来]

 

    连续存储【数组】

 

    离散存储【链表】

 

    线性结构的两种常见应用之一 栈

 

    线性结构的两种常见应用之二 队列

 

    专题：递归
 1. 1=2+3+4+...100 的和
 2.  求阶乘
 3.  汉诺塔
 4.  走迷宫

 

模块二：非线性结构
 树
 图 

 

连续存储 [数组 ]
 1. 什么叫数组
 元素类型相同，大小相同

 2. 数组的优缺点：

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

// 定义了一个数据类型， 该数据类型的名字叫做 struct Arr, 该数据类型含有 3 个成员，分别为pBase，len,cnt 
struct Arr 
{ 
	int *pBase;// 存储的是数组第一个元素的地址
	int len;// 数组所能容纳的最大元素的个数
	int cnt;// 当前数组有效元素的个数
	//int increment;// 自动增长因子
}; 
void init_arr(struct Arr *pArr,int length);// 初始化 ,使 pBase 指向一个有效的数组，而不再是垃圾数字
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 *pAr);// 是否为空
void sort_arr(struct Arr *pArr);// 排序
void show_arr(struct Arr *pArr);// 显示 ,分号不能省
void innversion_arr(struct Arr *pArr);// 倒置  

int main (void) 
{ 
	struct Arr arr; // 只定义没初始化时，内部三个变量里都是垃圾数字
	int val; 
	int posi=2; 
	int len=6; 
	//init_arr(arr);// 会输出垃圾数字，并不能改变 arr 的值
	//  printf("%d\n",arr.len); 
	init_arr(&arr,len);// 会输出垃圾数字，并不能改变 arr 的值
	show_arr(&arr); 
	append_arr(&arr,1); 
	append_arr(&arr,-3); 
	append_arr(&arr,6); 
	append_arr(&arr,45); 
	append_arr(&arr,13); 

	if(append_arr(&arr,34)) 
	{ 
		printf(" 追加成功！ \n"); 
	} 
	else 
	{ 
		printf(" 追加失败！ \n"); 
	} 

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

	/* 
	append_arr(&arr,1); 
	append_arr(&arr,2); 
	append_arr(&arr,3); 
	append_arr(&arr,4); 
	append_arr(&arr,5); 
	insert_arr(&arr,1,99);  //pos 的值从 1 开始
	*/ 
	/*  append_arr(&arr,6); 
	append_arr(&arr,7); 
	show_arr(&arr); 
	if(append_arr(&arr,8)) 
	{ 
	printf(" 追加成功！ \n"); 
	} 
	else 
	{ 
	printf(" 追加失败！ \n"); 
	} 
	*/ 
	printf(" 删除之后的数组内容是 :\n"); 
	show_arr(&arr); 
	innversion_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).len=99; 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; 
} 
void show_arr(struct Arr *pArr)// 显示
{ 
	//  if(数组为空 ) 
	//  提示用户数组为空
	//  else 
	//  输出数组有效内容
	if(is_empty(pArr))  // 
	{ 
		printf(" 数组为空 !\n"); 
	} 
	else 
	{ 
		for(int i=0;i<pArr->cnt;i++) 
		printf("%d ",pArr->pBase[i]); 
		printf("\n"); 
	} 
} 

bool is_full(struct Arr *pArr)// 是否为空
{ 
	if(pArr->cnt==pArr->len) 
		return true; 
	else 
		return false; 
} 

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)  //pos 的值从 1 开始
{ 
	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]; //i 赋给 i+1 
	} 
	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 innversion_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; 
			} 
		} 
	} 
} 

编译结果：