备案控制台
开发者社区 云计算 文章 正文

【数据结构】----顺序表项目-通讯录

2024-05-28 9
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【数据结构】----顺序表项目-通讯录

顺序表项目-通讯录

顺序表的底层是数组—决定了其作为可以存储不单一数据的结构体的特性—从简单的顺序表变成通讯录

通讯录中不同的数据构成了一个结构体，例如包含联系人的数据：姓名，性别，电话，家庭住址，年龄…

诸如此类。

而我们针对这些通讯录中的数据进行一系列的操作，例如增删查改。

然而这些操作实际上已经在顺序表中实现好，我们只需要直接更改函数的名称并且直接调用即可，或者是直接调用已有的函数放在通讯录的操作函数中直接实现。

顺序表和通讯录的相似之处

顺序表的操作

增加

删除

查找

修改

…

通讯录的操作

增加联系人数据

删除联系人数据

查找联系人数据

修改联系人数据

…

接下来我们开始进行通讯录项目的理论解析以及代码编写。

项目大纲

每个项目都需要一个框架来支撑它的逻辑结构，我们可以使用来大致阐述项目所需要实现的功能，各个部分的分工等等。如下：

项目的编程实现

下面针对导图的思维来进行具体实现。

具体实现

执行界面 Contest.c

菜单的设计

菜单设计使用一个函数来实现即可。

//通讯录菜单
void menu() {
  printf("*****************通讯录***************\n");
  printf("*******1.添加联系人  2.删除联系人*****\n");
  printf("*******3.修改联系人  4.查找联系人*****\n");
  printf("*******5.查看通讯录  0.  退 出  ******\n");
  printf("**************************************\n");
}

基于用户的步骤

该部分既是主函数所对应的部分，如下：

int main()
{
  int op = -1;
  //创建通讯录结构对象
  Contact con;
  ContactInit(&con);
  do {
    menu();
    printf("请选择您的操作:\n");
    scanf("%d", &op);
    switch (op)
    {
    case 1:
      //添加联系人
      ContactAdd(&con);
      break;
    case 2:
      //删除联系人
      ContactDel(&con);
      break;
    case 3:
      //修改联系人
      ContactModify(&con);
      break;
    case 4:
      //查找联系人
      ContactFind(&con);
      break;
    case 5:
      //查看通讯录
      ContactShow(&con);
      break;
    case 0:
      //退出通讯录
      printf("通讯录退出中...\n");
      break;
    default:
      break;
    }
    
  } while (op != 0);
  //销毁通讯录
  //ContactDesTroy(&con);
  //return 0;
}

其中所涉及的函数在后续会进行编写。

通讯录声明 Contest.h

首先我们对所需的数据进行一个长度限制，保证数据的合理性

#define NAME_MAX 100
//#define AGE_MAX
#define GENDER_MAX 10
#define TEL_MAX 12
#define ADDR_MAX 100

基于数据类型，我们进行一个定义

//通讯录数据类型
typedef struct PersonInfo
{
  char name[NAME_MAX];
  int age;
  char gender[GENDER_MAX];
  char tel[TEL_MAX];
  char addr[ADDR_MAX];
}Info;

最后就是通讯里的操作声明

//通讯里提供的操作
//通讯录的初始化和销毁
void ContactInit(Contact* pcon);//实际初始化的还是顺序表
void ContactDesTroy(Contact* pcon);
//增加、删除、修改、查找、查看通讯录
void ContactAdd(Contact* pcon);
void ContactDel(Contact* pcon);
void ContactModify(Contact* pcon);
void ContactFind(Contact* pcon);
void ContactShow(Contact* pcon);

通讯录操作 Contact.c

初始化
void ContactInit(Contact* pcon) {
  SLInit(pcon);
}
销毁
void ContactDesTroy(Contact* pcon) {
  SLDestroy(pcon);
}
增加联系人数据
void ContactAdd(Contact* pcon) {
  //创建联系人结构体变量
  Info info;
  printf("请输入联系人姓名：\n");
  scanf("%s", info.name);
  printf("请输入联系人年龄：\n");
  scanf("%d", &info.age);
  printf("请输入联系人性别：\n");
  scanf("%s", info.gender);
  printf("请输入联系人电话：\n");
  scanf("%s", info.tel);
  printf("请输入联系人住址：\n");
  scanf("%s", info.addr);
  //保存数据到通讯录（顺序表）
  SLPushBack(pcon, info);
}
查找联系人数据

