數據結構基礎（1）--數組C語言實現--動態內存分配（跟風追逐，加強突擊）

數據結構基礎（1）--數組C語言實現--動態內存分配http://blog.csdn.net/davidluo001/article/details/46447817

基本思想：數組是最常用的數據結構，在內存中連續存儲，可以靜態初始化（int a[2]={1,2}），可以動態初始化 malloc（）。

                    難點就是數組在刪除或者插入元素的時候，要移動元素的座標不好確定。規律：

                    1.如果要在數組中第pos個位置插入一個元素（應該從後面開始移動）

                     for( i=cnu;i>=pos;i--)

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

                  2.刪除數組第pos位置的元素

                      for(i=pos+1;i<=cnu;i--)

                       pBase[i-2]=pBase[i-1];

                 使用malloc動態分配內存並將返回值賦給整形指針

                  int *pBase=(int *)malloc(sizeof(int)*len);//分配4*len字節長度的內存

                這是pBase可以指向數組中的第一個元素，可以作爲數組變量名稱使用。

數組的優缺點：

            優點：

                存取速度快 o(1) 可以直接根據下標找到內存位置

            缺點：

                事先必須知道數組的長度

                插入刪除元素很慢

                空間通常是有限制的

                需要大塊連續的內存塊

                插入刪除元素的效率很低

#include<stdio.h>
#include<malloc.h>
#include<stdbool.h>
struct Arr{
int len;//數組能存取的最大元素個數
int cnu;//數組中當前元素個數
int * pBase;//存儲指向數組的指針
};


/**
*初始化數組
*/
void init_array(struct Arr * pArray,int len){
pArray->pBase=(int *)malloc(sizeof(int)*len);//分配4*len字節長度的內存
if(NULL== pArray->pBase)//判斷內存是否分配失敗
{
    printf("動態分配內存失敗\n");
   // exit(-1);
}else{
pArray->len=len;
pArray->cnu=0;
}
return ;
}

/**
*判斷數組是否爲空，傳地址省內存4字節，傳結構體變量需要進行拷貝，12字節
*/
bool isempty(struct Arr * pArray){
if(0==pArray->cnu)
{
    return true;
}else{
return false;
}
}

/**
**判斷數組是否滿了
*/
bool isfull(struct Arr * pArray)
{
  if(pArray->len==pArray->cnu)
  {

      return true;
  }else {
  return false;
  }

}
/**
*顯示數組內容
*/
void show_array(struct Arr * pArray){
if(isempty(pArray))
    printf("數組爲空！\n");
else{
    int i;
    for( i=0; i<pArray->cnu;i++)
    {
        printf("%d \n",pArray->pBase[i]);
    }
    printf("------------------------------------\n");
}
}

/**
**向數組追加元素
*/
bool append(struct Arr * pArray,int val){
if(isfull(pArray))
{
 printf("數組已經滿了！\n");
 return false;
}else{
    pArray->pBase[pArray->cnu]=val;
    pArray->cnu++;

}
}


/**
**向數組中插入元素,pos爲數組中第幾個位置，pos=3就是向a[2]插入元素
*/

bool insert(struct Arr * pArray,int pos,int val)
{
   if(pos<1||pos>pArray->len+1)//插入的位置不能小於1，同時不能比最後一個元素大二
   {
   printf("插入的位置輸入的不合法\n");
   return false;
   }
   if(isfull(pArray))
   {
       printf("數組已經滿了,插入失敗！\n");
      return false;
    }
    int i;
    //循環將pos位置開始的數組後移
   for(i=pArray->cnu;i>=pos;i--)
    //移動範圍是從第pos個到底cnu個
   {
       pArray->pBase[i]=pArray->pBase[i-1];
       /**
       若以i表示要移動元素的位置，從一開始的。右邊都是i-1,若左移，左邊是i-2,右移，左邊是i
       */
   }



       pArray->pBase[pos-1]=val;
       pArray->cnu++;
       pArray->len++;
       return true;
}
/**
**刪除數組中的第pos個元素，同時返回刪除的元素的值
*/

bool delete(struct Arr * pArray,int pos,int * val)
{
     if(pos<1||pos>pArray->cnu)
     {
         printf("刪除失敗，位置不合法\n");
         return false;
     }
     int i;
     *val=pArray->pBase[pos-1];
     for(i=pos+1;i<=pArray->cnu;i++)
     {
         //移動單位是從第pos+1個到cnu
         pArray->pBase[i-2]=pArray->pBase[i-1];

     }
      pArray->cnu--;
      return true;

}

/**
**數組倒置
*/

bool inverse(struct Arr * pArray)
{
if(isempty(pArray))
{
    printf("倒置失敗，因數組爲空");
    return false;
}

int i=0;
int j=pArray->cnu-1;

    int temp;
while(i<j)
{
    temp=pArray->pBase[i];
    pArray->pBase[i]= pArray->pBase[j];
     pArray->pBase[j]=temp;
     i++;
     j--;
}
return true;

}
int main()
{
    struct Arr arr;
    init_array(&arr,6);//將結構體的地址作爲實參，這樣才能修改結構體中的值，如果傳的是結構體變量，那麼將進行拷貝，不會改變值
    append(&arr,1);
    append(&arr,2);
    append(&arr,3);
    append(&arr,4);
    show_array(&arr);
    insert(&arr,2,88);
     show_array(&arr);
     int val;
     delete(&arr,1,&val);
     show_array(&arr);
     printf("刪除了 %d\n",val);
     inverse(&arr);
    show_array(&arr);
    return 0;
}