【郝斌数据结构自学笔记】12-13_连续存储数组的算法演示

12_连续存储数组的算法演示_1

13_连续存储数组的算法演示_2

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

连续存储[数组]

离散存储[链表]

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

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

专题：递归

1. 1=2+3+4+...100的和

2. 求阶乘

3. 汉诺塔

4. 走迷宫

模块二：非线性结构

树

图

 

 

连续存储[数组]

1. 什么叫数组

元素类型相同，大小相同

2. 数组的优缺点：

#include<stdio.h>

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

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

 

//定义了一个数据类型，该数据类型的名字叫做structArr,该数据类型含有3个成员，分别为pBase，len,cnt

struct Arr

{

         int*pBase;//存储的是数组第一个元素的地址

         intlen;//数组所能容纳的最大元素的个数

         intcnt;//当前数组有效元素的个数

//int increment;//自动增长因子

};

void init_arr(struct Arr *pArr,int length);//初始化,使pBase指向一个有效的数组，而不再是垃圾数字

bool append_arr(struct Arr *pArr,intval);//追加，可能成功，可能失败

bool insert_arr(struct Arr *pArr,intpos,int val);     //pos的值从1开始

bool delete_arr(struct Arr *pArr,intpos,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)

{

        

         structArr arr; //只定义没初始化时，内部三个变量里都是垃圾数字

         intval;

         intposi=2;

         intlen=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);

 

 

 

         return0;

}

 

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)

                   returntrue;

         else

                   returnfalse;

 

}

 

void show_arr(struct Arr *pArr)//显示

{

//      if(数组为空)

//               提示用户数组为空

//      else

//               输出数组有效内容

         if(is_empty(pArr))    //

         {

                   printf("数组为空!\n");

         }

         else

         {

                   for(inti=0;i<pArr->cnt;i++)

                            printf("%d",pArr->pBase[i]);

                   printf("\n");

                  

         }

}

 

bool is_full(struct Arr *pArr)//是否为空

{

         if(pArr->cnt==pArr->len)

                   returntrue;

         else

                   returnfalse;

 

}

 

bool append_arr(struct Arr *pArr,int val)//追加，可能成功，可能失败

{

         //满时返回false

         if(is_full(pArr))

                   returnfalse;

         //不满时追加

         pArr->pBase[pArr->cnt]=val;

         (pArr->cnt)++;

         returntrue;

}

 

bool insert_arr(struct Arr *pArr,intpos,int val)      //pos的值从1开始

{

         inti;

         if(is_full(pArr))

                   returnfalse;

         if(pos<1||pos>pArr->cnt+1)    //

                   returnfalse;

 

         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++;

 

         returntrue;

}

 

bool delete_arr(struct Arr *pArr,intpos,int *pVal)

{

         inti;

         if(is_empty(pArr))

                   returnfalse;

         if(pos<1||pos>pArr->cnt)

                   returnfalse;

 

         *pVal=pArr->pBase[pos-1];

         for(i=pos;i<pArr->cnt;++i)

         {

                   pArr->pBase[i-1]=pArr->pBase[i];

         }

         pArr->cnt--;

         returntrue;

}

 

void innversion_arr(struct Arr *pArr)//倒置

{

         inti=0;

         intj=pArr->cnt-1;

         intt;

         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)//排序

{

         inti,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;

                            }

                   }

         }

 

}