1.基于其他函数的查找

int FindByName(Contact* pcon, char name[]) {
  for (int i = 0; i < pcon->size; i++)
  {
    if (strcmp(pcon->arr[i].name, name) == 0) {
      //找到了
      return i;
    }
  }
  return -1;
}

2.独立的查找

void ContactFind(Contact* pcon) {
  char name[NAME_MAX];
  printf("请输入要查找的用户姓名：\n");
  scanf("%s", name);
  int findIndex = FindByName(pcon, name);
  if (findIndex < 0) {
    printf("该联系人不存在！\n");
    return;
  }
  //找到了，打印一下查找的联系人信息
  printf("%s %s %s %s %s\n", "姓名", "性别", "年龄", "电话", "住址");
  printf("%s %s %d %s %s\n",
    pcon->arr[findIndex].name,
    pcon->arr[findIndex].gender,
    pcon->arr[findIndex].age,
    pcon->arr[findIndex].tel,
    pcon->arr[findIndex].addr
  );
}
//注：此处的查找使用最简单的查找方式，而在实际过程中我们完全可以使用例如二分法来降低时间复杂度从而提高效率。
//本文章仅介绍关于通讯录的基本操作及代码，可以自行完善。
删除联系人数据
void ContactDel(Contact* pcon) {
  //删除之前一定要先查找
  //找到了，可以删除
  //找不到,不能执行删除
  printf("请输入要删除的联系人姓名:\n");
  char name[NAME_MAX];
  scanf("%s", name);
  int findIndex = FindByName(pcon, name);
  if (findIndex < 0) {
    printf("要删除的联系人不存在！\n");
    return;
  }
  //执行删除操作
  SLErase(pcon, findIndex);
  printf("联系人删除成功！\n");
}
修改联系人数据
void ContactModify(Contact* pcon) {
  //修改之前要先查找
  //找到了，执行修改操作
  //没有找到，不能执行修改操作
  char name[NAME_MAX];
  printf("请输入要修改的联系人姓名:\n");
  scanf("%s", name);
  int findIndex = FindByName(pcon, name);
  if (findIndex < 0) {
    printf("要修改的联系人不存在！\n");
    return;
  }
  //找到了，执行修改操作
  //int arr[10]   int arr[findIndex] = 100
  printf("请输入姓名：\n");
  scanf("%s", pcon->arr[findIndex].name);
  printf("请输入年龄：\n");
  scanf("%d", &pcon->arr[findIndex].age);
  printf("请输入性别：\n");
  scanf("%s", pcon->arr[findIndex].gender);
  printf("请输入电话：\n");
  scanf("%s", pcon->arr[findIndex].tel);
  printf("请输入地址：\n");
  scanf("%s", pcon->arr[findIndex].addr);
  printf("联系人修改成功！\n");
}
查看通讯录
void ContactShow(Contact* pcon) {
  printf("%s %s %s %s %s\n", "姓名", "性别", "年龄", "电话", "住址");//遍历整个通讯录从而查看所有的数据
  for (int i = 0; i < pcon->size; i++)
  {
    printf("%s %s %d %s %s\n",
      pcon->arr[i].name,
      pcon->arr[i].gender,
      pcon->arr[i].age,
      pcon->arr[i].tel,
      pcon->arr[i].addr
      );
  }
}

以上的操作都基于顺序表的对应实现。

当然你也可以基于此发散更多有关的操作，例如对联系人重命名，拉入黑名单（不同于删除）等等，在此只进行基本操作的介绍。

顺序表操作 SeqList.c

