数据结构---顺序表c实现

最新推荐文章于 2022-11-01 16:26:41 发布
最新推荐文章于 2022-11-01 16:26:41 发布
阅读量473 收藏
点赞数
分类专栏： Data structure 文章标签： 数据结构 c struct list 扩展 null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiegenwendada/article/details/7435056
版权

#include <stdio.h>
#include <stdlib.h>
typedef int elemType;
struct List{
 elemType *list;
 int size;
 int maxsize;
};
void againMalloc(struct List *L);/*0.扩展函数*/
void initList(struct List *L, int ms);/*1.初始化线性表函数*/
void clearList(struct List *L);/*2.清除线性表函数*/
int sizeList(struct List *L);/*3.返回线性表长度函数*/
int emptyList(struct List *L);/*4.判定线性表是否为空函数*/
elemType getElem(struct List *L, int pos);/*5.返回线性表L中第pos个元素的值,若pos超出范围,则停止程序运行*/
void traverseList(struct List *L);/*6.遍历输出线性表L中每个元素*/
int findList(struct List *L, elemType x);/*7.查找线性表L中与x相等元素并返回其位置,否则返回-1*/
int updatePosList(struct List *L, int pos, elemType x);/*8.把线性表L中第pos个元素的值修改为x的值，若修改成功返回1，否则返回0*/
void inserFirstList(struct List *L, elemType x);/*9.向线性表L的表头插入元素x*/
void insertLastList(struct List *L, elemType x);/* 10.向线性表L的表尾插入元素x*/
int insertPosList(struct List *L, int pos, elemType x);/*11.向线性表L中第pos个元素位置插入元素x，若插入成功返回1，否则返回0*/
void insertOrderList(struct List *L,int pos, elemType x);/*12.向有序线性表L中插入元素x,　使得插入后仍然有序*/
elemType deleteFirstList(struct List *L);/*13.从线性表L中删除表头元素并返回它，若删除失败则停止程序运行*/
elemType deleteLastList(struct List *L);/*14.从线性表L中删除表尾元素并返回它，若删除失败则停止程序运行*/
elemType deletePosList(struct List *L, int pos);/*15.从线性表L中删除第pos个元素并返回它，若删除失败则停止程序运行*/
int deleteValueList(struct List *L, elemType x);/*16.从线性表L中删除值为x的第一个元素，若成功返回1，失败返回0*/
void sortAlgorithm(struct List *L);/*17.排序算法*/
void againMalloc(struct List *L){/*0.扩展函数*/
 elemType *p = realloc(L->list,2 * L->maxsize * sizeof(elemType));
 if(!p){
  printf("扩展空间分配失败!\n");
  exit(1);
 }
 L->list = p;
 L->maxsize = 2 * L->maxsize;
 return ;
}
void initList(struct List *L, int ms){/*1.初始化线性表函数*/
 int x=0,k=0,size;
 while(ms <= 0|| ms >32767 || (ms/ms)!=1 ){
  printf("线性表长度输入有误\n请输入正整数:");
  scanf("%d",&ms);
 }
 L->list = malloc(ms *sizeof(elemType));
 if(!L->list){
  printf("开拓空间分配失败!\n");
  exit(1);
 }
 L->maxsize = ms;
 printf("请输入小于%d的数据长度以便录入:",L->maxsize);
 scanf("%d",&size);
 while(size>L->maxsize||size<0){
  printf("输入数据长度有误,请重新输入1--%d的数据长度",L->maxsize);
 }
 L->size=size;
 printf("请输入%d个数据,空格间隔:",L->size);
 while(k != (L->size)){ 
  scanf("%d",&x);
  if(x>=(-32768)||x<=32767){
  }
  else{
   printf("输入x有误,请重新输入:");
   scanf("%d",&x);
   k--;
   continue;
  }
  L->list[k]=x;
  k++;
 }
 printf("线性表L输入完毕!");
 return ;
}
void clearList(struct List *L){/*2.清除线性表函数*/
 if(L->list != NULL){
     free(L->list);
  L->list = 0;
  L->size = 0;
  L->maxsize = 0;
 }
 else{
  exit(1);
    }
 return ;
}
int sizeList(struct List *L){/*3.返回线性表长度函数*/
 return L->size;
}
int emptyList(struct List *L){/*4.判定线性表是否为空函数*/
 if(L->size ==0){
  return 1;
 }
 else{
  return 0;
 }
}
elemType getElem(struct List *L, int pos){/*5.返回线性表L中第pos个元素的值,若pos超出范围,则停止程序运行*/
 while(pos>L->size||pos<1){
  printf("查询pos位置越界\n请重新输入>1%d<=的正整数",L->size);
  scanf("%d",&pos);
  return getElem(L, pos);
 }
 return L->list[pos-1];
}
void traverseList(struct List *L){/*6.遍历输出线性表L中每个元素*/
 int i;
 for(i=0;i<L->size;i++){
  printf("%d ",L->list[i]);
 }
 return ;
}
int findList(struct List *L, elemType x){/*7.查找线性表L中与x相等元素并返回其位置,否则返回提示语句*/
    int i=0,j=0,l;
 for(i=0;i<L->size;i++){
  if(L->list[i] == x){
  j++;
  l=i+1;
  }
 }
 if(j==0){
    printf("该线性表没有与x相等的数据");
 }
 return l;
}
int updatePosList(struct List *L, int pos, elemType x){/*8.把线性表L中第pos个元素的值修改为x的值，若修改成功返回1，否则返回0*/
 while(pos<1||pos>L->size){
  printf("修改位置越界请重新输入[1,%d]之间的正整数:",L->size);
  scanf("%d",pos);
  while(x<(-32768)||x>32767){
  printf("要求修改的x不是匹配的elemType类型或越界请重新输入-32768--32767 之间的整数:");
  scanf("%d",x);
  }
  updatePosList(L,pos,x);
 }
 while(L->list==NULL){
  int hs=0;
  printf("线性表为空没有可供修改的值,需要重新构造线性表L\n");
  printf("请输入新线性表的长度:");
  scanf("%d",hs);
  initList(L,hs);
  updatePosList(L,pos,x);
 }
  L->list[pos-1]=x;
  if(L->list[pos-1]==x){
  printf("修改成功返回1");
     return 1;
  }
  else{
  printf("修改不成功返回0");
  return 0;
 }
}
void inserFirstList(struct List *L, elemType x){/*9.向线性表L的表头插入元素x*/
 int i=1,j=0;
 while(L->list==NULL){
  int hs=0;
  printf("线性表为空没有可供修改的值,需要重新构造线性表L\n");
  printf("请输入新线性表的长度:");
  scanf("%d",&hs);
  initList(L,hs);
  while(x<(-32768)||x>32767){
      printf("要求修改的x不是匹配的elemType类型或越界请重新输入-32768--32767 之间的整数:");
     scanf("%d",x);
  }
  inserFirstList(L,x);
 }
 if(L->size+1>L->maxsize){
  struct List *h=0 ;
  printf("原线性表已满,执行重新构造线性表");
  h->list = malloc((L->maxsize+1) * sizeof(elemType));
  if(!h->list){
  printf("扩展空间分配失败!\n");
  exit(1);
  }
  h->list[0]=x;
  for(i = 1,j = 0;i <L->maxsize,j <(L->maxsize-1);i++,j++){
   h->list[i]=L->list[j];
        }
        h->maxsize = L->maxsize+1;
  h->size = L->maxsize+1;
        clearList(L);
  L->list = h->list;
  clearList(h);
 }
 else{
  printf("原线性表未满,表头插入成功!");
  for(i=1,j=0;i<L->size,j<(L->size-1);i++,j++){
    L->list[L->size-j]=L->list[L->size-i];
        }
  L->list[0]=x;
  L->size=L->size+1;
 }
}
void insertLastList(struct List *L, elemType x){/* 10.向线性表L的表尾插入元素x*/
 int i=0,j=0;
 while(L->list==NULL){
  int hs=0;
  printf("线性表为空没有可供修改的值,需要重新构造线性表L\n");
  printf("请输入新线性表的长度:");
  scanf("%d",&hs);
  initList(L,hs);
  while(x<(-32768)||x>32767){
      printf("要求修改的x不是匹配的elemType类型或越界请重新输入-32768--32767 之间的整数:");
     scanf("%d",x);
  }
  insertLastList(L,x);
 }
     if(L->size+1>L->maxsize){
  struct List *h =0;
  printf("原线性表已满,执行重新构造线性表");
  h->list = malloc((L->maxsize+1) * sizeof(elemType));
  if(!h->list){
  printf("扩展空间分配失败!\n");
  exit(1);
  }
  h->list[L->maxsize]=x;
  for(i = 0,j = 0;i <L->maxsize,j <L->maxsize;i++,j++){
   h->list[i]=L->list[j];
        }
        h->maxsize = L->maxsize+1;
  h->size = L->maxsize+1;
        clearList(L);
  L->list = h->list;
  clearList(h);
 }
 else{
  printf("原线性表未满,执行表尾插入成功!");
  L->list[L->size]=x;
  L->size=L->size+1;
 }
}
int insertPosList(struct List *L, int pos, elemType x){/*11.向线性表L中第pos个元素位置插入元素x，若插入成功返回1，否则返回0*/
 int i=1,j=0;
     while(L->list==NULL){
  int hs=0;
  printf("线性表为空没有可供修改的值,需要重新构造线性表L\n");
  printf("请输入新线性表的长度:");
  scanf("%d",&hs);
  initList(L,hs);
  while(x<(-32768)||x>32767){
      printf("要求修改的x不是匹配的elemType类型或越界请重新输入-32768--32767 之间的整数:");
     scanf("%d",&x);
  }
  while(pos<=1||pos>=L->size){
  printf("输入插入位置错误,请重新输入>1且<%d的正整数",L->size);
  scanf("%d",&pos);
  }
        insertPosList(L,pos,x);

  }
  
  if(L->size+1>L->maxsize){
  struct List *h =0;
  printf("原线性表已满,执行重新构造线性表");
  h->list = malloc((L->maxsize+1) * sizeof(elemType));
  if(!h->list){
  printf("扩展空间分配失败!\n");
  exit(1);
  }
  for(i = 1,j = 0;i <L->maxsize,(j <L->maxsize+1);i++,j++){
   if((L->size-i)== (pos - i)){
            h->list[L->size-i]=x;
   }
   else{
   h->list[L->size-j]=L->list[L->size-i];
            }
  }
        h->maxsize = L->maxsize+1;
  h->size = L->maxsize+1;
        clearList(L);
  L->list = h->list;
  clearList(h);
 }
 else{
  printf("原线性表未满,可以执行表中插入");
  for(i = L->size - 1; i >= pos - 1; i--){
   L->list[i + 1] = L->list[i];
  }
  L->list[pos - 1] = x;
  L->size=L->size+1;
  return 1;
  
 }
 return 0;
}
void insertOrderList(struct List *L, int pos,elemType x){/*12.向有序线性表L中插入元素x,　使得插入后仍然有序*/
  while(L->list==NULL){
  int hs=0;
  printf("线性表为空没有可供修改的值,需要重新构造线性表L\n");
  printf("请输入新线性表的长度:");
  scanf("%d",&hs);
  initList(L,hs);
  while(x<(-32768)||x>32767){
      printf("要求修改的x不是匹配的elemType类型或越界请重新输入-32768--32767 之间的整数:");
     scanf("%d",&x);
  }
  while(pos<1||pos>L->size){
  printf("输入插入位置错误,请重新输入>=1且<=%d的正整数",L->size);
  }
    }
        if(pos==1){
   inserFirstList(L,x);
   sortAlgorithm(L);
   traverseList(L);
  }
  else if(pos==L->size){
   insertLastList(L,x);
   sortAlgorithm(L);
   traverseList(L);
  }
  else{
   insertPosList(L,pos,x);
   sortAlgorithm(L);
   traverseList(L);
  }
 
  return ;
}
void sortAlgorithm(struct List *L){
 int j=0,k=1,i=0,l=1;
  printf("请选择1->升序或者2->降序:");
  scanf("%d",&i);
  while(!(i==1||i==2)){
   printf("选择错误,请重新选择:");
   scanf("%d",&i);
        }
  switch(i)
  {
  case 1:
   for(j=0;j<L->size;j++){
    while(k<L->size){
     if(L->list[j]>L->list[k])
     {
      i=L->list[j];
      L->list[j]=L->list[k];
      L->list[k]=i;
     }
     k++;
    }
    k=l++;
   }
   break;
       default:
      for(j=0;j<L->size;j++){
    while(k<L->size){
     if(L->list[j]<L->list[k])
     {
      i=L->list[j];
      L->list[j]=L->list[k];
      L->list[k]=i;
     }
     k++;
    }
    k=l++;
   }
   break;
  }
  return ;
}

