数据结构之顺序表

目录

存储结构

操作实现

类型定义

初始化

判空

求长

插入

查找

删除

测试

存储结构

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

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

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

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

操作实现

• 类型定义

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

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

• 删除

判断i的合法性；

正序左移i前元素；

长度减一；

void Delete(List &L,int i)
{    
     if(L.length

测试

#include
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(iL.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