#include"SeqList.h"
//初始化和销毁
void SLInit(SL* ps) {
  ps->arr = NULL; //不是int 而是Info类型 
  ps->size = ps->capacity = 0;
}
void SLCheckCapacity(SL* ps) {
  if (ps->size == ps->capacity) {
    int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
    SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));
    if (tmp == NULL) {
      perror("realloc fail!");
      exit(1);
    }
    //扩容成功
    ps->arr = tmp;
    ps->capacity = newCapacity;
  }
}
//顺序表的头部/尾部插入
void SLPushBack(SL* ps, SLDataType x) {
  //断言--粗暴的解决方式
  //assert(ps != NULL);
  assert(ps);
  //if判断--温柔的解决方式
  //if (ps == NULL) {
  //  return;
  //}
  //空间不够，扩容
  SLCheckCapacity(ps);
  //空间足够，直接插入
  ps->arr[ps->size++] = x;
  //ps->size++;
}
void SLPushFront(SL* ps, SLDataType x) {
  assert(ps);
  //判断是否扩容
  SLCheckCapacity(ps);
  //旧数据往后挪动一位
  for (int i = ps->size; i > 0; i--) //i = 1
  {
    ps->arr[i] = ps->arr[i - 1]; //ps->arr[1] = ps->arr[0]
  }
  ps->arr[0] = x;
  ps->size++;
}
//顺序表的头部/尾部删除
void SLPopBack(SL* ps) {
  assert(ps);
  assert(ps->size);
  //顺序表不为空
  //ps->arr[ps->size - 1] = -1;
  ps->size--;
}
void SLPopFront(SL* ps) {
  assert(ps);
  assert(ps->size);
  //不为空执行挪动操作
  for (int i = 0; i < ps->size-1 ;i++)
  {
    ps->arr[i] = ps->arr[i + 1];
  }
  ps->size--;
}
//指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x) {
  assert(ps);
  assert(pos >= 0 && pos <= ps->size);
  
  SLCheckCapacity(ps);
  //pos及之后的数据往后挪动一位，pos空出来
  for (int i = ps->size; i > pos ;i--)
  {
    ps->arr[i] = ps->arr[i - 1]; //ps->arr[pos+1] = ps->arr[pos]
  }
  ps->arr[pos] = x;
  ps->size++;
}
//删除指定位置数据
void SLErase(SL* ps, int pos) {
  assert(ps);
  assert(pos >= 0 && pos < ps->size); 
  //pos以后的数据往前挪动一位
  for (int i = pos;i < ps->size-1;i++)
  {
    ps->arr[i] = ps->arr[i + 1];//ps->arr[i-2] = ps->arr[i-1];
  }
  ps->size--;
}
//在顺序表中查找X
//int SLFind(SL* ps, SLDataType x) {
//  //加上断言对代码的健壮性更好
//  assert(ps);
//  for (int i = 0; i < ps->size; i++)
//  {
//    if (ps->arr[i] == x) {
//      return i;
//    }
//  }
//  return -1;
//}
void SLDestroy(SL* ps) {
  assert(ps);
  if (ps->arr) {
    free(ps->arr);
  }
  ps->arr = NULL;
  ps->size = ps->capacity = 0;
}
void SLPrint(SL* ps) {
  for (int i = 0; i < ps->size; i++)
  {
    printf("%d ", ps->arr[i]);
  }
  printf("\n");
}

顺序表声明 SeqList.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"Contact.h"//包含了通讯录的头文件
//静态顺序表
//#define N 100
//struct SeqList
//{
//  SLDataType a[N];
//  int size;
//};
//动态顺序表
//typedef int SLDataType;
typedef Info SLDataType;//注：此处存储的不再是顺序表有关的例如int的基本类型，而是基于通讯录的复合类型
typedef struct SeqList
{
  SLDataType* arr; //存储数据的底层结构
  int capacity;    //记录顺序表的空间大小
  int size;        //记录顺序表当前有效的数据个数
}SL;
//typedef struct SeqList SL;
//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps); //保持接口一致性
//顺序表的头部/尾部插入
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);
//顺序表的头部/尾部删除
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);
//指定位置之前插入数据
//删除指定位置数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
//int SLFind(SL* ps, SLDataType x);

请注意以上的代码中出现了对"Contact.h"的包含，而"Contact.c"中同时包含了"**SeqList.h****以及"Contact.h"，这就出现了头文件互相包含的嵌套问题。

解决办法：前置声明：在"Contact.h"中进行前置声明，以保证不会出现反复包含的错误。

//Contact.h
//使用顺序表的前置声明
struct SeqList;
typedef struct SeqList Contact;

所有代码

ConTest.