elemType deleteFirstList(struct List *L){/*13.从线性表L中删除表头元素并返回它，若删除失败则停止程序运行*/
 int i=0;
 elemType k=0;
 k=L->list[i];
 for(i=0;i<L->size;i++){
  L->list[i]=L->list[i+1];
 }
 L->list[i]=0;
 L->size=L->size-1;
 L->maxsize=L->maxsize-1;
 return k;
}
elemType deleteLastList(struct List *L){/*14.从线性表L中删除表尾元素并返回它，若删除失败则停止程序运行*/
 elemType k=0;
 k=L->list[L->size-1];
 L->list[L->size-1]=0;
 L->size=L->size-1;
 L->maxsize=L->maxsize-1;
 return k;
}
elemType deletePosList(struct List *L, int pos){/*15.从线性表L中删除第pos个元素并返回它，若删除失败则停止程序运行*/
  int i=0;
     elemType k=0;
     while(L->list==NULL){
  int hs=0;
  printf("线性表为空没有可供修改的值,需要重新构造线性表L\n");
  printf("请输入新线性表的长度:");
  scanf("%d",&hs);
  initList(L,hs);
  while(pos<=1||pos>=L->size){
  printf("输入插入位置错误,请重新输入>1且<%d的正整数",L->size);
  scanf("%d",&pos);
  }
        deletePosList(L,pos);
  }
  k=L->list[pos-1];
  if(pos-i<L->size){
  L->list[pos-1-i]=L->list[pos-i];
  }
  L->list[L->size-1]=0;
  L->size=L->size-1;
  L->maxsize=L->maxsize-1;
        return k;
}
int deleteValueList(struct List *L, elemType x){/*16.从线性表L中删除值为x的第一个元素，若成功返回1，失败返回0*/
  while(L->list==NULL){
  int hs=0;
  printf("线性表为空没有可供修改的值,需要重新构造线性表L\n");
  printf("请输入新线性表的长度:");
  scanf("%d",&hs);
  initList(L,hs);
  while(x<(-32768)||x>32767){
      printf("要求修改的x不是匹配的elemType类型或越界请重新输入-32768--32767 之间的整数:");
     scanf("%d",x);
  }
  deleteValueList(L,x);
  }
     if(findList(L,x)==1){
   deleteFirstList(L);
  }
  else if(findList(L,x)==L->size){
   deleteLastList(L);
  }
  else{
   deletePosList(L,findList(L,x));
  }
  return 1;
}
   
