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

原创 2015年11月17日 21:53:25

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;

                            }

                   }

         }

 

}


版权声明:本文为博主原创文章,未经博主允许不得转载。

郝斌数据结构  13  连续存储数组的算法演示_2

#include #include #include #include struct Arr //定义了一个数据类型,该数据类型名字叫struct Arr { int *pBase;//...
  • asty008
  • asty008
  • 2016年12月20日 16:53
  • 231

郝斌数据结构  12 连续存储数组的算法演示

#include #include #include #include struct Arr //定义了一个数据类型,该数据类型名字叫struct Arr { int *pBase;//...
  • asty008
  • asty008
  • 2016年12月20日 09:36
  • 324

郝斌数据结构连续存储数组的算法演示

#include #include #include //包含了exit函数 //定义了一个数据类型 struct Arr { int * pBase;//存储的是数组第一个元素的地址 i...

跟着郝斌学数据结构(02)——连续存储数组的算法

# include # include //包含了malloc函数 # include //包含了exit函数 //定义了一个数据类型,该数据类型的名字叫做struct Arr, 该数据类...

(郝斌讲学)数据结构学习篇(二)---数组的操作连续存储

012.连续存储数组的算法演示 线性结构:把所有的结点用一根直线穿起来. 一个字节有4个地址。   实现一个数组的案例 #include #include #include  //包含了...

【郝斌数据结构自学笔记】25_判断链表是否为空和求链表长度算法的演示

25_判断链表是否为空和求链表长度算法的演示 #include #include #include   typedefstruct Node {          int data;//...

【郝斌数据结构自学笔记】27-29_链表插入和删除算法的演示_复习

27_如何学习算法自己的一些感想 28_链表插入和删除算法的演示 #include #include #include   typedefstruct Node {          ...

数据结构-连续存储(郝斌老师的教程)

#include #include #include struct Arr{ int *pBase;//存储的是一维数组的第一个元素的地址 int len;//数组所能容纳的最大元...

【郝斌数据结构自学笔记】66-69_森林的存储_二叉树的先序遍历_二叉树的中序遍历【中间访问根节点】_二叉树的后序遍历【最后访问根节点】

66_树7_森林的存储 67_树8_二叉树的先序遍历 二叉树操作          1.遍历:先序遍历,中序遍历,后序遍历          2.已知两种遍历序列求原始二叉树 先序遍...

【郝斌数据结构自学笔记】30-34_栈的定义_栈的分类_栈程序演示_栈的日常具体应用

30_栈的定义 定义          一种可以实现“先进后出”的存储结构          栈类似于箱子 分类 算法 应用 31_栈的分类 分类          静态栈 动态栈 32_栈可以执行哪...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【郝斌数据结构自学笔记】12-13_连续存储数组的算法演示
举报原因:
原因补充:

(最多只允许输入30个字)