数据结构：顺序表的静态和动态实现

最新推荐文章于 2023-10-20 10:55:58 发布
最新推荐文章于 2023-10-20 10:55:58 发布
阅读量392 收藏 1
点赞数
分类专栏： C语言技术网 数据结构 文章标签： 顺序表 静态 动态 结构体 内存管理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41962968/article/details/122159671
版权 
/*
 * 程序名：seqlist1.c，此程序演示顺序表的静态实现，数据元素是整数。
 * 
*/
#include <stdio.h>
#include <string.h>

#define MAXSIZE 100       // 顺序表的最大长度

typedef int ElemType;     // 自定义顺序表的数据元素为整数。

typedef struct
{
  ElemType data[MAXSIZE];   // 用数组存储顺序表中的元素
  unsigned int length;      // 顺序表中元素的个数
}SeqList,*PSeqList;

// 顺序表LL的初始化操作。
void InitList(PSeqList LL);                     

// 销毁顺序表LL。
void DestroyList(PSeqList LL);

// 在顺序表LL的第ii个位置插入元素ee，返回值：0-失败；1-成功。
int  InsertList(PSeqList LL, unsigned int ii, ElemType *ee);   

// 在顺序表LL的头结点插入元素ee，返回值：0-失败；1-成功。
int  PushFront(PSeqList LL, ElemType *ee);

// 在顺序表LL的尾结点插入元素ee，返回值：0-失败；1-成功。
int  PushBack(PSeqList LL, ElemType *ee);

// 求顺序表的长度，返回值：>=0-表LL元素的个数。
int  LengthList(PSeqList LL);                   

// 获取顺序表中第ii个元素的值，存放在ee中，返回值：0-失败；1-成功。
int  GetElem(PSeqList LL, unsigned int ii, ElemType* ee);  

// 清空顺序表。
void ClearList(PSeqList LL);                    

// 判断顺序表是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PSeqList LL);                    

// 打印顺序表中全部的元素。
void PrintList(PSeqList LL);                    

// 查找ee在顺序表LL中的位置，返回值：0-元素ee在表LL中不存在，>0元素ee在表LL中的位置。
int  LocateElem(PSeqList LL, ElemType *ee);

// 删除顺序表LL中的第ii个元素，返回值：0-位置ii不合法；1-成功。
int  DeleteElem(PSeqList LL, unsigned int ii);  

// 删除顺序表LL中头元素，返回值：0-位置ii不合法；1-成功。
int PopFront(PSeqList LL);

// 删除顺序表LL中尾元素，返回值：0-位置ii不合法；1-成功。
int PopBack(PSeqList LL);

// 采用归并的方法，将两个升序的顺序表La和Lb，合并成一个升序的顺序表Lc。
int MergeList(PSeqList La,PSeqList Lb,PSeqList Lc);

int main()
{
  SeqList LL;     // 创建顺序表。

  ElemType ee;    // 创建一个数据元素。

  InitList(&LL);  // 初始化顺序表。

  printf("在表中插入元素（1、2、3、4、5、6、7、8、9、10）。\n");
  ee=1;  InsertList(&LL, 1, &ee);
  ee=2;  InsertList(&LL, 1, &ee);
  ee=3;  InsertList(&LL, 1, &ee);
  ee=4;  InsertList(&LL, 1, &ee);
  ee=5;  InsertList(&LL, 1, &ee);
  ee=6;  InsertList(&LL, 1, &ee);
  ee=7;  InsertList(&LL, 1, &ee);
  ee=8;  InsertList(&LL, 1, &ee);
  ee=9;  InsertList(&LL, 1, &ee);
  ee=10; InsertList(&LL, 1, &ee);

  PrintList(&LL);

  printf("在表头插入元素（11），表尾插入元素（12）。\n");
  ee=11; PushFront(&LL, &ee);
  ee=12; PushBack(&LL, &ee);

  PrintList(&LL);

  printf("在第5个位置插入元素（13）。\n");
  ee=13; InsertList(&LL, 5, &ee);  

  PrintList(&LL);

  printf("删除表中第7个元素。\n");
  DeleteElem(&LL,7); PrintList(&LL);

  printf("删除表头元素。\n");
  PopFront(&LL); PrintList(&LL);

  printf("删除表尾元素。\n");
  PopBack(&LL); PrintList(&LL);

  GetElem(&LL,3,&ee);
  printf("第3个元素的值是%d。\n",ee);

  ee=8;
  printf("元素值为8的位置是=%d\n",LocateElem(&LL,&ee));

  /*
  // 以下代码显示两个顺序表的合并，把两个有序的La和Lb合并成有序的Lc。
  SeqList La,Lb,Lc;

  InitList(&La);
  InitList(&Lb);
  InitList(&Lc);

  ee=1;  PushBack(&Lb, &ee);
  ee=2;  PushBack(&La, &ee);
  ee=3;  PushBack(&Lb, &ee);
  ee=4;  PushBack(&Lb, &ee);
  ee=5;  PushBack(&La, &ee);
  ee=6;  PushBack(&Lb, &ee);
  ee=7;  PushBack(&Lb, &ee);
  ee=8;  PushBack(&Lb, &ee);
  ee=9;  PushBack(&La, &ee);
  ee=10; PushBack(&La, &ee);

  PrintList(&La);
  PrintList(&Lb);

  MergeList(&La,&Lb,&Lc);

  PrintList(&Lc);
  */

  return 0;
}

// 初始化顺序表
void InitList(PSeqList LL)
{
  ClearList(LL); // 清空顺序表。
}

// 清空顺序表。
void ClearList(PSeqList LL)
{
  if (LL == NULL) return;  // 检查空指针。

  LL->length=0;  // 表长置为0。
  memset(LL->data,0,sizeof(ElemType)*MAXSIZE);  // 数组元素清0。
}

// 求顺序表的长度，返回值：>=0-表LL元素的个数。
int LengthList(PSeqList LL)
{
  if (LL == NULL) return 0;  // 检查空指针。

  return LL->length;
}

// 获取顺序表中第ii个元素的值，存放在ee中，返回值：0-失败；1-成功。
int  GetElem(PSeqList LL, unsigned int ii, ElemType* ee)
{
  if ( (LL == NULL) || (ee == NULL) ) return 0;   // 检查空指针。
  
  // 判断位置ii是否合法
  if ( (ii < 1) || (ii > LL->length) ) return 0;

  //memcpy(ee,LL->data+ii-1,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。
  memcpy(ee,&LL->data[ii-1],sizeof(ElemType));   // 用数组的形式也可以。

  return ;
}

