c/c++ 数据结构 顺序表

1.概述

本段代码定义了一个顺序存储的线性表（简称顺序表）的基本操作。顺序表使用结构体SqList来存储数据，其中包含一个整型数组data用于存储元素，以及一个整型length表示当前顺序表的长度。代码提供了顺序表的初始化、销毁、判空、显示、获取元素、定位元素、创建顺序表、插入元素、删除元素以及获取顺序表长度的函数。

1.代码结构

1. 头文件包含

   • #include<stdio.h>：用于输入输出。
   • #include<malloc.h>：用于内存分配。在现代C++编程中，通常建议使用#include<stdlib.h>。

2. 常量定义

   • #define Maxsize 20：定义了顺序表能存储的最大元素数量。

3. 结构体定义

   • SqList：定义了顺序表的结构体，包含一个整型数组data和一个整型length。

     #include<stdio.h>
     #include<malloc.h>
     #define Maxsize 20
     //定义顺序表最大长度
     typedef struct
     {
         int data[Maxsize];
         int length;
     }SqList;
     //顺序表结构体，包括数组data和长度length

4. 函数列表

   • InitList：初始化顺序表，分配内存并设置长度为0。
   • DestroyList：销毁顺序表，释放内存。
   • ListEmpty：判断顺序表是否为空。
   • DispList：显示顺序表的所有元素。
   • GetElem：获取顺序表中指定位置的元素。
   • LocateElem：定位顺序表中指定元素的位置。
   • CreateSqList：根据数组创建顺序表。
   • ListLength：获取顺序表的长度。
   • ListInsert：在顺序表的指定位置插入元素。
   • ListDelete：从顺序表的指定位置删除元素。

5. 主函数

   • main：测试上述函数的功能。

2.代码分析

1. 函数InitList：通过指针的引用SqList*& L，函数内部可以改变传入的指针L的指向，实现顺序表的动态分配和初始化。

   void InitList(SqList*& L)
   {
       L = (SqList*)malloc(sizeof(SqList));
       //（变量名）= (指针)malloc(n*sizeof());
       (*L).length = 0;
       //L->length=0;
   }

2. 函数DestroyList：直接释放了传入指针L所指向的内存。

   void DestroyList(SqList*& L)
   {
       free(L);
   }
   //free()函数：
   //若多次调用free释放同一片内存，或者传递给free一个未经malloc返回的指针，则报错

3. 函数ListEmpty：正确判断了顺序表是否为空。

   bool ListEmpty(SqList* L)
   {
       return (*L).length == 0;
   }
   //检查长度是否为0

4. 函数DispList：正确实现了顺序表的显示功能。

   void DispList(SqList* L)
   {
       if (L->length == 0)
       {
           printf("什么都没有。");
       }
       else
       {
           for (int i = 0; i < L->length; i++)
               printf("%d ", (*L).data[i]);
           printf("\n");
       }
   }
   //循环打印元素

5. 函数GetElem：

   int GetElem(SqList* L, int i, int& e)
   {
       if (i > L->length || i < 1)
       {
           return -1;
       }
       else
       {
           e = L->data[i - 1];
           return e;
       }
   }
   //若索引合法返回对应元素，否则返回-1

6. 函数LocateElem：正确实现了元素的定位功能。

   int LocateElem(SqList* L, int e)
   {
       for (int i = 0; i < L->length; i++)
       {
           if ((*L).data[i] == e)
               return i;
       }
       return -1;
   }
   //若存在该元素则返回索引，否则返回-1

7. 函数CreateSqList：根据数组创建顺序表，无需调用InitList，因为已经分配了内存并初始化了长度。

   void CreateSqList(SqList*& L, int arr[], int n)
   {
       L = (SqList*)malloc(sizeof(SqList));
       //malloc分配固定大小的内存
       int i = 0;
       for (i = 0; i < n; i++)
       {
           L->data[i] = arr[i];
       }
       //依次对内存赋值
       L->length = n;
   }

8. 函数ListInsert：

   bool ListInsert(SqList*& L, int i, int e)
   {
       if (i < 0 || i >= L->length)
           return false;
       else
       {
           L->length++;
           for (int j = L->length; j > i; j--)
           {
               L->data[j] = L->data[j - 1];
           }
           L->data[i] = e;
           return true;
       }
       //若索引合法，先将顺序表长度+1，再用循环从后往前赋值，最后将该位置的data更改
   }

9. 函数ListLength：

   int ListLength(SqList* L)
   {
       return L->length;
   }

10. 函数ListDelete：

    • 删除元素时，循环应从i开始向后移动元素。

      bool ListDelete(SqList*& L, int i, int& e)
      {
          if (i<0 || i>L->length)
              return false;
          else
          {
              e = L->data[i];
              for (int j = i; j < L->length - 1; j++)
              {
                  L->data[j] = L->data[j + 1];
              }
              L->length--;
              return true;
          }
          //若索引合法，先将该位置的元素传递出去，在用循环从前往后赋值，然后将顺序表长度-1
      }

11. 主函数main：

    int main()
    {    
        int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
        SqList* L;
        InitList(L);
        CreateSqList(L, arr, 10);
        DispList(L);
        ListInsert(L, 3, 111);
        DispList(L);
        int o; ListDelete(L, 3, o);
        DispList(L);
        DestroyList(L);
        return 0;
    }