关于连续性储存数组的一些小算法

本人呢正处于完成C语言的大作业时期，对于链表啊，非常头疼，所以就查了有关于此类的一些基本知识，连续性数组与链表到是比较相近，便多看了一点，现在就分享一点

---

1.结构体

首先我们先定义一个非常简单结构体

struct Arr
{
 int * pBase;  //储存的是数组第一个元素的地址
 int cnt;  //当前数组有效元素的个数
 int len;  //数组所能容纳元素的最大个数
};

2.初始化

结构体定义完了，下面对其进行初始化

void init_arr(struct Arr * pArr, int length)  //lenght表示接收的数组长度
{
 pArr->pBase = (int *)malloc(sizeof(struct Arr) * length);  //定义一个动态内存放置我们的数组， 需要头文件malloc.h
 if (NULL == pArr->pBase)   //数组毕竟是连续性的，如果内存不够的话也会导致分配失败 
 {
  printf("动态内存分配失败");
  exit(-1);   //程序终止 需要头文件stdlib.h
 }
 else
 {
  pArr->len = length;
  pArr->cnt = 0; 
 }
 return ;
} 

3.追加

当我们用着用着发现数组不够了，这个时候追加的用处就体现出来了。
当然这个追加也是要看当时你动态数组分配大小也是有关的，所以追加的时候要用到一个判断，如果这个连续型数组已经是满了的话追加也是不成功的。

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;
 //不满时追加
 else
 {
  pArr->pBase[pArr->cnt] = val;   //这个val相当于赋在了这个数组的末尾
  (pArr->cnt)++;   //当追加成功后这个数组的有效值就要+1
  return true;
 }
}

4.插入和删除

连续性数组必须要会的两个就是插入和删除

插入

同样的插入也要去判断一下这个数组是否已经满了，如果满了的话插入就会失败

bool is_full(struct Arr * pArr)       
{
 if (pArr->cnt == pArr->len)
  return true;
 else
  return false;
}
bool insert_arr(struct Arr * pArr, int pos, int val)
{
 if ( is_full(pArr) )    //被插入的数组是否已满
  return false;
 if (pos<1 || pos>pArr->cnt+1)    //插入的地区是否符合合法
  return false;
 
 for(int i=pArr->cnt-1; i>=pos-1; i--)
 {
  pArr->pBase[i+1] = pArr->pBase[i];   //从选定的地方让数组往后移动
 }
 pArr->pBase[pos-1] = val;         //移动过后再将数据插入
 (pArr->cnt)++;   //同样当插入成功后这个数组的有效值也要+1
 return true;
}

删除

删除就不用在关心数组是否满了这个问题，找到那个数直接删了

bool delete_arr(struct Arr * pArr, int pos, int *pVal)
{
 if(pos<1 || pos>pArr->cnt)     //删除的地区是否符合合法
  return false;
 
 *pVal = pArr->pBase[pos-1];  //那个被删除的数据
 for(int i=pos; i<=pArr->cnt; i++)
 {
  pArr->pBase[i-1] = pArr->pBase[i];    //由那个被删除的数据的后一位开始往前移动一位，直接将要删除的数据覆盖
 }
 (pArr->cnt)--;   //删除数据后有效元素-1
}

5.倒置

倒置，顾名思义就是将数组反过来`

void inversion_arr(struct Arr *pArr)
{
 int i,j;
 i = 0;             
 j = pArr->cnt-1;   //将最后一个元素的下标给j
 int temp;
 while(i<j)
 {
  temp = pArr->pBase[i];
  pArr->pBase[i] = pArr->pBase[j];
  pArr->pBase[j] = temp;     //最后一个元素与第一个元素实现对调
  i++;
  j--;            
 } 
 return;
}

这个程序在数组奇数或者偶数情况下是都能运行的

6.排序

关于排序的方法就很多了，我在这里就先写两个最基本的，一个是选择排序，一个是冒泡排序。

选择排序

void sort_arr(struct Arr * pArr)
{
 int i, j, temp;
 for (i=0; i<pArr->cnt-1; i++)
 {
  for(j=i+1; j<pArr->cnt; j++)
  {
  if(pArr->pBase[i] >pArr->pBase[j])
   {
    temp = pArr->pBase[i];
    pArr->pBase[i] = pArr->pBase[j];
    pArr->pBase[j] = temp;
   }
  }
 }
}

冒泡排序

void sort_arr(struct Arr * pArr)
{
 int i, j, temp;
 for (i=0; i<pArr->cnt; i++)
 {
  for(j=0; j<pArr->cnt-i-1; j++)
  {
   if(pArr->pBase[j] >pArr->pBase[j+1])
   {
    temp = pArr->pBase[j];
    pArr->pBase[j] = pArr->pBase[j+1];
    pArr->pBase[j+1] = temp;
   }
     }
 }
}

详情请参考B站郝斌老师的视频《郝斌老师数据结构自学视频》
分享结束
下次，链表见。