// 在顺序表LL的第ii个位置插入元素ee，返回值：0-失败；1-成功。
int InsertList(PSeqList LL, unsigned int ii, ElemType *ee)
{
  if ( (LL == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (LL->length >= MAXSIZE)
  {
    printf("顺序表已满，不能插入。\n"); return 0;
  }

  // 判断插入位置是否合法
  if ( (ii < 1) || (ii > LL->length+1) )
  {
    printf("插入位置（%d）不合法，应该在（%d-%d）之间。\n",ii,1,LL->length+1); return 0;
  }

  // 注意，元素后移只能用循环，不能用以下注释掉的方法，当元素是结构体时，以下方法不稳定。
  // if ( ii < LL->length+1)
  //    memcpy(LL->data+ii,LL->data+ii-1,(LL->length-ii+1)*sizeof(ElemType));

  // 把ii和ii之后的元素后移。
  int kk;
  for (kk=LL->length;kk>=ii;kk--)
  {
    // memcpy(LL->data+kk,LL->data+kk-1,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。
    memcpy(&LL->data[kk],&LL->data[kk-1],sizeof(ElemType));  // 用数组的形式也可以。
  }

  //memcpy(LL->data+ii-1,ee,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。
  memcpy(&LL->data[ii-1],ee,sizeof(ElemType));  // 用数组的形式也可以。
  LL->length++;       // 表的长度加1。

  return 1;
}

// 在顺序表LL的头结点插入元素ee，返回值：0-失败；1-成功。
int  PushFront(PSeqList LL, ElemType *ee)
{
  return InsertList(LL,1,ee);
}

// 在顺序表LL的尾结点插入元素ee，返回值：0-失败；1-成功。
int PushBack(PSeqList LL, ElemType *ee)
{
  return InsertList(LL,LL->length+1,ee);
}

// 删除顺序表LL中的第ii个元素，返回值：0-位置ii不合法；1-成功。
int DeleteElem(PSeqList LL, unsigned int ii)
{
  if (LL == NULL) return 0;   // 检查空指针。

  // 判断删除位置ii是否合法
  if ( (ii < 1) || (ii > LL->length) )
  {
    printf("删除位置（%d）不合法，应该在（%d-%d）之间\n",ii,1,LL->length); return 0;
  }

  // 把ii之后的元素前移。
  int k;
  for (k=ii;k<=LL->length;k++)
  {
    // memcpy(LL->data+k-1,LL->data+k,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。
    memcpy(&LL->data[k-1],&LL->data[k],sizeof(ElemType));   // 用数组的形式也可以。
  }

  LL->length--;       // 表的长度减1。

  return 1;
}

// 查找ee在顺序表LL中的位置，返回值：0-元素ee在表LL中不存在，>0元素ee在表LL中的位置。
int LocateElem(PSeqList LL, ElemType *ee)
{
  if ( (LL == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  int kk;

  for (kk = 0; kk < LL->length; kk++)
  {
    // 如果元素ee为结构体，这行代码要修改。
    // if (*(LL->data+kk) == *ee) return kk+1; // 在表中对应序号应为kk+1。
    if (LL->data[kk] == *ee) return kk+1; // 用数组的形式也可以。
  }
    
  return 0;
}

// 删除顺序表LL中头元素，返回值：0-位置ii不合法；1-成功。
int PopFront(PSeqList LL)
{
  return DeleteElem(LL, 1);
}

// 删除顺序表LL中尾元素，返回值：0-位置ii不合法；1-成功。
int PopBack(PSeqList LL)
{
  return DeleteElem(LL, LL->length);
}

// 判断顺序表是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqList LL)
{
  if (LL == NULL) return 0;   // 检查空指针。

  if (LL->length == 0) return 1;

  return 0;
}

// 打印顺序表中全部的元素。
void PrintList(PSeqList LL)
{
  if (LL == NULL) return;   // 检查空指针。

  if (LL->length == 0) { printf("表为空。\n"); return; }

  int kk;
  for (kk = 0; kk < LL->length; kk++)
  {
    // printf("%-3d", *(LL->data+kk));  // 如果元素ee为结构体，这行代码要修改。
    printf("%-3d", LL->data[kk]);  // 用数组的形式也可以。
  }

  printf("\n");
}

// 采用归并的方法，将两个升序的顺序表La和Lb，合并成一个升序的顺序表Lc。
int MergeList(PSeqList La,PSeqList Lb,PSeqList Lc)
{
  if ( (La == NULL) || (Lb == NULL) || (Lc == NULL) )   // 检查空指针。

  if ( MAXSIZE < La->length + Lb->length ) { printf("表Lc的长度不够。\n"); return 0; }

  int istartla=0;  // 表La第一个元素的位置。
  int istartlb=0;  // 表Lb第一个元素的位置。
  int istartlc=0;  // 表Lc第一个元素的位置。

  // 把La和Lb合并到Lc中。
  while (istartla < La->length && istartlb < Lb->length)
    Lc->data[istartlc++]=La->data[istartla]<Lb->data[istartlb] ? La->data[istartla++] : Lb->data[istartlb++];

  // 把La其它的元素追加到Lc中。
  while (istartla < La->length) Lc->data[istartlc++]=La->data[istartla++];

  // 把Lb其它的元素追加到Lc中。
  while (istartlb < Lb->length) Lc->data[istartlc++]=Lb->data[istartlb++];

  Lc->length=La->length + Lb->length;

  return 1;
}

// 销毁顺序表LL。
void DestroyList(PSeqList LL)
{
  // 静态顺序表无需释放内存，不需要销毁操作。
  return;
}

/*
 * 程序名：seqlist2.c，此程序演示顺序表的静态实现，数据元素是结构体。
 * 
*/
#include <stdio.h>
#include <string.h>

#define MAXSIZE 100       // 顺序表的最大长度

typedef struct
{
  int  no;        // 超女编号。
  char name[31];  // 超女姓名。
}ElemType;        // 自定义顺序表的数据元素为结构体。

typedef struct
{
  ElemType data[MAXSIZE];   // 用数组存储顺序表中的元素
  unsigned int length;      // 顺序表中元素的个数
}SeqList,*PSeqList;

// 顺序表LL的初始化操作。
void InitList(PSeqList LL);                     

// 销毁顺序表LL。
void DestroyList(PSeqList LL);

// 在顺序表LL的第ii个位置插入元素ee，返回值：0-失败；1-成功。
int  InsertList(PSeqList LL, unsigned int ii, ElemType *ee);   

// 在顺序表LL的头结点插入元素ee，返回值：0-失败；1-成功。
int  PushFront(PSeqList LL, ElemType *ee);

// 在顺序表LL的尾结点插入元素ee，返回值：0-失败；1-成功。
int  PushBack(PSeqList LL, ElemType *ee);

// 求顺序表的长度，返回值：>=0-表LL元素的个数。
int  LengthList(PSeqList LL);                   

// 获取顺序表中第ii个元素的值，存放在ee中，返回值：0-失败；1-成功。
int  GetElem(PSeqList LL, unsigned int ii, ElemType* ee);  

// 清空顺序表。
void ClearList(PSeqList LL);                    

// 判断顺序表是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PSeqList LL);                    

// 打印顺序表中全部的元素。
void PrintList(PSeqList LL);                    

// 查找ee在顺序表LL中的位置，返回值：0-元素ee在表LL中不存在，>0元素ee在表LL中的位置。
int  LocateElem(PSeqList LL, ElemType *ee);

// 删除顺序表LL中的第ii个元素，返回值：0-位置ii不合法；1-成功。
int  DeleteElem(PSeqList LL, unsigned int ii);  

// 删除顺序表LL中头元素，返回值：0-位置ii不合法；1-成功。
int PopFront(PSeqList LL);

// 删除顺序表LL中尾元素，返回值：0-位置ii不合法；1-成功。
int PopBack(PSeqList LL);

int main()
{
  SeqList LL;     // 创建顺序表。

  ElemType ee;    // 创建一个数据元素。

  InitList(&LL);  // 初始化顺序表。

  printf("在表中插入元素（1、2、3、4、5、6、7、8、9、10）。\n");
  ee.no=1;  InsertList(&LL, 1, &ee); 
  ee.no=2;  InsertList(&LL, 1, &ee);
  ee.no=3;  InsertList(&LL, 1, &ee);
  ee.no=4;  InsertList(&LL, 1, &ee);
  ee.no=5;  InsertList(&LL, 1, &ee);
  ee.no=6;  InsertList(&LL, 1, &ee);
  ee.no=7;  InsertList(&LL, 1, &ee);
  ee.no=8;  InsertList(&LL, 1, &ee);
  ee.no=9;  InsertList(&LL, 1, &ee);
  ee.no=10; InsertList(&LL, 1, &ee);

  PrintList(&LL);

  printf("在表头插入元素（11），表尾插入元素（12）。\n");
  ee.no=11; PushFront(&LL, &ee);
  ee.no=12; PushBack(&LL, &ee);

  PrintList(&LL);

  printf("在第5个位置插入元素（13）。\n");
  ee.no=13; InsertList(&LL, 5, &ee);  

  PrintList(&LL);

  printf("删除表中第7个元素。\n");
  DeleteElem(&LL,7); PrintList(&LL);

  printf("删除表头元素。\n");
  PopFront(&LL); PrintList(&LL);

  printf("删除表尾元素。\n");
  PopBack(&LL); PrintList(&LL);

  GetElem(&LL,3,&ee);
  printf("第3个元素的值是%d。\n",ee.no);

  ee.no=8;
  printf("元素值为8的位置是=%d\n",LocateElem(&LL,&ee));

  return 0;
}

// 初始化顺序表
void InitList(PSeqList LL)
{
  ClearList(LL); // 清空顺序表。
}

// 清空顺序表。
void ClearList(PSeqList LL)
{
  if (LL == NULL) return;  // 检查空指针。

  LL->length=0;
  memset(LL->data,0,sizeof(ElemType)*MAXSIZE);
}

// 求顺序表的长度，返回值：>=0-表LL元素的个数。
int LengthList(PSeqList LL)
{
  if (LL == NULL) return 0;  // 检查空指针。

  return LL->length;
}

// 获取顺序表中第ii个元素的值，存放在ee中，返回值：0-失败；1-成功。
int  GetElem(PSeqList LL, unsigned int ii, ElemType* ee)
{
  if ( (LL == NULL) || (ee == NULL) ) return 0;   // 检查空指针。
  
  // 判断位置ii是否合法
  if ( (ii < 1) || (ii > LL->length) ) return 0;

  memcpy(ee,LL->data+ii-1,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。

  return ;
}

// 在顺序表LL的第ii个位置插入元素ee，返回值：0-失败；1-成功。
int InsertList(PSeqList LL, unsigned int ii, ElemType *ee)
{
  if ( (LL == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (LL->length >= MAXSIZE)
  {
    printf("顺序表已满，不能插入。\n"); return 0;
  }

  // 判断插入位置是否合法
  if ( (ii < 1) || (ii > LL->length+1) )
  {
    printf("插入位置（%d）不合法，应该在（%d-%d）之间。\n",ii,1,LL->length+1); return 0;
  }

  // 注意，元素后移只能用循环，不能用以下注释掉的方法，当元素是结构体时，以下方法不稳定。
  // if ( ii < LL->length+1)
  //   memcpy(LL->data+ii,LL->data+ii-1,(LL->length-ii+1)*sizeof(ElemType));

  // 把ii和ii之后的元素后移。
  int kk;
  for (kk=LL->length;kk>=ii;kk--)
  {
    memcpy(LL->data+kk,LL->data+kk-1,sizeof(ElemType));  // 采用memcpy是为了支持e为结构体的情况。
  }

  memcpy(LL->data+ii-1,ee,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。
  LL->length++;       // 表的长度加1。

  return 1;
}

// 在顺序表LL的头结点插入元素ee，返回值：0-失败；1-成功。
int  PushFront(PSeqList LL, ElemType *ee)
{
  return InsertList(LL,1,ee);
}

// 在顺序表LL的尾结点插入元素ee，返回值：0-失败；1-成功。
int PushBack(PSeqList LL, ElemType *ee)
{
  return InsertList(LL,LL->length+1,ee);
}

// 删除顺序表LL中的第ii个元素，返回值：0-位置ii不合法；1-成功。
int DeleteElem(PSeqList LL, unsigned int ii)
{
  if (LL == NULL) return 0;   // 检查空指针。

  // 判断删除位置ii是否合法
  if ( (ii < 1) || (ii > LL->length) )
  {
    printf("删除位置（%d）不合法，应该在（%d-%d）之间\n",ii,1,LL->length); return 0;
  }

  // 把ii之后的元素前移。
  int kk;
  for (kk=ii;kk<=LL->length;kk++)
  {
    memcpy(LL->data+kk-1,LL->data+kk,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。
  }

  LL->length--;       // 表的长度减1。

  return 1;
}

// 查找ee在顺序表LL中的位置，返回值：0-元素ee在表LL中不存在，>0元素ee在表LL中的位置。
int LocateElem(PSeqList LL, ElemType *ee)
{
  if ( (LL == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  int kk;

  for (kk = 0; kk < LL->length; kk++)
  {
    // 元素ee为结构体，这行代码与元素为整数时的方式不一样，比较超女结构体的编号。
    if ((LL->data+kk)->no == ee->no) return kk+1; // 在表中对应序号应为kk+1。
  }
    
  return 0;
}

// 删除顺序表LL中头元素，返回值：0-位置ii不合法；1-成功。
int PopFront(PSeqList LL)
{
  return DeleteElem(LL, 1);
}

// 删除顺序表LL中尾元素，返回值：0-位置ii不合法；1-成功。
int PopBack(PSeqList LL)
{
  return DeleteElem(LL, LL->length);
}

// 判断顺序表是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqList LL)
{
  if (LL == NULL) return 0;   // 检查空指针。

  if (LL->length == 0) return 1;

  return 0;
}

// 打印顺序表中全部的元素。
void PrintList(PSeqList LL)
{
  if (LL == NULL) return;   // 检查空指针。

  if (LL->length == 0) { printf("表为空。\n"); return; }

  int kk;
  for (kk = 0; kk < LL->length; kk++)
  {
    // 元素ee为结构体，这行代码与元素为整数时的方式不一样，这里输出超女结构体的编号。
    printf("%-3d", (LL->data+kk)->no);  // 输出超女的编号。
  }

  printf("\n");
}

// 销毁顺序表LL。
void DestroyList(PSeqList LL)
{
  // 静态顺序表无需释放内存，不需要销毁操作。
  return;
}


/*
 * 程序名：seqlist3.c，此程序演示顺序表的动态实现，数据元素是整数。
 * 
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define INITSIZE 10        // 顺序表的初始长度。
#define EXTSIZE   5        // 每次扩展元素的个数。

typedef int ElemType;      // 自定义顺序表的数据元素为整数。

typedef struct
{
  ElemType *data;           // 存储顺序表中元素的首地址。
  unsigned int maxsize;     // 顺序表元素的最大长度。
  unsigned int length;      // 顺序表中元素的个数。
}SeqList,*PSeqList;

// 顺序表LL的初始化操作。
void InitList(PSeqList LL);                     

// 销毁顺序表LL。
void DestroyList(PSeqList LL);

// 扩展顺序表的内存空间，返回值：0-失败；1-成功。
int ExtList(PSeqList LL);

// 在顺序表LL的第ii个位置插入元素ee，返回值：0-失败；1-成功。
int  InsertList(PSeqList LL, unsigned int ii, ElemType *ee);   

// 在顺序表LL的头结点插入元素ee，返回值：0-失败；1-成功。
int  PushFront(PSeqList LL, ElemType *ee);

// 在顺序表LL的尾结点插入元素ee，返回值：0-失败；1-成功。
int  PushBack(PSeqList LL, ElemType *ee);

// 求顺序表的长度，返回值：>=0-表LL元素的个数。
int  LengthList(PSeqList LL);                   

// 获取顺序表中第ii个元素的值，存放在ee中，返回值：0-失败；1-成功。
int  GetElem(PSeqList LL, unsigned int ii, ElemType* ee);  

// 清空顺序表。
void ClearList(PSeqList LL);                    

// 判断顺序表是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PSeqList LL);                    

// 打印顺序表中全部的元素。
void PrintList(PSeqList LL);                    

// 查找ee在顺序表LL中的位置，返回值：0-元素ee在表LL中不存在，>0元素ee在表LL中的位置。
int  LocateElem(PSeqList LL, ElemType *ee);

// 删除顺序表LL中的第ii个元素，返回值：0-位置ii不合法；1-成功。
int  DeleteElem(PSeqList LL, unsigned int ii);  

// 删除顺序表LL中头元素，返回值：0-位置ii不合法；1-成功。
int PopFront(PSeqList LL);

// 删除顺序表LL中尾元素，返回值：0-位置ii不合法；1-成功。
int PopBack(PSeqList LL);

int main()
{
  SeqList LL;     // 创建顺序表。

  ElemType ee;    // 创建一个数据元素。

  InitList(&LL);  // 初始化顺序表。

  printf("在表中插入元素（1、2、3、4、5、6、7、8、9、10）。\n");
  ee=1;  InsertList(&LL, 1, &ee);
  ee=2;  InsertList(&LL, 1, &ee);
  ee=3;  InsertList(&LL, 1, &ee);
  ee=4;  InsertList(&LL, 1, &ee);
  ee=5;  InsertList(&LL, 1, &ee);
  ee=6;  InsertList(&LL, 1, &ee);
  ee=7;  InsertList(&LL, 1, &ee);
  ee=8;  InsertList(&LL, 1, &ee);
  ee=9;  InsertList(&LL, 1, &ee);
  ee=10; InsertList(&LL, 1, &ee);

  PrintList(&LL);

  printf("在表头插入元素（11），表尾插入元素（12）。\n");
  ee=11; PushFront(&LL, &ee);
  ee=12; PushBack(&LL, &ee);

  PrintList(&LL);

  printf("在第5个位置插入元素（13）。\n");
  ee=13; InsertList(&LL, 5, &ee);  

  PrintList(&LL);

  printf("删除表中第7个元素。\n");
  DeleteElem(&LL,7); PrintList(&LL);

  printf("删除表头元素。\n");
  PopFront(&LL); PrintList(&LL);

  printf("删除表尾元素。\n");
  PopBack(&LL); PrintList(&LL);

  GetElem(&LL,3,&ee);
  printf("第3个元素的值是%d。\n",ee);

  ee=8;
  printf("元素值为8的位置是=%d\n",LocateElem(&LL,&ee));

  DestroyList(&LL);  // 销毁顺序表LL。

  return 0;
}

// 初始化顺序表
void InitList(PSeqList LL)
{
  LL->data=(ElemType *)malloc(sizeof(ElemType)*INITSIZE);
  LL->maxsize=INITSIZE;

  ClearList(LL); // 清空顺序表。
}

// 清空顺序表。
void ClearList(PSeqList LL)
{
  if (LL == NULL) return;  // 检查空指针。

  LL->length=0;
  memset(LL->data,0,sizeof(ElemType)*LL->maxsize);
}

// 销毁顺序表LL。
void DestroyList(PSeqList LL)
{
  free(LL->data);

  LL->maxsize=0;
  LL->length=0;
}

// 求顺序表的长度，返回值：>=0-表LL元素的个数。
int LengthList(PSeqList LL)
{
  if (LL == NULL) return 0;  // 检查空指针。

  return LL->length;
}

// 获取顺序表中第ii个元素的值，存放在ee中，返回值：0-失败；1-成功。
int  GetElem(PSeqList LL, unsigned int ii, ElemType* ee)
{
  if ( (LL == NULL) || (ee == NULL) ) return 0;   // 检查空指针。
  
  // 判断位置ii是否合法
  if ( (ii < 1) || (ii > LL->length) ) return 0;

  memcpy(ee,LL->data+ii-1,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。

  return ;
}

// 扩展顺序表的内存空间，返回值：0-失败；1-成功。
int ExtList(PSeqList LL)
{
  // 分配新的内存空间。
  ElemType *newdata=(ElemType *)malloc(sizeof(ElemType)*(LL->maxsize+EXTSIZE));

  // 如果分配失败，返回0。
  if (newdata == NULL) return 0;

  memset(newdata,0,sizeof(ElemType)*(LL->maxsize+EXTSIZE));

  // 把顺序表中原来的内容复制到新分配的内存空间中。
  memcpy(newdata,LL->data,sizeof(ElemType)*LL->maxsize);

  // 释放原来的内存空间。
  free(LL->data);

  // 把顺序表数据元素的指针指向新分配的内存空间的地址。
  LL->data=newdata;

  // 重置顺序表的maxsize变量。
  LL->maxsize=LL->maxsize+EXTSIZE;

  return 1;
}

// 在顺序表LL的第ii个位置插入元素ee，返回值：0-失败；1-成功。
int InsertList(PSeqList LL, unsigned int ii, ElemType *ee)
{
  if ( (LL == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (LL->length >= LL->maxsize)
  {
    if (ExtList(LL) == 0) { printf("护展顺序表失败。\n"); return 0; }
  }

  // 判断插入位置是否合法
  if ( (ii < 1) || (ii > LL->length+1) )
  {
    printf("插入位置（%d）不合法，应该在（%d-%d）之间。\n",ii,1,LL->length+1); return 0;
  }

  // 注意，元素后移只能用循环，不能用以下注释掉的方法，当元素是结构体时，以下方法不稳定。
  // if ( ii < LL->length+1)
  //   memcpy(LL->data+ii,LL->data+ii-1,(LL->length-ii+1)*sizeof(ElemType));

  // 把ii和ii之后的元素后移。
  int kk;
  for (kk=LL->length;kk>=ii;kk--)
  {
    memcpy(LL->data+kk,LL->data+kk-1,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。
    // memcpy(&LL->data[kk],&LL->data[kk-1],sizeof(ElemType));  // 也可以采用数组的形式。
  }

  memcpy(LL->data+ii-1,ee,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。
  LL->length++;       // 表的长度加1。

  return 1;
}

// 在顺序表LL的头结点插入元素ee，返回值：0-失败；1-成功。
int  PushFront(PSeqList LL, ElemType *ee)
{
  return InsertList(LL,1,ee);
}

// 在顺序表LL的尾结点插入元素ee，返回值：0-失败；1-成功。
int PushBack(PSeqList LL, ElemType *ee)
{
  return InsertList(LL,LL->length+1,ee);
}

// 删除顺序表LL中的第ii个元素，返回值：0-位置ii不合法；1-成功。
int DeleteElem(PSeqList LL, unsigned int ii)
{
  if (LL == NULL) return 0;   // 检查空指针。

  // 判断删除位置ii是否合法
  if ( (ii < 1) || (ii > LL->length) )
  {
    printf("删除位置（%d）不合法，应该在（%d-%d）之间\n",ii,1,LL->length); return 0;
  }

  // 把ii之后的元素前移。
  int kk;
  for (kk=ii;kk<=LL->length;kk++)
  {
    memcpy(LL->data+kk-1,LL->data+kk,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。
  }

  LL->length--;       // 表的长度减1。

  return 1;
}

// 查找ee在顺序表LL中的位置，返回值：0-元素ee在表LL中不存在，>0元素ee在表LL中的位置。
int LocateElem(PSeqList LL, ElemType *ee)
{
  if (LL == NULL) return 0;   // 检查空指针。

  int kk;

  for (kk = 0; kk < LL->length; kk++)
  {
    // 如果元素ee为结构体，这行代码要修改。
    if (*(LL->data+kk) == *ee) return kk+1; // 在表中对应序号应为kk+1。
  }
    
  return 0;
}

// 删除顺序表LL中头元素，返回值：0-位置ii不合法；1-成功。
int PopFront(PSeqList LL)
{
  return DeleteElem(LL, 1);
}

// 删除顺序表LL中尾元素，返回值：0-位置ii不合法；1-成功。
int PopBack(PSeqList LL)
{
  return DeleteElem(LL, LL->length);
}

// 判断顺序表是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqList LL)
{
  if (LL == NULL) return 0;   // 检查空指针。

  if (LL->length == 0) return 1;

  return 0;
}

// 打印顺序表中全部的元素。
void PrintList(PSeqList LL)
{
  if (LL == NULL) return;   // 检查空指针。

  if (LL->length == 0) { printf("表为空。\n"); return; }

  int kk;
  for (kk = 0; kk < LL->length; kk++)
  {
    printf("%-3d", *(LL->data+kk));  // 如果元素ee为结构体，这行代码要修改。
  }

  printf("\n");
}



/*
 * 程序名：seqlist4.c，此程序演示顺序表的动态实现，数据元素是结构体。
 * 
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define INITSIZE 10        // 顺序表的初始长度。
#define EXTSIZE   5        // 每次扩展元素的个数。

typedef struct
{
  int  no;        // 超女编号。
  char name[31];  // 超女姓名。
}ElemType;        // 自定义顺序表的数据元素为结构体。

typedef struct
{
  ElemType *data;           // 存储顺序表中元素的首地址。
  unsigned int maxsize;     // 顺序表元素的最大长度。
  unsigned int length;      // 顺序表中元素的个数。
}SeqList,*PSeqList;

// 顺序表LL的初始化操作。
void InitList(PSeqList LL);                     

// 销毁顺序表LL。
void DestroyList(PSeqList LL);

// 扩展顺序表的内存空间，返回值：0-失败；1-成功。
int ExtList(PSeqList LL);

// 在顺序表LL的第ii个位置插入元素ee，返回值：0-失败；1-成功。
int  InsertList(PSeqList LL, unsigned int ii, ElemType *ee);   

// 在顺序表LL的头结点插入元素ee，返回值：0-失败；1-成功。
int  PushFront(PSeqList LL, ElemType *ee);

// 在顺序表LL的尾结点插入元素ee，返回值：0-失败；1-成功。
int  PushBack(PSeqList LL, ElemType *ee);

// 求顺序表的长度，返回值：>=0-表LL元素的个数。
int  LengthList(PSeqList LL);                   

// 获取顺序表中第ii个元素的值，存放在ee中，返回值：0-失败；1-成功。
int  GetElem(PSeqList LL, unsigned int ii, ElemType* ee);  

// 清空顺序表。
void ClearList(PSeqList LL);                    

// 判断顺序表是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PSeqList LL);                    

// 打印顺序表中全部的元素。
void PrintList(PSeqList LL);                    

// 查找ee在顺序表LL中的位置，返回值：0-元素ee在表LL中不存在，>0元素ee在表LL中的位置。
int  LocateElem(PSeqList LL, ElemType *ee);

// 删除顺序表LL中的第ii个元素，返回值：0-位置ii不合法；1-成功。
int  DeleteElem(PSeqList LL, unsigned int ii);  

// 删除顺序表LL中头元素，返回值：0-位置ii不合法；1-成功。
int PopFront(PSeqList LL);

// 删除顺序表LL中尾元素，返回值：0-位置ii不合法；1-成功。
int PopBack(PSeqList LL);

int main()
{
  SeqList LL;     // 创建顺序表。

  ElemType ee;    // 创建一个数据元素。

  InitList(&LL);  // 初始化顺序表。

  printf("在表中插入元素（1、2、3、4、5、6、7、8、9、10）。\n");
  ee.no=1;  InsertList(&LL, 1, &ee);
  ee.no=2;  InsertList(&LL, 1, &ee);
  ee.no=3;  InsertList(&LL, 1, &ee);
  ee.no=4;  InsertList(&LL, 1, &ee);
  ee.no=5;  InsertList(&LL, 1, &ee);
  ee.no=6;  InsertList(&LL, 1, &ee);
  ee.no=7;  InsertList(&LL, 1, &ee);
  ee.no=8;  InsertList(&LL, 1, &ee);
  ee.no=9;  InsertList(&LL, 1, &ee);
  ee.no=10; InsertList(&LL, 1, &ee);

  PrintList(&LL);

  printf("在表头插入元素（11），表尾插入元素（12）。\n");
  ee.no=11; PushFront(&LL, &ee);
  ee.no=12; PushBack(&LL, &ee);

  PrintList(&LL);

  printf("在第5个位置插入元素（13）。\n");
  ee.no=13; InsertList(&LL, 5, &ee);

  PrintList(&LL);

  printf("删除表中第7个元素。\n");
  DeleteElem(&LL,7); PrintList(&LL);

  printf("删除表头元素。\n");
  PopFront(&LL); PrintList(&LL);

  printf("删除表尾元素。\n");
  PopBack(&LL); PrintList(&LL);

  GetElem(&LL,3,&ee);
  printf("第3个元素的值是%d。\n",ee.no);

  ee.no=8;
  printf("元素值为8的位置是=%d\n",LocateElem(&LL,&ee));

  DestroyList(&LL);  // 销毁顺序表LL。

  return 0;
}

// 初始化顺序表
void InitList(PSeqList LL)
{
  LL->data=(ElemType *)malloc(sizeof(ElemType)*INITSIZE);
  LL->maxsize=INITSIZE;

  ClearList(LL); // 清空顺序表。
}

// 清空顺序表。
void ClearList(PSeqList LL)
{
  if (LL == NULL) return;  // 检查空指针。

  LL->length=0;
  memset(LL->data,0,sizeof(ElemType)*LL->maxsize);
}

// 销毁顺序表LL。
void DestroyList(PSeqList LL)
{
  free(LL->data);

  LL->maxsize=0;
  LL->length=0;
}

// 求顺序表的长度，返回值：>=0-表LL元素的个数。
int LengthList(PSeqList LL)
{
  if (LL == NULL) return 0;  // 检查空指针。

  return LL->length;
}

// 获取顺序表中第ii个元素的值，存放在ee中，返回值：0-失败；1-成功。
int  GetElem(PSeqList LL, unsigned int ii, ElemType* ee)
{
  if ( (LL == NULL) || (ee == NULL) ) return 0;   // 检查空指针。
  
  // 判断位置ii是否合法
  if ( (ii < 1) || (ii > LL->length) ) return 0;

  memcpy(ee,LL->data+ii-1,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。

  return ;
}

// 扩展顺序表的内存空间，返回值：0-失败；1-成功。
int ExtList(PSeqList LL)
{
  // 分配新的内存空间。
  ElemType *newdata=(ElemType *)malloc(sizeof(ElemType)*(LL->maxsize+EXTSIZE));

  // 如果分配失败，返回0。
  if (newdata == NULL) return 0;

  memset(newdata,0,sizeof(ElemType)*(LL->maxsize+EXTSIZE));

  // 把顺序表中原来的内容复制到新分配的内存空间中。
  memcpy(newdata,LL->data,sizeof(ElemType)*LL->maxsize);

  // 释放原来的内存空间。
  free(LL->data);

  // 把顺序表数据元素的指针指向新分配的内存空间的地址。
  LL->data=newdata;

  // 重置顺序表的maxsize变量。
  LL->maxsize=LL->maxsize+EXTSIZE;

  return 1;
}

// 在顺序表LL的第ii个位置插入元素ee，返回值：0-失败；1-成功。
int InsertList(PSeqList LL, unsigned int ii, ElemType *ee)
{
  if ( (LL == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (LL->length >= LL->maxsize)
  {
    if (ExtList(LL) == 0) { printf("护展顺序表失败。\n"); return 0; }
  }

  // 判断插入位置是否合法
  if ( (ii < 1) || (ii > LL->length+1) )
  {
    printf("插入位置（%d）不合法，应该在（%d-%d）之间。\n",ii,1,LL->length+1); return 0;
  }

  // 注意，元素后移只能用循环，不能用以下注释掉的方法，当元素是结构体时，以下方法不稳定。
  // if ( ii < LL->length+1)
  //   memcpy(LL->data+ii,LL->data+ii-1,(LL->length-ii+1)*sizeof(ElemType));

  // 把ii和ii之后的元素后移。
  int k;
  for (k=LL->length;k>=ii;k--)
  {
    memcpy(LL->data+k,LL->data+k-1,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。
  }

  memcpy(LL->data+ii-1,ee,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。
  LL->length++;       // 表的长度加1。

  return 1;
}

// 在顺序表LL的头结点插入元素ee，返回值：0-失败；1-成功。
int  PushFront(PSeqList LL, ElemType *ee)
{
  return InsertList(LL,1,ee);
}

// 在顺序表LL的尾结点插入元素ee，返回值：0-失败；1-成功。
int PushBack(PSeqList LL, ElemType *ee)
{
  return InsertList(LL,LL->length+1,ee);
}

// 删除顺序表LL中的第ii个元素，返回值：0-位置ii不合法；1-成功。
int DeleteElem(PSeqList LL, unsigned int ii)
{
  if (LL == NULL) return 0;   // 检查空指针。

  // 判断删除位置ii是否合法
  if ( (ii < 1) || (ii > LL->length) )
  {
    printf("删除位置（%d）不合法，应该在（%d-%d）之间\n",ii,1,LL->length); return 0;
  }

  // 把ii之后的元素前移。
  int k;
  for (k=ii;k<=LL->length;k++)
  {
    memcpy(LL->data+k-1,LL->data+k,sizeof(ElemType));  // 采用memcpy是为了支持ee为结构体的情况。
  }

  LL->length--;       // 表的长度减1。

  return 1;
}

// 查找ee在顺序表LL中的位置，返回值：0-元素ee在表LL中不存在，>0元素ee在表LL中的位置。
int LocateElem(PSeqList LL, ElemType *ee)
{
  if ( (LL == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  int k;

  for (k = 0; k < LL->length; k++)
  {
    // 元素ee为结构体，这行代码与元素为整数时的方式不一样，比较超女结构体的编号。
    if ((LL->data+k)->no == ee->no) return k+1; // 在表中对应序号应为k+1。
  }
    
  return 0;
}

// 删除顺序表LL中头元素，返回值：0-位置ii不合法；1-成功。
int PopFront(PSeqList LL)
{
  return DeleteElem(LL, 1);
}

// 删除顺序表LL中尾元素，返回值：0-位置ii不合法；1-成功。
int PopBack(PSeqList LL)
{
  return DeleteElem(LL, LL->length);
}

// 判断顺序表是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqList LL)
{
  if (LL == NULL) return 0;   // 检查空指针。

  if (LL->length == 0) return 1;

  return 0;
}

// 打印顺序表中全部的元素。
void PrintList(PSeqList LL)
{
  if (LL == NULL) { printf("表不存在。\n"); return; }

  if (LL->length == 0) { printf("表为空。\n"); return; }

  int k;
  for (k = 0; k < LL->length; k++)
  {
    // 元素ee为结构体，这行代码与元素为整数时的方式不一样，这里输出超女结构体的编号。
    printf("%-3d", (LL->data+k)->no);  // 输出超女的编号。
  }

  printf("\n");
}

橙子@C
关注
专栏目录
程序设计 | 实体类中如何设计动态表格、列数据 [原创]
CTRA®王大大技术中心
09-13 299
1、前提 这里目前只对这一种需求做一个抛砖引玉，更复杂的场景大家可以从此思路出发 1.1 需求如下 如图可以看到前台需要展示这样的这个数据结构 特点： 每一组都是按照【名称】维度，查询他们各自下面的特性 除了【名称】，全部为动态查询出来的数据库 每一组的分类都没有共同的特点 1.2 分析 由于是动态的数据，这里就不能按照传统思路去将各个“列”设定死 这个结构就可以规划成如下： 这样看就比较直观了，想必大家此时都有一些想法了 1.3 设计实体类 那这个对象设计如下： public class test
静态和动态分配实现顺序表（结构体的创建）
MaybeFlipped的博客
11-25 839
静态分配线性表结构体的创建： #include<stdlib.h> #include<stdio.h> //顺序表静态分配 #define Maxsize 10 //表空间的最大长度 typedef struct{ ElemType data[maxsize]; //ElemType是一个数据元素的类型，可改为int型，String型等(根据需要修改) int length; //当前顺序表内数据的长度 }SqList;
数据结构：顺序表的静态和动态创建
weixin_51227472的博客
07-20 492
最近在看数据结构，今天刚看完顺序表，做个记录。 1）顺序表的静态初始化 #include <stdio.h> #include <stdlib.h> #define N 6 typedef struct{ int a[N];//N是常数，顺序表最多可存10个，固定了所以是静态分配 int length;//顺序表现在的长度 }list;//顺序表类型叫list，这个顺序表存的是整数（你还可以存别的的类型数据，只需要把int改掉就ok了） void mylist(list *l){
动态版顺序表的实现
qq_58724706的博客
10-30 446
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 目录 首先，我们先定义变量，创建结构体。 顺序表接口的创建 void SeqListInit(SL* ps) void SeqListDestroy(SL* ps) void SeqListCheckCapacity(SL* ps) void SeqListPushBack(SL* ps, SLDataType x) void SeqListPopBa...
redis有序集合性能 列表、集合、有序集合
一清二白
11-05 381
1.1 列表 　　列表(list)类型是用来存储多个字符串,元素从左到右组成一个有序的集合.列表中的每个字符串被称为元素(element),一个列表最多可以存储(2的32次方)-1个元素.在redis中,可以对列表两端插入(push)和弹出(pop),还可以获取指定范围的元素列表、获取指定所有下标的元素等. 列表类型有两个特点: ①列表中的元素是有序的,这就意味着可以通过索引下标获取某个元素或者某...
数据结构-动态顺序表
tzy134679的博客
11-05 788
#pragma once #include <stdio.h> #include<string.h> #include<stdlib.h> typedef int SQDataType; typedef struct SeqList { SQDataType* a; int size; //有效数据的个数 int capacity; //容量 }SL; void SeqListInit(SL* ps);//初始化动态顺序表 void SeqListPus.
数据结构c++代码（顺序表的代码，包括静态顺序表和动态顺序表）
07-13
顺序表是一种线性结构，它的所有元素在内存中连续存放，可以分为静态顺序表和动态顺序表。静态顺序表通常是在编译时就预分配好固定大小的数组，而动态顺序表则可以根据需要动态地调整其容量。 静态顺序表的优点在于...
数据结构之静态顺序表和动态顺序表
Sock的博客
12-02 1372
@Sock对静态顺序表和动态顺序表的总结 简单概括他们的异同点 相同点:内存空间连续, 数据顺序存储 不同点:它们所占内存空间的位置不同, 静态定义一个顺序表, 顺序表所占的内存空间开辟在内存的静态区, 即所谓的函数栈上, 随着函数调用的结束, 这块内存区域会被系统自动回收; 而动态生成一个顺序表, 顺序表所占的内存空间开辟在内存的动态区, 即所谓的堆内存上, 这块区域不会随着函数调用的结束被...
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
10-19
在IT领域，数据结构是计算机科学中的核心概念，它研究如何高效地组织和存储数据，以便于进行各种操作。在C语言中实现数据结构能够帮助我们深入理解底层工作原理，并为编写高性能的程序打下坚实基础。以下是关于标题...
数据结构静态顺序表.zip
02-03
在这个“数据结构静态顺序表.zip”压缩包中，包含的是作者用C语言实现的静态顺序表源代码。 首先，让我们深入理解静态顺序表的概念。静态顺序表是一种固定大小的数组，其长度在创建时就已经确定，且在表的整个生命...
实现动态表头_动态多层交叉表头报表的制作
weixin_39859715的博客
01-11 244
在数据信息系统中，常常会看到这样一类报表需求，它们的样式为交叉报表的变形（既纵向分组扩展又横向分组扩展，在交叉区域对统计项进行汇总），同时在纵向分组时，要求每个组跟随一个与分组相对应的横向表头。对比效果如下图所示：从上图可看到，报表纵向按照年进行分组扩展，同时每年又能生成一个横向分组表头，该表头按照地区横向扩展，并且根据年份的不同而不同。如上图所示：2014 年有 6 个地区，而 2015 年由于...
数据结构：静态or动态顺序表 代码实现
Xiaoxiaokezhan的博客
02-07 178
静态表 头文件 `#include<stdio.h>` 代码实现 `//建立一个静态顺序表 #define MixSize 10 typedef struct{` int data[MixSize]; int Length; }SqList;//静态分配 void InitList(SqList &L);//初始化 void PrintList(SqList &amp...
顺序表的相关操作（静态&动态）
The Laughing Uncle的博客
09-09 497
静态顺序表 定义 定义结构体 初始化顺序表 销毁顺序表 打印顺序表 插入元素 尾插 头插 任意位置插入元素 删除元素 尾删 头删 任意位置删除 删除遇见的第一个指定元素 删除所有的指定元素 查找指定元素 排序 冒泡排序 选择排序 测试函数 动态顺序表 定义结构体 初始化 销毁 插入 尾插 头插 任意位置插入元素 一般情...
【数据结构】顺序表(实现+详解+源码+通讯录项目(静态+动态+文件保存))
热门推荐
Edward_Asia的博客
10-18 2万+
概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组储存元素。 动态顺序表：使用动态开辟的数组储存。 ...
数据结构：顺序表
咩咩的博客
06-15 684
1 顺序表的定义 静态分配： #define MaxSize 100////线性表最大长度 //数组静态分配 typedef struct { ElemType data[MaxSize];//ElemType为数量类型，可根据实际替换成想要的数据类型，如int int length;//当前长度 }SqList; 动态分配： //数组动态分配 #define MaxSize 100////线性表最大长度 #define InitSize 100//线性表初始分配量 typedef struct {
详解顺序表
k2865155467的博客
10-06 161
顺序表是一种线性表的存储结构，它通过采用动态一维数组来实现。顺序表的定义包括三个基本要素：指针域elem（指向顺序表的基地址）、length（顺序表长度）和listsize（顺序表当前分配的空间大小）。顺序表的特点是：元素之间在内存中的存储地址是连续的，可以通过下标直接访问元素，插入和删除操作需要移动元素的位置。顺序表的运算包括但不限于以下几个方面：创建顺序表、插入元素、删除元素、查找元素、打印顺序表等。顺序表的实现主要涉及创建顺序表、插入元素和打印顺序表三个操作。
实现顺序表的基本运算的算法
最新发布
qq_52190538的博客
10-20 109
printf("(10)提取串s的第2个字符开始的10个字符而产生串s3\n");printf("(6)删除串s第2个字符开始的5个字符而产生串s2\n");printf("(3)串s的长度:%d\n",StrLength(s));printf("(4)在串s的第9个字符位置插入s1而产生串s2\n");printf("(8)将串s第2个字符开始的5个字符而产生串s2\n");printf("(12)将串s1和串s2连接起来而产生串s4\n");printf("(1)建立串s和串s1\n");
数据结构—顺序表的操作及实现
qq_52166656的博客
07-22 1757
数据结构—顺序表的操作及实现(C/C++) 文章目录数据结构—顺序表的操作及实现(C/C++)1.0初始化定义1.1顺序表的定义1.2顺序表的初始化(构造一个空的顺序表)1.3顺序表的创建1.4顺序表的取值1.5顺序表的查找1.6顺序表的插入1.7顺序表的删除1.8C完整代码如下：1.8C++完整代码如下：1.9运行截图：2.0参考书籍2.1总结 1.0初始化定义 #include<stdio.h> #include<malloc.h> #define MAXSIZE 100
王道考研数据结构代码解析：静态与动态顺序表实现
"王道计算机考研数据结构相关代码，包括基于静态分配和动态分配的顺序表实现" 在计算机科学中，数据结构是编程的基础，它涉及到如何高效地组织和存储数据，以便于进行各种操作。这里提到的代码是针对数据结构中的一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值