备案控制台
开发者社区 人工智能 文章 正文

实现顺序表——实践报告

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

实验名称 ： 顺序表的基本操作

一、实验目的：

1、复习C语言程序设计中的知识。

2、掌握线性表的顺序存储结构的表示和实现方法。

3、掌握顺序表基本操作的算法实现。

二、实验内容：

1．建立顺序表。

2．在顺序表上实现插入、删除和查找等操作。

三、实验要求：

1. 编写实现顺序表的基本算法（初始化、查找、插入、删除等）的函数，并在此基础上设计一个主程序完成如下功能：


⑴初始化一个顺序表L，数据元素类型可任选；


⑵建立顺序表L，要求数据元素至少10个；


⑶输出顺序表L的长度；


⑷按位置查找：输出顺序表L的第i个元素，如第3个元素；


⑸按内容查找：输出给定元素的位置；


⑹在第i个元素前插入给定元素；


⑺删除顺序表L的第i个元素；


⑻遍历顺序表，将表中的元素按序输出。


⑼编写菜单，以便用户可以选择相应的操作。


2. 利用顺序表的基本操作，求两个集合A和B的交集、并集和差集。

四.实验步骤（给出每个函数的算法描述）：

下面是使用 C 语言实现顺序表的一般步骤：


1.定义结构体：首先，你需要定义一个结构体来表示顺序表。该结构体至少应包含两个成员：一个数组来存储数据元素，以及一个整型变量来记录当前元素的数量。

#define MAX_SIZE 100
typedef struct {
    int data[MAX_SIZE];
    int length;
} SeqList;

2.初始化顺序表：创建一个函数来初始化顺序表。这将包括将顺序表的 length 成员设置为 0。

void init(SeqList *list) {
    list->length = 0;
}

3.插入元素：创建一个函数用于在顺序表中插入元素。这将包括将新元素添加到数组中，并增加 length 变量的值。

int insert(SeqList *list, int index, int element) {
    if (index < 0 || index > list->length || list->length == MAX_SIZE) {
        return 0;  // 插入失败
    }
    // 将 index 位置及其后面的元素后移一位
    for (int i = list->length - 1; i >= index; i--) {
        list->data[i + 1] = list->data[i];
    }
    // 在 index 位置插入新元素
    list->data[index] = element;
    list->length++;
    return 1;  // 插入成功
}

4.删除元素：创建一个函数用于从顺序表中删除元素。这将涉及将指定位置的元素删除，并将后面的元素向前移动。

int remove(SeqList *list, int index) {
    if (index < 0 || index >= list->length) {
        return 0;  // 删除失败
    }
    // 将 index 位置后面的元素前移一位
    for (int i = index + 1; i < list->length; i++) {
        list->data[i - 1] = list->data[i];
    }
    list->length--;
    return 1;  // 删除成功
}

5.查找元素：创建一个函数用于在顺序表中查找指定元素。这将涉及遍历顺序表的元素，并与目标元素进行比较。

int search(SeqList *list, int element) {
    for (int i = 0; i < list->length; i++) {
        if (list->data[i] == element) {
            return i;  // 返回元素位置
        }
    }
    return -1;  // 找不到元素
}

6.打印顺序表：创建一个函数来打印顺序表的所有元素。

void print(SeqList *list) {
    for (int i = 0; i < list->length; i++) {
        printf("%d ", list->data[i]);
    }
    printf("\n");
}

当完善顺序表的实验步骤时，你可以考虑添加以下功能：


1.获取指定位置的元素：创建一个函数，用于获取指定位置的元素值。

int getElement(SeqList *list, int index) {
    if (index < 0 || index >= list->length) {
        return -1;  // 获取失败，返回一个特定的错误值
    }
    return list->data[index];
}

2.更新指定位置的元素：创建一个函数，用于更新指定位置的元素值。

int updateElement(SeqList *list, int index, int newElement) {
    if (index < 0 || index >= list->length) {
        return 0;  // 更新失败
    }
    list->data[index] = newElement;
    return 1;  // 更新成功
}

3.清空顺序表：创建一个函数，用于清空顺序表中的所有元素。

void clear(SeqList *list) {
    list->length = 0;
}

这些是一些常见的功能，可以帮助完善顺序表的实验步骤。在实际应用中，你还可以根据需要扩展其他功能，例如顺序表的动态扩容、按值查找等。确保在修改完善代码后，进行编译和测试，以确保顺序表的正确性和稳定性。

五.实验结果：

初始化成功

b38521b402f642a99123e41b3ebe146a.png

销毁顺序表      

455bbe63c31041e29a8e9a6d297822a0.png

  1. 头部插入

5a717995701449a8918217d41acdf37f.png