/#include"Contact.h"  //在SeqList.h文件中已经包了Contact.h
#include"SeqList.h"
//通讯录菜单
void menu() {
  printf("*****************通讯录***************\n");
  printf("*******1.添加联系人  2.删除联系人*****\n");//ctrl+d
  printf("*******3.修改联系人  4.查找联系人*****\n");//ctrl+d
  printf("*******5.查看通讯录  0.  退 出  ******\n");//ctrl+d
  printf("**************************************\n");
}
int main()
{
  int op = -1;
  //创建通讯录结构对象
  Contact con;
  ContactInit(&con);
  do {
    menu();
    printf("请选择您的操作:\n");
    scanf("%d", &op);
    switch (op)
    {
    case 1:
      //添加联系人
      ContactAdd(&con);
      break;
    case 2:
      //删除联系人
      ContactDel(&con);
      break;
    case 3:
      //修改联系人
      ContactModify(&con);
      break;
    case 4:
      //查找联系人
      ContactFind(&con);
      break;
    case 5:
      //查看通讯录
      ContactShow(&con);
      break;
    case 0:
      //退出通讯录
      printf("通讯录退出中...\n");
      break;
    default:
      break;
    }
    
  } while (op != 0);
  //销毁通讯录
  ContactDesTroy(&con);
  return 0;
}

Contact.c

#include"Contact.h"
#include"SeqList.h"
//通讯录的初始化和销毁
//SL* ps
void ContactInit(Contact* pcon) {
  SLInit(pcon);
}
void ContactDesTroy(Contact* pcon) {
  SLDestroy(pcon);
}
//增加、删除、修改、查找、查看通讯录
void ContactAdd(Contact* pcon) {
  //创建联系人结构体变量
  Info info;
  printf("请输入联系人姓名：\n");
  scanf("%s", info.name);
  printf("请输入联系人年龄：\n");
  scanf("%d", &info.age);
  printf("请输入联系人性别：\n");
  scanf("%s", info.gender);
  printf("请输入联系人电话：\n");
  scanf("%s", info.tel);
  printf("请输入联系人住址：\n");
  scanf("%s", info.addr);
  //保存数据到通讯录（顺序表）
  SLPushBack(pcon, info);
}
int FindByName(Contact* pcon, char name[]) {
  for (int i = 0; i < pcon->size; i++)
  {
    if (strcmp(pcon->arr[i].name, name) == 0) {
      //找到了
      return i;
    }
  }
  return -1;
}
void ContactDel(Contact* pcon) {
  //删除之前一定要先查找
  //找到了，可以删除
  //找不到,不能执行删除
  printf("请输入要删除的联系人姓名:\n");
  char name[NAME_MAX];
  scanf("%s", name);
  int findIndex = FindByName(pcon, name);
  if (findIndex < 0) {
    printf("要删除的联系人不存在！\n");
    return;
  }
  //执行删除操作
  SLErase(pcon, findIndex);
  printf("联系人删除成功！\n");
}
void ContactModify(Contact* pcon) {
  //修改之前要先查找
  //找到了，执行修改操作
  //没有找到，不能执行修改操作
  char name[NAME_MAX];
  printf("请输入要修改的联系人姓名:\n");
  scanf("%s", name);
  int findIndex = FindByName(pcon, name);
  if (findIndex < 0) {
    printf("要修改的联系人不存在！\n");
    return;
  }
  //找到了，执行修改操作
  //int arr[10]   int arr[findIndex] = 100
  printf("请输入姓名：\n");
  scanf("%s", pcon->arr[findIndex].name);
  printf("请输入年龄：\n");
  scanf("%d", &pcon->arr[findIndex].age);
  printf("请输入性别：\n");
  scanf("%s", pcon->arr[findIndex].gender);
  printf("请输入电话：\n");
  scanf("%s", pcon->arr[findIndex].tel);
  printf("请输入地址：\n");
  scanf("%s", pcon->arr[findIndex].addr);
  printf("联系人修改成功！\n");
}
void ContactShow(Contact* pcon) {
  //格式大家下去感兴趣去调整
  printf("%s %s %s %s %s\n", "姓名", "性别", "年龄", "电话", "住址");
  for (int i = 0; i < pcon->size; i++)
  {
    printf("%s %s %d %s %s\n",
      pcon->arr[i].name,
      pcon->arr[i].gender,
      pcon->arr[i].age,
      pcon->arr[i].tel,
      pcon->arr[i].addr
      );
  }
}
void ContactFind(Contact* pcon) {
  char name[NAME_MAX];
  printf("请输入要查找的用户姓名：\n");
  scanf("%s", name);
  int findIndex = FindByName(pcon, name);
  if (findIndex < 0) {
    printf("该联系人不存在！\n");
    return;
  }
  //找到了，打印一下查找的联系人信息
  printf("%s %s %s %s %s\n", "姓名", "性别", "年龄", "电话", "住址");
  printf("%s %s %d %s %s\n",
    pcon->arr[findIndex].name,
    pcon->arr[findIndex].gender,
    pcon->arr[findIndex].age,
    pcon->arr[findIndex].tel,
    pcon->arr[findIndex].addr
  );
}

