数据结构之顺序表_求顺序表的长度

目录

存储结构

操作实现

类型定义

初始化

判空

求长

插入

查找

删除

测试

存储结构

顺序表在内存中以一段连续的地址存储，具有随机性，顺序性，动态性：

随机性，即首地址随机生成；

顺序性，即各元素地址满足等距相邻；

动态性，即存储空间可在程序运行时动态生成。

操作实现

• 类型定义

结构体类型，定义一个动态数组存储数据，定义表长和当前长度。

typedef struct        //顺序表结构体
{  
  int *base;          //动态数组
 
  int length;         //顺序表当前长度
 
  int listsize;       //顺序表最大长度
 
}List;           

• 初始化

函数参数设成引用传递地址，以改变顺序表；

然后申请动态数组空间；

定义表长，初始化当前长度；

void initList (List &L)                 //参数设成引用，地址传递；
{
   L.base=(int)malloc(100*sizeof(int)); //申请空间
 
   if(!L.base)  return;                 //申请失败则返回
 
   L.length=0;                          //当前长度赋为零
 
   L.size=100;                          //为顺序表赋长度
 
}

• 判空

不需改变顺序表的数据，因此值传递即可；

访问当前长度，为零则空，否则不空。

int listempty(List L)          //不需改变实参，值传递即可
{ 
   if(L.length==0) return 1;   //当前长度为零即为空
   
   return 0;                   //否则返回零
 
}

• 求长

直接访问顺序表结构体的当前长度。

int listlength(List L)   //无需改变实参，值传递即可
{    
 
  return L.length;       //返回当前表长
 
}

• 插入

这里写的是在第i个元素之前插入。

应先判断i的合法性；

再判断空间是否不足，不足则申请更长的空间；

之后倒序右移i后元素；

最后插入元素。

void ListInsert(List &L,int i,int e)
{  
    if(i>L.length+1||i<1) return ;                         //i非法则返回
 
    if(L.length+1>L.listsize)                              //空间不足则先申请空间
     { (int*)realloc(L.base,(L.listsize+listcrement)*sizeof(int));
       L.listsize+=listcrement;
     }
 
    for(int j=L.length-1;j>=i-1;j--)                      //倒序右移i后元素
      L.base[j+1]=L.base[j];
 
    L.base[i-1]=e;                                        //插入e
 
    L.length++;                                           //长度加一
}                         

• 查找

遍历顺序表，到头或遇目标值跳出；

i到头则返回-1；

否则返回位置；

int Locatelem(List L,int e)     
{  
   int i=0;
 
   while(i<L.length&&L.base[i]!=e)  //跳出条件
    i++;   
    
   if(i<L.length)                  
    return i+1;                     //返回位置
 
}

• 删除

判断i的合法性；

正序左移i前元素；

长度减一；

void Delete(List &L,int i)
{    
     if(L.length<i) return;       //i非法
 
     for(int j=i;j<L.length;j++)  //正序左移
       L.base[j-1]=L.base[j];
 
     L.length--;                  //长度减一
}

测试

#include<bits/stdc++.h>
using namespace std;
 
#define listSize 100      
#define listcrement 10
int a;
typedef struct                          //类型定义
{  int *base;
   int length;
   int listsize;
}List;
 
void initList(List &L)                  //初始化
{  L.base=(int*)malloc(listSize*sizeof(int));
   if(!L.base) return;
   L.length=0;
   L.listsize=listSize;
}
 
int listempty(List L)                   //判空
{ if(L.length==0) return 1;
  return 0;
}
 
int listlength(List L)                 //求长度
{
   return L.length;
}
 
int getelement(List &L,int i)          //取元素
{   if(i<1||i>L.length) return -1;
    int e=L.base[i-1];
    return e;
}
 
int Locatelem(List L,int e)           //查位序
{  int i=0;
   while(i<L.length&&L.base[i]!=e)
    i++;
   if(i<L.length)
    return i+1;
}
 
void ListInsert(List &L,int i,int e)  //i前插入
{  if(i>L.length+1||i<1) return ;
   if(L.length+1>L.listsize)
    { (int*)realloc(L.base,(L.listsize+listcrement)*sizeof(int));
      //if(!newbase) return;
      //L.base=newbase;
      L.listsize+=listcrement;
    }
   for(int j=L.length-1;j>=i-1;j--)
     L.base[j+1]=L.base[j];
     L.base[i-1]=e;
     L.length++;
}
 
void Delete(List &L,int i)          //删除
{    if(L.length<i) return;
     for(int j=i;j<L.length;j++)
       L.base[j-1]=L.base[j];
     L.length--;
}
int main()
{   List ll;
    initList(ll);
 
    ll.base[0]=1;
    ll.length++;
 
    ListInsert(ll,1,2);
    ListInsert(ll,1,3);
    ListInsert(ll,1,4);
    ListInsert(ll,2,5);
 
    cout<<ll.length<<"\n";
    for(int i=0;i<=4;i++)
      cout<<ll.base[i]<<" ";
    cout<<"\n";
 
    Delete(ll,1);
 
    for(int i=0;i<ll.length;i++)
      cout<<ll.base[i]<<" ";
    cout<<"\n";
 
    cout<<Locatelem(ll,2);
 
}