void main()
{
 int i,ms,pos;
 elemType x;
 struct List L;
 while(1){
 printf("0->扩展线性表为2倍\n1->初始化线性表\n2->清除线性表\n3->返回线性表长度\n4->判定线性表是否为空\n5->返回线性表L中第pos个元素的值\n");
    printf("6->遍历输出线性表L中每个元素\n7->查找线性表L中与x相等元素并返回其位置\n8->把线性表L中第pos个元素的值修改为x的值\n");
 printf("9->向线性表L的表头插入元素x\n10->向线性表L的表尾插入元素x\n11->向线性表L中第pos个元素位置插入元素x\n");
 printf("12->向有序线性表L中插入元素x使得插入后仍然有序\n13->从线性表L中删除表头元素并返回它\n14->从线性表L中删除表尾元素并返回它\n");
 printf("15->从线性表L中删除第pos个元素并返回它\n16->从线性表L中删除值为x的第一个元素\n17->排序算法\n");
 printf("请选择操作:");
 scanf("%d",&i);
  while(i<0||i>17){
   printf("输入操作不存在,重新输入");
   scanf("%d",&i);
   continue;
  }
      switch(i){
    case 0:
     printf("\n");
     printf("0->扩展线性表为2倍");
     againMalloc(&L);
     break;
       case 1:
     printf("\n");
     printf("1->初始化线性表");
     printf("请输入构造线性表长度:");
     scanf("%d",&ms);
     initList(&L,ms);
     break;
       case 2:
     printf("\n");
     printf("2->清除线性表");
     clearList(&L);
     break;
       case 3:
     printf("\n");
     printf("3->返回线性表长度");
     printf("线性表长度为%d",sizeList(&L));
     getchar();
     getchar();
              break;
       case 4:
              printf("\n");
     printf("4->判定线性表是否为空:");
              if(!emptyList(&L)){
      printf("线性表非空!");
     }
     else{
      printf("线性表为空!");
     }
     getchar();
     getchar();
     break;
       case 5:
     printf("\n");
     printf("5->返回线性表L中第pos个元素的值\n");
     printf("请输入查询L线性表pos位置:");
     scanf("%d",&pos);
     printf("\n");
     printf("线性表第%d个值为%d",pos,getElem(&L,pos));
     getchar();
     getchar();
     break;
       case 6:
     printf("\n");
     printf("6->遍历输出线性表L中每个元素");
     traverseList(&L);
     getchar();
     getchar();
     break;
    case 7:
     printf("\n");
     printf("7->查找线性表L中与x相等元素并返回其位置\n");
     printf("请输入查询x的值:");
     scanf("%d",&x);
     printf("\n");
     printf("与x相等的表中位置为:%d",findList(&L,x));
     getchar();
     getchar(); 
     break;
    case 8:
     printf("\n");
     printf("8->把线性表L中第pos个元素的值修改为x的值\n");
     printf("请输入把线性表L位于pos值改为x:\n");
     printf("请输入pos:");
     scanf("%d",&pos);
     printf("\n");
     printf("请输入x:");
     scanf("%d",&x);
     updatePosList(&L,pos,x);
     break;
    case 9:
     printf("\n");
     printf("9->向线性表L的表头插入元素x\n");
     printf("请输入在表头插入的x值\n");
     scanf("%d",&x);
     inserFirstList(&L,x);
     getchar();
     getchar();
     break;
    case 10:
     printf("\n");
     printf("10->向线性表L的表尾插入元素x\n");
     printf("请输入在表尾插入的x值:");
     scanf("%d",&x);
     insertLastList(&L,x);
     getchar();
     getchar();
     break;
    case 11:
     printf("\n");
     printf("11->向线性表L中第pos个元素位置插入元素x\n");
     printf("请输入在表L中pos位置插入的x值\n");
     printf("请输入pos:");
     scanf("%d",&pos);
     printf("\n");
     printf("请输入x:");
     scanf("%d",&x);
     insertPosList(&L,pos,x);
     getchar();
     getchar();
     break;
    case 12:
     printf("\n");
     printf("12->向有序线性表L中插入元素x\n");
     printf("请输入在表L中pos位置插入的x值\n");
     printf("请输入pos:");
     scanf("%d",&pos);
     printf("\n");
     printf("请输入x:");
     scanf("%d",&x);
     insertOrderList(&L,pos,x);
     getchar();
     getchar();
     break;
    case 13:
     printf("\n");
     printf("13->从线性表L中删除表头元素并返回它\n");
     printf("被删除的表头元素为:%d",deleteFirstList(&L));
     getchar();
     getchar();
              break;
    case 14:
     printf("\n");
     printf("14->从线性表L中删除表尾元素并返回它");
              printf("被删除的表尾元素为:%d",deleteLastList(&L));
     getchar();
     getchar();
     break;
    case 15:
     printf("\n");
     printf("15->从线性表L中删除第pos个元素并返回它\n");
     printf("请输入在表L中删除的pos位置:");
     printf("请输入pos:");
     scanf("%d",&pos);
     deletePosList(&L,pos);
     printf("\n");
     printf("被删除的表中第%d个元素为:%d",pos,deletePosList(&L,pos));
     getchar();
     getchar();
     break;
    case 16:
     printf("\n");
     printf("16->从线性表L中删除值为x的第一个元素\n");
     printf("请输入在表L中删除的x值:");
     printf("请输入x:");
     scanf("%d",&x);
     deleteValueList(&L,x);
     getchar();
     getchar();
              break;
    case 17:
     printf("\n");
     printf("17->排序算法\n");
     sortAlgorithm(&L);
     printf("排序后遍历:");
              traverseList(&L);
     getchar();
     getchar();
     break;
   }
   system("cls"); 
 }

}