Contact.h

#pragma once
//#include<stdio.h> //暂时加上
#define NAME_MAX 100
#define GENDER_MAX 10
#define TEL_MAX 12
#define ADDR_MAX 100
//通讯录数据类型
typedef struct PersonInfo
{
  char name[NAME_MAX];
  int age;
  char gender[GENDER_MAX];
  char tel[TEL_MAX];
  char addr[ADDR_MAX];
}Info;
//使用顺序表的前置声明
struct SeqList;
typedef struct SeqList Contact;
//通讯里提供的操作
//通讯录的初始化和销毁
void ContactInit(Contact* pcon);//实际初始化的还是顺序表
void ContactDesTroy(Contact* pcon);
//增加、删除、修改、查找、查看通讯录
void ContactAdd(Contact* pcon);
void ContactDel(Contact* pcon);
void ContactModify(Contact* pcon);
void ContactFind(Contact* pcon);
void ContactShow(Contact* pcon);

SeqList.c

#include"SeqList.h"
//初始化和销毁
void SLInit(SL* ps) {
  ps->arr = NULL; //不是int 而是Info类型 
  ps->size = ps->capacity = 0;
}
void SLCheckCapacity(SL* ps) {
  if (ps->size == ps->capacity) {
    int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
    SLDataType* tmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));
    if (tmp == NULL) {
      perror("realloc fail!");
      exit(1);
    }
    //扩容成功
    ps->arr = tmp;
    ps->capacity = newCapacity;
  }
}
//顺序表的头部/尾部插入
void SLPushBack(SL* ps, SLDataType x) {
  //断言--粗暴的解决方式
  //assert(ps != NULL);
  assert(ps);
  //if判断--温柔的解决方式
  //if (ps == NULL) {
  //  return;
  //}
  //空间不够，扩容
  SLCheckCapacity(ps);
  //空间足够，直接插入
  ps->arr[ps->size++] = x;
  //ps->size++;
}
void SLPushFront(SL* ps, SLDataType x) {
  assert(ps);
  //判断是否扩容
  SLCheckCapacity(ps);
  //旧数据往后挪动一位
  for (int i = ps->size; i > 0; i--) //i = 1
  {
    ps->arr[i] = ps->arr[i - 1]; //ps->arr[1] = ps->arr[0]
  }
  ps->arr[0] = x;
  ps->size++;
}
//顺序表的头部/尾部删除
void SLPopBack(SL* ps) {
  assert(ps);
  assert(ps->size);
  //顺序表不为空
  //ps->arr[ps->size - 1] = -1;
  ps->size--;
}
void SLPopFront(SL* ps) {
  assert(ps);
  assert(ps->size);
  //不为空执行挪动操作
  for (int i = 0; i < ps->size-1 ;i++)
  {
    ps->arr[i] = ps->arr[i + 1];
  }
  ps->size--;
}
//指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x) {
  assert(ps);
  assert(pos >= 0 && pos <= ps->size);
  
  SLCheckCapacity(ps);
  //pos及之后的数据往后挪动一位，pos空出来
  for (int i = ps->size; i > pos ;i--)
  {
    ps->arr[i] = ps->arr[i - 1]; //ps->arr[pos+1] = ps->arr[pos]
  }
  ps->arr[pos] = x;
  ps->size++;
}
//删除指定位置数据
void SLErase(SL* ps, int pos) {
  assert(ps);
  assert(pos >= 0 && pos < ps->size); 
  //pos以后的数据往前挪动一位
  for (int i = pos;i < ps->size-1;i++)
  {
    ps->arr[i] = ps->arr[i + 1];//ps->arr[i-2] = ps->arr[i-1];
  }
  ps->size--;
}
//在顺序表中查找X
//int SLFind(SL* ps, SLDataType x) {
//  //加上断言对代码的健壮性更好
//  assert(ps);
//  for (int i = 0; i < ps->size; i++)
//  {
//    if (ps->arr[i] == x) {
//      return i;
//    }
//  }
//  return -1;
//}
void SLDestroy(SL* ps) {
  assert(ps);
  if (ps->arr) {
    free(ps->arr);
  }
  ps->arr = NULL;
  ps->size = ps->capacity = 0;
}
void SLPrint(SL* ps) {
  for (int i = 0; i < ps->size; i++)
  {
    printf("%d ", ps->arr[i]);
  }
  printf("\n");
}