d8827dd309cd417cb3713e3a2a88468e.png

  1. 尾部插入  

63c4c67f0d2541d0914c833da41e47e1.png

4c88962977c1463d94fdd128df7c657e.png

  1. 头部删除

3a3b856b412946ebb009d4397d60cc5a.png

  1. 尾部删除

da8974abf7af4d35a90dbe269c6f1b62.png

4a0f7110ff044c05b97aec7ac4fb8f86.png

查找想要pos位置的元素下标

97075f280d2d4dc587f2dd80b226ec4f.png

六.源代码

Seqlist.h文件
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
typedef int SLDateType;
typedef struct SeqList
{
  SLDateType* a;
  int size;
  int capacity;
}SL;
// 对数据的管理:增删查改 
//初始化
void SeqListInit(SL* ps);
//销毁
void SeqListDestroy(SL* ps);
//打印
void SeqListPrint(SL* ps);
//尾插
void SeqListPushBack(SL* ps, SLDateType x);
//头插
void SeqListPushFront(SL* ps, SLDateType x);
//头删
void SeqListPopFront(SL* ps);
// 尾删
void SeqListPopBack(SL* ps);
//检测空间是否需要扩容
void SLCheckCapacity(SL* ps);
//
 顺序表查找
int SeqListFind(SL* ps, SLDateType x);
 顺序表在pos位置插入x
void SeqListInsert(SL* ps, int pos, SLDateType x);
 顺序表删除pos位置的值
void SeqListErase(SL* ps, int pos);
Seqlist.c文件
#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"
void SeqListInit(SL* ps)
{
  ps->a = (SLDateType*)malloc(sizeof(SLDateType) * 4);
  if (ps->a == NULL)
  {
    perror("malloc");
    exit(-1);
  }
  ps->size = 0;
  ps->capacity = 4;
}
void SeqListDestroy(SL* ps)
{
  free(ps->a);
  ps->a = NULL;
  ps->size = 0;
  ps->capacity = 0;
}
void SeqListPrint(SL* ps)
{
  for (int i = 0; i < ps->size; i++)
  {
    printf("%d ", ps->a[i]);
  }
  printf("\n");
}
void SLCheckCapacity(SL* ps)
{
  if (ps->size == ps->capacity)
  {
    SLDateType* p = (SLDateType*)realloc(ps->a, sizeof(ps->a) * 2);
    if (*p == NULL)
    {
      perror(realloc);
      exit(-1);
    }
    ps->capacity *= 2;
    ps->a = p;
  }
}
void SeqListPushBack(SL* ps, SLDateType x)
{
  SLCheckCapacity(ps);
  ps->a[ps->size] = x;
  ps->size++;
}
void SeqListPopBack(SL* ps)
{
  assert(ps->size > 0);
  /*if (ps->sz == 0)
  {
    return;
  }*/
  ps->size--;
}
void SeqListPushFront(SL* ps, SLDateType x)
{
  SLCheckCapacity(ps);
  for (int i = ps->size; i > 0; i--)
  {
    ps->a[i] = ps->a[i - 1];
  }
  ps->a[0] = x;
  ps->size++;
}
void SeqListPopFront(SL* ps)
{
  assert(ps->size > 0);
  for (int i = 0; i < ps->size - 1; i++)
  {
    ps->a[i] = ps->a[i + 1];
  }
  ps->size--;
}
void SeqListInsert(SL* ps, int pos, SLDateType x)
{
  assert(pos >= 0 && pos <= ps->size);
  SLCheckCapacity(ps);
  int end = ps->size - 1;
  while (end >= pos)
  {
    ps->a[end + 1] = ps->a[end];
    --end;
  }
  ps->a[pos] = x;
  ps->size++;
}
void SeqListErase(SL* ps, int pos)
{
  assert(ps->size > 0);
  for (int i = pos - 1; i < ps->size - 1; i++)
  {
    ps->a[i] = ps->a[i + 1];
  }
  ps->size--;
}
int SeqListFind(SL* ps, SLDateType x)
{
  assert(ps->size > 0);
  for (int i = 0; i < ps->size; i++)
  {
    if (ps->a[i] == x)
      return i;
  }
  return -1;
}
Test.c文件
#define _CRT_SECURE_NO_WARNINGS 1
#include"Seqlist.h"
void menu()
{
  printf("******************************************************\n");
  printf("*******      线 性 表                           ******\n");
  printf("*******  1.初始化顺序表                         ******\n");
  printf("*******  2. 销毁顺序表                          ******\n");
  printf("*******  3.   头部插入                          ******\n");
  printf("*******  4.   尾部插入                          ******\n");
  printf("*******  5.   头部删除                          ******\n");
  printf("*******  6.   尾部删除                          ******\n");
  printf("*******  7. 在pos位置插入给定元素               ******\n");
  printf("*******  8. 删除pos位置的元素                    *****\n");
  printf("*******  9. 遍历顺序表，将表中的元素按序输出    ******\n");
  printf("*******  10. 查找想要pos位置的元素下标           *****\n");
  printf("*******  0.        退出程序              ***********\n\n");
  printf("----------------------------------------------------\n\n");
}
int main()
{
  SL sl;
  int choose = 0;
  do
  {
    menu();
    printf("请选择需要的功能：");
    scanf("%d", &choose);
    if (!(choose >= 0 && choose <= 10))
    {
      printf("非法输入，重新输入(范围0~10)\n");
      continue;
    }
    switch (choose)
    {
    case 1:
    {
      SeqListInit(&sl);
      printf("初始化成功\n");
      break;
    }
    case 2:
    {
      SeqListDestroy(&sl);
      printf("销毁成功\n");
      break;
    }
    case 3:
    {
      int num = 0;
      printf("输入存放值：");
      scanf("%d", &num);
      SeqListPushFront(&sl, num);
      break;
    }
    case 4:
    {
      int num = 0;
      printf("输入存放值：");
      scanf("%d", &num);
      SeqListPushBack(&sl, num);
      break;
    }
    case 5:
    {
      SeqListPopFront(&sl);
      break;
    }
    case 6:
    {
      SeqListPopBack(&sl);
      break;
    }
    case 7:
    {
      int num = 0;
      int pos = 0;
      printf("输入存放值：");
      scanf("%d", &num);
      printf("\n输入想要放置的pos位：");
      scanf("%d", &pos);
      SeqListInsert(&sl, pos, num);
      break;
    }
    case 8:
    {
      int pos = 0;
      printf("\n输入想要删除的pos位：");
      scanf("%d", &pos);
      SeqListErase(&sl, pos);
      break;
    }
    case 9:
    {
      SeqListPrint(&sl);
      break;
    }
    case 10:
    {
      int num = 0;
      printf("输入寻找pos位的元素：");
      scanf("%d", &num);
      printf("%d\n",SeqListFind(&sl, num));
      break;
    }
    case 0: printf("结束程序\n");
    }
  } while (choose);
  return 0;
}

