顺序表算法——考研数据结构

顺序表

1. 定义一个顺序表的结构

struct sqlist
{
  int* head;  // 首地址
  unsigend int rongliang ; // 线性表的容量
  unsigned int shuliang ; //已经储存的的数量 
}

2. 对顺序表的参数初始化

void chushihua(shtuct sqlist* shuzu)  //传递一个顺序表的结构体
{
  shuzu->rongliang=5;  //设置初始容量极值
  shzu->shuliang = malloc(sizeof(int) * zhuzu->rongliang); //为初始设置的容量申请空间
  shuzu->shuliang = 0 ； //初始时 以存储数量为0
} 

3. 顺序表尾添加

void add_end(struct sqlist* shuzu , int data )
{
  // 判断剩余空间有无，当以存数量=容量时，需要扩容
  if(shuzu->rongliang=shuliang)
  {
    // 容量增大
    shuzu->rongliang +=10;
    // 申请空间
    int* temp = malloc (sizeof(int)* shuzu->rongliang);
    //将原数据存入新申请的空间,
    for(int i=0;i<shuzu->rongliang;i++)
    {
      temp[i]=shuzu->head[i];
    }
    // 原数据已经备份完成，释放原来的空间
    free(shuzu->head);
    // 将数组头指针指向新空间
    shuzu->head = temp; 
  } 
// 还有剩余空间的时候，直接尾添加
shuzu->head[shuzu->shuliang] = data;
// 由于数组的下标比个数少1，所以新添加的数据的下标=以存数量
shuzu->shuliang++ ; // 以存储数量+1  
}

4. 顺序表的插入

顺序表的插入，插入点后面的元素都要向后移动一位

王道教材版本：

void charu(struct sqlist* zhuzu , int data , int xiabiao)
{
  // 参数检测
  if(shuzu=null)
  {
    printf("传入参数有误")
    return;
  }
  // 检测插入位置是否正确
  if(xiabiao > shuzu->shuliang)
  {
    printf("下标超出范围")
    return ;
  }
  // 当下标在可插入范围内
  if(xiabiao >= 0 && xiabiao <= shuzu->shuliang)
  {
    // 往后挪(第个元素以及后面的元素)
    // 下标为shuzu->shuliang的这个位置时没有数据的，是空的
    for(int i=shuzu->shuliang ; i>=xiabiao ; i--)
    {
      // 先将最后一个元素往后挪，然后在空出的位置放下一个后挪的元素
      shuzu->head[i] = shuzu->head[i-1] ;
    }
    // 将数据插入到指定位置
    shuzu->head[xiabiao] = data ;
    // 数据量+1
    shuzu->shuliang++ ;
  }
}

1. 当传递的插入参数是在下标为n要插入时：

• 循环后挪在下标i=参数下标的位置停止(ｉ>= n)
• 将数据给插入位置的下标就直接是所给的参数n

2. 当传递的插入参数是在第n个语速的位置插入时：

• 循环后挪在下标i=n–1的位置停止（i>=n-1）
• 将数据给插入位置的下标是参数为n-1

添加功能版本

• 参数、下标的检测
• 自动扩容，
• 插入位置过大直接添加在结尾

void charu (struct sqlist* zhuzu ; int data ; int xiabiao)
{
  // 参数检验
  if(shuzu == null)
  {
    printf("参数错误");
    return ;
  }
  //当空间已满，需要扩容
  if(shuzu->shuliang==shuzu->rongliang)
  {
    //容量变大
    shuzu->rongliang+=10;
    //申请空间
    int* temp= (int*)malloc(sizeof(int)*shuzu->rongliang);
    // 将原数据装入新空间
    for(int i=0;i<shuuz->rongliang;i++)
    {
      temp[i]=shuzu->head[i];
    }
    // 将原空间释放
    free(shuzu->head);
    // 将原数据头指针指向新空间
    shuzu->head = temp ;
  }
  // 当下标过大时，插入到最后,将下标参数
  if(xiabiao > zhuzu->shuliang)
  {
    xiabiao = shuzu->shuliang
  }
  // 往后挪
  if(xiabiao >= 0 && xiabiao <= shuzu->shuliang)
  {
    for(int i=shuzu->shuliang ; i>=xiabiao ; i--)
    {
      shuzu->head[i] = shuzu->head[i];
    }
  }
  // 数据插入到指定位置
  shuzu->head[xiaobiao] = shuju ; 
  // 数据量++
  shuju->shuliang
}

5. 顺序表删除

尾删除

• 直接结构体中存储数据个数-1

void end_delete(struct sqlist* shuzu )
{
  if(shuzu==null)
  {
    printf("参数错误");
    return ;
  }
  shuzu->shuliang-- ;  
}

全部删除

• 结构体中数量置为0
• 清空空间：数量，容量置为0，释放头指针地址，首指针置为null

void  all_delete(struct sqlist* shuzu)
{
  if(shuzu==null)
  {
    printf("参数错误");
    return ;
  }
  shuzu->shuliang = 0 ；
  
  // 添加下面代码为在删除全部元素的同时，释放所占空间
  shuzu->rongliang=0;
  free(shuzu->head);
  shuzu->head=null;
}

删除中间元素

• 要删除位置的元素整体向前移，把要删除的元素覆盖掉,然后数量-1

void middle_delete(struct sqlist* shuzu , int xiabiao )
{
  if(shuzu==null)
  {
    printf("参数错误");
    return ;
  }
  for(int i=xiabiao; i<shuzu->shuliang ; i++)
  {
    shuzu->head[i]=shuzu->head[i+1];
  }
  shuzu->shuliang--;
}

6. 顺序表查找

根据数据查找，返回数据下标

(没考虑数据重复的情况)

int findbydata(struct sqlist* shuzu , int data )
{
  if(shuzu==null)
  {
    printf("参数错误");
    return ;
  }
  for(int i=0; i<shuzu->shuliang;i++)
  {
    if(shuzu->head[i]==data)
    {
      return i+1
    }
    return 0;
  }
}

根据下标查找数据

int findbyindex(struct sqlist* shuzu , int index )
{
  if(shuzu==null)
  {
    printf("参数错误");
    return ;
  }
  retrun shuzu->head[index];
}