SeqList.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"Contact.h"
//静态顺序表
//#define N 100
//struct SeqList
//{
//  SLDataType a[N];
//  int size;
//};
//动态顺序表
//typedef int SLDataType;
typedef Info SLDataType;
typedef struct SeqList
{
  SLDataType* arr; //存储数据的底层结构
  int capacity;    //记录顺序表的空间大小
  int size;        //记录顺序表当前有效的数据个数
}SL;
//typedef struct SeqList SL;
//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps); //保持接口一致性
//顺序表的头部/尾部插入
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);
//顺序表的头部/尾部删除
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);
//指定位置之前插入数据
//删除指定位置数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
//int SLFind(SL* ps, SLDataType x);

i < ps->size; i++)

{

printf(“%d “, ps->arr[i]);

}

printf(”\n”);

}

### SeqList.h
```c
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"Contact.h"
//静态顺序表
//#define N 100
//struct SeqList
//{
//  SLDataType a[N];
//  int size;
//};
//动态顺序表
//typedef int SLDataType;
typedef Info SLDataType;
typedef struct SeqList
{
  SLDataType* arr; //存储数据的底层结构
  int capacity;    //记录顺序表的空间大小
  int size;        //记录顺序表当前有效的数据个数
}SL;
//typedef struct SeqList SL;
//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps); //保持接口一致性
//顺序表的头部/尾部插入
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);
//顺序表的头部/尾部删除
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);
//指定位置之前插入数据
//删除指定位置数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
//int SLFind(SL* ps, SLDataType x);
文章标签：
存储
关键词：
数据结构顺序表
数据结构顺序表通讯录
数据结构顺序表项目
数据结构通讯录
数据结构项目
Skrrapper
目录
相关文章
秋刀鱼不做梦
|
5天前
|
存储
数据结构—顺序表（如果想知道顺序表的全部基础知识点，那么只看这一篇就足够了！）
数据结构—顺序表（如果想知道顺序表的全部基础知识点，那么只看这一篇就足够了！）
秋刀鱼不做梦
18 1
爱喝兽奶的熊孩子
|
12天前
|
存储 机器学习/深度学习 算法
【数据结构与算法】：手搓顺序表（Python篇）
【数据结构与算法】：手搓顺序表（Python篇）
爱喝兽奶的熊孩子
14 1
爱喝兽奶的熊孩子
|
12天前
|
存储 算法 C++
【数据结构与算法】：带你手搓顺序表（C/C++篇）
【数据结构与算法】：带你手搓顺序表（C/C++篇）
爱喝兽奶的熊孩子
18 1
反季雪
|
1天前
|
存储 算法 C语言
【数据结构】详解顺序表
【数据结构】详解顺序表
反季雪
2 0
24k纯甄
|
2天前
|
存储 算法
【C/数据结构与算法】：顺序表的实现
【C/数据结构与算法】：顺序表的实现
24k纯甄
6 0
就学呗
|
15天前
数据结构初阶 顺序表的补充
数据结构初阶 顺序表的补充
就学呗
11 0
就学呗
|
15天前
|
存储
数据结构初阶 顺序表的讲解
数据结构初阶 顺序表的讲解
就学呗
10 0
lge101058
|
1天前
|
存储 测试技术
【数据结构】操作受限的线性表，栈的具体实现
【数据结构】操作受限的线性表，栈的具体实现
lge101058
12 5
倔强的石头_
|
1天前
|
算法 C语言
【数据结构与算法 经典例题】使用队列实现栈（图文详解）
【数据结构与算法 经典例题】使用队列实现栈（图文详解）
倔强的石头_
9 1
24k纯甄
|
2天前
|
算法
【C/数据结构和算法】：栈和队列
【C/数据结构和算法】：栈和队列
24k纯甄
9 1