以上代码需要不能直接应用，需要在三个文件中使用，在借鉴使用同时，如果有不明白的地方可以私信博主，博主在线解答。

文章标签：
算法
C语言
存储
W...Y
目录
相关文章
笨笨胡小巴
|
4月前
【编织时空二：探究顺序表与链表的数据之旅】（下）
【编织时空二：探究顺序表与链表的数据之旅】
笨笨胡小巴
22 0
笨笨胡小巴
|
4月前
|
存储 索引
【编织时空二：探究顺序表与链表的数据之旅】（上）
【编织时空二：探究顺序表与链表的数据之旅】
笨笨胡小巴
29 0
笨笨胡小巴
|
4月前
|
存储 缓存
【编织时空四：探究顺序表与链表的数据之旅】（上）
【编织时空四：探究顺序表与链表的数据之旅】
笨笨胡小巴
45 0
【编织时空四：探究顺序表与链表的数据之旅】（上）
笨笨胡小巴
|
4月前
【编织时空三：探究顺序表与链表的数据之旅】（下）
【编织时空三：探究顺序表与链表的数据之旅】
笨笨胡小巴
34 0
笨笨胡小巴
|
4月前
|
算法
【编织时空三：探究顺序表与链表的数据之旅】（上）
【编织时空三：探究顺序表与链表的数据之旅】
笨笨胡小巴
35 0
笨笨胡小巴
|
4月前
|
存储 C语言 索引
【编织时空一：探究顺序表与链表的数据之旅】（上）
【编织时空一：探究顺序表与链表的数据之旅】
笨笨胡小巴
26 0
笨笨胡小巴
|
4月前
【编织时空一：探究顺序表与链表的数据之旅】（下）
【编织时空一：探究顺序表与链表的数据之旅】
笨笨胡小巴
26 0
笨笨胡小巴
|
4月前
|
存储 缓存 算法
【编织时空四：探究顺序表与链表的数据之旅】（下）
【编织时空四：探究顺序表与链表的数据之旅】
笨笨胡小巴
33 0
命运之光
|
数据可视化 C语言 C++
数据结构实验报告—顺序表的基本操作—学生管理系统
数据结构实验报告—顺序表的基本操作—学生管理系统
命运之光
237 0
命运之光
|
存储 算法
数据结构实验报告—栈和队列
数据结构实验报告—栈和队列
命运之光
175 0