xiegenwendada
关注
专栏目录
【数据结构】顺序表-C语言版
局部变量和全局变量
01-09 1287
线性表是n个具有相同特性的数据元素的有限序列，是一种实际中广泛使用的数据结构，常见的线性表有顺序表、链表、栈、队列、字符串。 线性表在逻辑上是线性结构，即连续的一条直线，但在物理上不一定连续，线性表在物理上存储时，通常以数组和链式结构的形式存储。 顺序表及其特点 数组缺陷：定义数组时必须制定数组大小，但是如果指定的大小 不能满足使用空间需求时，就会有问题。 顺序表含义及特点：顺序表本质是数组，是用一段物理地址连续......
【数据结构】顺序表（c语言实现）（附源码）
最新发布
2301_80955819的博客
07-24 1188
顺序表的概念和结构，顺序表的分类，顺序表的功能实现
【数据结构 】顺序表
C/C++菜鸟养成记
04-15 174
顺序表是什么 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表 分为 静态顺序表 和 动态顺序表 静态顺序表 使用长度给定的数组存储数据，结构体如下： typedef struct SeqList{ int array[1024]; int size; } SeqList; 动态顺序表 动态开辟的数组来存储数据，其大...
【初阶数据结构】——顺序表详解（C描述）
m0_70980326的博客
11-01 1101
顺序表详解 及 增删查改各接口函数实现
数据结构（一）——顺序表（C语言实现）
热门推荐
flueky的专栏
09-30 5万+
顺序表的简单实现
数据结构-顺序表-C语言实现顺序表相关功能-数据结构学习
05-22
C语言实现的数据结构中的顺序表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习 对顺序表边界操作的判定 实现了以下功能： 创建顺序表 向顺序表中插入元素(尾插法，...
数据结构-C语言描述（顺序表、链表）
04-01
本次实验的主要目的是让学生通过C语言实现顺序表和链表的相关操作，加深对这两种基本数据结构的理解，并掌握其在实际编程中的应用技巧。 #### 实验目的 1. **顺序表的操作实现**： - `linklistcreat`：创建顺序表...
数据结构-基于C语言实现线性顺序表的增删改查+排序，合表操作.rar
08-11
本资料包提供了一个基于C语言实现线性顺序表的实例，包括增删改查以及排序和合表操作。 线性顺序表是一种特殊的数组，它的元素按线性顺序排列，可以通过下标访问任意位置的元素。在C语言中，我们通常使用一维数组来...
数据结构C语言-顺序表PPT课件.ppt
12-27
数据结构C语言顺序表知识点 根据提供的PPT课件，以下是相关的知识点： 1. 线性表的逻辑结构 * 线性表是由n（n≥0）个类型相同的数据元素组成的有限序列。 * 线性表的逻辑结构可以用以下形式表示：L=(a1, a2,...,...
数据结构实验报告1-顺序表实现简易的学生信息管理系统(C语言)
04-07
本实验通过C语言实现了基于顺序表的学生信息管理系统，涵盖了学生信息的基本操作，如添加、删除、查找等功能，对于理解数据结构的基础概念和实践操作具有很好的帮助作用。此外，本实验还提供了一个良好的平台来探索...
数据结构—顺序表基本操作（c语言代码）
軒轅劍的博客
04-21 2万+
/******************************************************************************** 创建一个静态的顺序表存放整数，大小为10，完成以下的操作 1.输入6个整数，打印出顺序表的内容，并显示表中剩余空间的个数 2.在顺序表的第三个位置处插入元素0，打印出表中的内容，并显示空间中剩余的个数 3.再试图插入表中第11个位置整数...
数据结构笔记之顺序表
kaka的博客
04-18 1857
顺序表1.定义:用一组地址连续的存储单元依次存储线性表的数据元素的表。 由上图可以看出元素地址满足以下关系：2.类型定义以图书数据举例，其类型定义如下：#define MAXSIZE 100 //最大长度 typedef struct { char no[20]; //图书ISBN char name[20]; //图书名字 float price;
数据结构顺序表的基本实现（c语言版）
lemon_tea_sour的博客
10-05 2498
**线性表（Linear List）**是由n（n≥0）个数据元素（结点）a[0]，a[1]，a[2]…，a[n-1]组成的有限序列。线性表分为顺序表、链表等。我们现在来讨论下顺序表结构的基本实现。 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。简单来说，我们将电脑存储空间想象成一个个网格的形状，每个格子都存储一个数据，那么使用顺序表存储数...
数据结构算法实现-顺序表实现
jiaye_mi的博客
03-08 3385
C++实现数据结构顺序表代码，仅用于学习。
数据结构---顺序表的实现（C语言版）
little_spice的博客
10-22 5616
这里我们的目的是要简单地实现一下顺序表:初始化顺序表，插入5个数并输出，查找 2和 6是否在顺序表中，取出第3个数，最后删除第3个数 操作流程为： 1.首先开头预处理一下 #include&lt;bits/stdc++.h&gt; #define maxn 100 typedef int Status; using namespace std; typedef struct{ int *...
数据结构——C语言实现顺序表
我爱吃香锅的博客
09-11 3336
数据结构——C语言实现顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构。一般情况下顺序表是以数组为基础，结构体为框架来实现的。数组存储。在数组上完成数据的增删查改，而结构体中包含了存储数据的数组、所存储数据的实际长度以及顺序表的容量。 顺序表一般可分为： 1.静态顺序表：使用定长数组存储 #define N 100 typedef int SLDataType; typede...
数据结构——顺序表接口实现(C语言)
12-04 2226
C语言实现顺序表的增删查改一、概念及结构二、接口实现2.1 顺序表的两种存储方式与结构图2.1.1 顺序表的静态存储2.1.3 顺序表的动态存储2.2 顺序表初始化2.3 顺序表增容2.4 顺序表打印2.5 顺序表尾插2.6 顺序表尾删2.7 顺序表头插2.8 顺序表头删2.9 顺序表查找2.10 顺序表在任意位置插入2.11 顺序表删除任意位置的值2.12 顺序表销毁3. 工程化实现3.1 SeqList.h3.2 SeqList.c3.3 test.c 一、概念及结构 顺序表是一段物理地址连续的存储单元
数据结构（C语言版）顺序表
搬砖者也
05-28 2980
线性表及其顺序存储2.1线性表线性表是一个线性结构它是一个n&gt;=0各结点的有限序列，对于其中的结点，有且仅有一个开始结点，它没有前驱但有一个后继结点；有且仅有一个终端结点，它没有后继只有前驱；其他结点有且仅有一个 前驱和一个后继结点。线性表在计算机中的存储基本上是采用顺序存储和链式存储两种方式。2.2顺序表线性表采用顺序存储的方式就是顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址...
数据结构C语言实现-搜索顺序表算法详解
“算法的实现-C语言数据结构课件【比较清晰】” 这篇课件主要讲述了在数据结构领域中，如何使用C语言实现算法，特别是顺序查找（Search_Seq）算法的优化技巧。数据结构是计算机科学中的核心课程，它研究的是数据的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值