数据结构--顺序表简单实现(总结)

最新推荐文章于 2024-05-06 18:41:09 发布
最新推荐文章于 2024-05-06 18:41:09 发布
阅读量1k 收藏 7
点赞数 10
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48084293/article/details/118653831
版权

文章目录

在这里插入图片描述

特点

  1. 顺序表是有序、有限，且元素数据类型相同的集合。
  2. 除第一个元素外，其他元素都有唯一的前驱元素。
  3. 除最后一个元素外，其他的元素都有唯一的后继元素。
  4. 顺序表中的元素总数n(n ≥ 0)即为顺序表的长度，n = 0时，顺序表的长度为0，为空表。

功能实现

定义

#define SUC 1   		// 定义SUC 作为状态返回值，成功
#define ERR 0   		// 定义ERR 作为状态返回值，错误
#define TRUE 1  		// 定义TRUE 作为真假返回值，真
#define FALSE 0 		// 定义FALSE 作为真假返回值，假
#define MAXSIZE 20 		// 定义MAXSIZE为存储空间最大容量，依据情况而定

typedef int Status;     // 定义Status作为状态返回类型
typedef int Bool;       // 定义Bool 作为判断真假返回类型
typedef int ElemType ;  // ElemType 表示表中元素数据类型，依据情况而定
typedef struct       	// 定义存储结构
{
    ElemType data[MAXSIZE];   // 定义数组，作为顺序表的存储结构
    int len; 				// 定义len，表示【顺序表】长度
} SqList;

函数

初始化

功能：将顺序表长度初始化为0。

参数类型：SqList*

返回值类型：Status

Status InitList(SqList* L)
{
    L->len = 0;
    return SUC;
}

重置表

功能：将顺序表长度重置为0，置为空表，该操作是对于以创建顺序表的操作。

参数类型：SqList*

返回值类型：Status

Status ResetList(SqList* L)
{
    L->len = 0;
    return SUC;
}

获取表长

功能：获取顺序表的长度。

参数类型：SqList

返回值类型：int

int ListLength(SqList L)
{
    return L.len;
}

判断是否为空表

功能：判断顺序表是否为空表

参数类型：SqList

返回值类型：Bool

Bool isEmpty(SqList L)
{
    return L.len == 0 ? TRUE : FALSE;
}

访问元素

功能：输出指定元素至控制台

参数类型：ElemType

返回值类型：Status

Status visit(ElemType e)
{
    printf("%d ",e);
    return SUC;
}

遍历顺序表

功能：遍历顺序表中每个元素

参数类型：SqList

返回值类型：Status

Status ListTraverse(SqList L)
{
    int i = 0;
    int len = L.len;
    for(i = 0; i < len; i++)
    {
		visit(L.data[i]);
    }
    printf("\n");
    return SUC;
}

获取元素

功能：将指定位置上的元素的值赋值给接收元素

参数类型：SqList、ElemType*(接收元素)、int(位置)

返回值：Status

说明：

  1. 判断顺序表是否为空表？为空表返回ERR
  2. 判断指定位置是否合法？非法返回ERR
Status GetElem(SqList L, ElemType* e, int p)
{
    if(L.len == 0 || p < 1 || p > L.len)
    {
		return ERR;
    }
    *e = L.data[p - 1];
    return SUC;
}

查找元素

功能：查找指定元素在顺序表中的位置

参数类型：SqList、ElemType

返回值：int

说明：

  1. 判断顺序表是否为空表，空表返回0
  2. 遍历顺序表查找到则返回该位置，否则返回0
int LocataElem(SqList L, ElemType e)
{
    if(L.len == 0)
    {
        return 0;                  // 空表返回0 
    }
    int i = 0;
    for(i = 0; i < L.len; i++)
    {
        if(L.data[i] == e)
            return i + 1;         // 找到则返回位置
    }
    return 0;                     // 找不到则返回0
}

头插

功能：将元素添加至顺序表头。

参数类型：SqList* 、ElemType(添加的元素)

返回值类型：Status

说明：

  1. 判断顺序表是否已满
  2. 将所有元素整体后移一位
  3. 将元素添加至表头，表长+1
Status PushFront(SqList* L, ElemType e)
{
    int i = 0;        
    if (L->len == MAXSIZE)                // 判断顺序表是否已满
    {
        return ERR;
    }
    for (i = L->len - 1; i >= 0; i--)    
    {
        L->data[i + 1] = L->data[i];     // 将所有元素整体后移一位
    }
    L->data[0] = e;                      // 将元素添加至表头
    L->len++;                            // 表长+1
    return SUC;
}

尾插

功能：判断将元素添加至表尾

参数类型：SqList* 、ElemType(添加的元素)

返回值类型：Status

说明：

  1. 判断顺序表是否已满
  2. 将元素添加至表尾，表长+1
Status PushBack(SqList* L, ElemType e)
{
    if (L->len == MAXSIZE)                
    {
        return ERR;                      // 顺序表已满，则返回ERR
    }
                     
    L->data[L->len] = e;                 // 将元素添加至尾部，L->len是顺序表最后一个元素后一个位置，即表尾
    L->len++;                            // 顺序表长度+1
    return SUC;
}

指定位置插入元素

功能：将元素添加至顺序表中指定位置。

参数类型：SqList* 、ElemType(添加的元素)、int(位置)

返回值类型：Status

说明：

在添加元素前需要判断三点：

  1. 当前顺序表是否已满？

  2. 添加的位置是否不合理？

  3. 判断添加的位置是否在表尾？

    如果在表尾添加元素则不需要移动表中其他元素，否则需要将添加位置后的所有元素整体向后移动一位(包括添加位置的当前元素)。

添加完毕后，将表长+1，返回SUC。

Status InsertPos(SqList* L, ElemType e, int p)
{
    if (L->len == MAXSIZE || p < 1 || p > L->len + 1)  // 判断顺序表是否已满，或则插入位置是否合理
    {                                                  //   L->len+1, 连续线性表，中间不能存在空位置
        return ERR;                 
    }
    if (p <= L->len)   			                     // 判断添加位置是否在表尾，表尾不需要移动表中其他元素
    {   // 进入语句，说明p不在表尾
        int i = 0;                   
        for (i = L->len - 1; i >= p - 1; i--)
        {
            L->data[i + 1] = L->data[i];             // 则需要将添加位置后的所有元素向后移动一位
        }
    }

    L->data[p - 1] = e;                               // 将指定元素添加到指定位置
    L->len++;                                         // 表长+1
    return SUC;
}

头删

功能：将顺序表头的元素删除

参数类型：SqList*、 ElemType*(接收删除的元素)

返回值类型：Status

说明：

  1. 判断表是否为空，为空返回ERR；
  2. 将顺序表说有元素整体前移一位
  3. 顺序表长度-1
Status PopFront(SqList* L, ElemType* e)
{
    if (L->len == 0)
        return ERR;                       // 顺序表为空，返回ERR
    *e = L->data[0];                      // 将被删除的元素赋值给*e
    int i = 0;
    for (i = 0; i < L->len - 1; i++)
    {
        L->data[i] = L->data[i + 1];       // 将所有元素整体前移一位
    }
    L->len--;                              // 顺序表长度减1
    return SUC;                            // 返回SUC
}

尾删

功能：将顺序表尾的元素删除

参数类型：SqList*、 ElemType*(接收删除的元素)

返回值类型：Status

说明：

  1. 判断表是否为空，为空返回ERR
  2. 变量接收被删除的元素
  3. 顺序表长度-1
Status PopBack(SqList* L, ElemType* e)
{
    if (L->len == 0)
        return ERR;                       // 顺序表为空，返回ERR
    *e = L->data[L->len - 1];             // 被删除的元素赋值给*e, L->len - 1为最后一个元素的下标
    L->len--;                             // 将表长-1，达到删除表尾元素目的
    return SUC;
}

指定位置删除元素

功能：删除顺序表指定位置元素

参数类型：SqList* 、ElemType*(接收删除的元素)、int(指定删除的位置)

返回值类型：Status

说明：

  1. 判断表是否为空，或者删除位置是否合法，如果为真，则返回ERR。
  2. 将被删除的元素赋值给外部变量。
  3. 判断删除位置是否为最后一个元素，若不是是最后一个元素则将删除位置后的所有元素整体前移一位。
  4. 顺序表长度-1。
  5. 返回SUC。
Status DeletePos(SqList* L, ElemType* e, int p)
{

    if (L->len == 0 || p < 1 || p > L->len)     // 判断表是否为空，或者位置是否合法
        return ERR;
    *e = L->data[p - 1];                       // 将被删除的元素赋值给*e
    if (p < L->len)                            // 判断删除位置是否为最后一个元素
    {
        int i = 0;
        for (i = p; i < L->len; i++)
        {
            L->data[i - 1] = L->data[i];      // 若不是最后一个元素则将删除位置后的所有元素整体前移一位
        }
    }
    L->len--;
    return SUC;
}

指定元素删除

功能：将指定的元素从顺序表中删除

参数类型：SqList* 、ElemType(指定删除元素)

返回值类型：Status

说明：

  1. 调用LocataElem() 函数获取指定元素的位置
  2. 如果LocataElem() 的返回值不为 0，调用DeletePos() 函数将指定元素删除，并返回SUC
  3. 否则返回ERR；
Status DeleteElem(SqList* L, ElemType* e)
{
    int p = LocataElem(*L, *e);            
    if (p)
    {
        DeletePos(L, e, p);
        return SUC;
    }
    return ERR;
}

合并表

功能：将存在于表b，不存在于表a的元素，添加进表a末尾

参数类型：SqList* 、SqList

返回值类型：void

说明：

  1. 访问表b中的问一个元素，需要用到GetElem()函数。
  2. 将获取的元素与La中的每一个元素进行对比。需要用到LocateElem()。
  3. LocateElem()的返回值为0，则说明La中不存在这个元素。
  4. 调用PushBack()函数，将该元素添加至La表尾.
void UnionList(SqList* La, SqList Lb)
{
    ElemType e;                    // 元素e 用来比较两表中是否存在元素e
    // 获取两个表的长度
    int La_len = La->len;
    int Lb_len = Lb.len;
    int i = 0;
    for (i = 1; i <= Lb_len; i++)    // 获取Lb中的每一个元素
    {
        GetElem(Lb, &e, i);
        if (!LocataElem(*La, e))   // 如果La中没有该元素，将该元素添加至表尾。
        {
            PushBack(La, e);
        }
    }
}

测试代码

#define SUC 1   		// 定义SUC 作为状态返回值，成功
#define ERR 0   		// 定义ERR 作为状态返回值，错误
#define TRUE 1  		// 定义TRUE 作为真假返回值，真
#define FALSE 0 		// 定义FALSE 作为真假返回值，假
#define MAXSIZE 20 		// 定义MAXSIZE为存储空间最大容量，依据情况而定

typedef int Status;     // 定义Status作为状态返回类型
typedef int Bool;       // 定义Bool 作为判断真假返回类型
typedef int ElemType ; 	// ElemType 表示表中元素数据类型，依据情况而定
typedef struct       	// 定义存储结构
{
    ElemType data[MAXSIZE];    // 定义数组，作为线性表的存储结构
    int len; 				  // 定义len，表示【线性表】长度
} SqList;


// 初始化
Status InitList(SqList* L)
{
    L->len = 0;              // 将表长初始化为0，该操作是是对于新创建的表
    return SUC;              
}

// 重置表                   
Status ResetList(SqList* L)
{
    L->len = 0;              //  将顺序表长度重置为0，置为空表，该操作是对于以创建顺序表的操作。
    return SUC;
}

// 判断是否为空表
Bool isEmpty(SqList L)
{
    return L.len == 0 ? TRUE : FALSE;   
}

// 获取表长
int ListLength(SqList L)
{
    return L.len;          
}


// 访问元素
Status visit(ElemType e)
{
    printf("%d ", e);            // 打印元素
    return SUC;
}

// 遍历表
Status ListTraverse(SqList L)
{
    int i = 0;
    int len = L.len;
    for (i = 0; i < len; i++)   
    {
        visit(L.data[i]);       // 调用visit函数依次打印顺序表中的元素
    }
    printf("\n");
    return SUC;
}


// 获取元素
Status GetElem(SqList L, ElemType* e, int p)
{
    if (L.len == 0 || p < 1 || p > L.len)
    {
        return ERR;          // 空表，或位置不合法返回ERR
    }
    *e = L.data[p - 1];      // 将指定位置的元素赋值给e，e为真正的返回值
    return SUC;              // SUC为返回的状态
}

// 查找元素
int LocataElem(SqList L, ElemType e)
{
    if (L.len == 0)
    {
        return 0;                  // 空表返回0 
    }
    int i = 0;
    for (i = 0; i < L.len; i++)
    {
        if (L.data[i] == e)
            return i + 1;         // 找到则返回位置
    }
    return 0;                     // 找不到则返回0
}

// 头插
Status PushFront(SqList* L, ElemType e)
{
    int i = 0;        
    if (L->len == MAXSIZE)                
    {
        return ERR;                       // 顺序表已满，则返回ERR
    }
    for (i = L->len - 1; i >= 0; i--)    
    {
        L->data[i + 1] = L->data[i];     // 将所有元素整体后移一位
    }
    L->data[0] = e;                      // 将元素添加至表头
    L->len++;                            // 表长+1
    return SUC;
}

// 尾插
Status PushBack(SqList* L, ElemType e)
{
    if (L->len == MAXSIZE)                
    {
        return ERR;                      // 顺序表已满，则返回ERR
    }
                     
    L->data[L->len] = e;                 // 将元素添加至尾部，L->len是顺序表最后一个元素后一个位置，即表尾
    L->len++;                            // 顺序表长度+1
    return SUC;
}

// 按位置插入
Status InsertPos(SqList* L, ElemType e, int p)
{
    if (L->len == MAXSIZE || p < 1 || p > L->len + 1)  // 判断顺序表是否已满，或则插入位置是否合理
    {                                                  //   L->len+1, 连续线性表，中间不能存在空位置
        return ERR;
    }
    if (p <= L->len)   			                     // 判断添加位置是否在表尾，表尾不需要移动表中其他元素
    {   // 进入语句，说明p不在表尾
        int i = 0;
        for (i = L->len - 1; i >= p - 1; i--)
        {
            L->data[i + 1] = L->data[i];             // 则需要将添加位置后的所有元素向后移动一位
        }
    }

    L->data[p - 1] = e;                               // 将指定元素添加到指定位置
    L->len++;                                         // 表长+1
    return SUC;
}


// 头删
Status PopFront(SqList* L, ElemType* e)
{
    if (L->len == 0)
        return ERR;                       // 顺序表为空，返回ERR
    *e = L->data[0];                      // 将被删除的元素赋值给*e
    int i = 0;
    for (i = 0; i < L->len - 1; i++)
    {
        L->data[i] = L->data[i + 1];       // 将所有元素整体前移一位
    }
    L->len--;                             // 顺序表长度减1
    return SUC;                           // 返回SUC
}

// 头删
Status PopBack(SqList* L, ElemType* e)
{
    if (L->len == 0)
        return ERR;                       // 顺序表为空，返回ERR

    *e = L->data[L->len - 1];             // 被删除的元素赋值给*e, L->len - 1为最后一个元素的下标
    L->len--;                             // 将表长-1，达到删除表尾元素目的
    return SUC;
}



// 指定位置删除
Status DeletePos(SqList* L, ElemType* e, int p)
{

    if (L->len == 0 || p < 1 || p > L->len)     // 判断表是否为空，或者位置是否合法
        return ERR;
    *e = L->data[p - 1];                       // 将被删除的元素赋值给*e
    if (p < L->len)                            // 判断删除位置是否为最后一个元素
    {
        int i = 0;
        for (i = p; i < L->len; i++)
        {
            L->data[i - 1] = L->data[i];      // 若不是最后一个元素则将删除位置后的所有元素整体前移一位
        }
    }
    L->len--;
    return SUC;
}

// 指定元素删除
Status DeleteElem(SqList* L, ElemType* e)
{
    int p = LocataElem(*L, *e);
    if (p)
    {
        DeletePos(L, e, p);
        return SUC;
    }
    return ERR;
}


// 合并表
void UnionList(SqList* La, SqList Lb)
{
    ElemType e;                    // 元素e 用来比较两表中是否存在元素e
    // 获取两个表的长度
    int La_len = La->len;
    int Lb_len = Lb.len;
    int i = 0;
    for (i = 1; i <= Lb_len; i++)    // 获取Lb中的每一个元素
    {
        GetElem(Lb, &e, i);
        if (!LocataElem(*La, e))   // 如果La中没有该元素，将该元素添加至表尾。
        {
            PushBack(La, e);
        }
    }
}



int main()
{
    // 创建顺序表La,Lb
    SqList La,Lb; 

    // 创建接收ElemType类型变量
    ElemType elem;

    // 创建循环变量
    int i = 0;

    // 创建接收状态变量
    Status s = 0;

    // 创建接收真值变量
    Bool b = 0;

    // 创建接收int返回值变量
    int ret = 0;

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

    // 在顺序表La的表头插入5个元素
    for (i = 1; i <= 5; i++)
    {
        PushFront(&La, i);
    }
    printf("1.  表头添加元素后：");
    ListTraverse(La);

    // 删除表头元素
    s = PopFront(&La,&elem);
    // 判断删除是否成功
    if (s)
    {
        printf("2.  被删除的元素是：%d\n", elem);
        printf("3.  删除表头元素后：");
        ListTraverse(La);

        // 获取顺序表当前长度
        ret = ListLength(La);
        printf("4.  顺序表当前长度为：%d\n", ret);
    }
    else
    {
        printf("2.  删除失败！\n");
    }


    // 重置顺序表
    s = ResetList(&La);
    printf("5.  顺序表是否重置成功？ret = %d（1. 成功 0. 失败）\n", s);

    // 判断顺序表是否为空 
    b = isEmpty(La);
    printf("6.  顺序表是否为空？    bl = %d（1. 是 0. 否）\n", b);

    // 再次在La的表尾处插入10个元素
    for (i = 1; i <= 10; i++)
    {
        PushBack(&La, i);
    }
    printf("7.  表尾添加元素后：");
    ListTraverse(La);
    
    // 删除表尾元素
    s =  PopBack(&La, &elem);
    // 判断删除是否成功
    if (s)
    {
        printf("8.  被删除的元素是：%d\n", elem);
        printf("9.  删除表尾元素后：");
        ListTraverse(La);

        // 获取顺序表当前长度
        ret = ListLength(La);
        printf("10. 顺序表当前长度为：%d\n", ret);
    }
    else
    {
        printf("8.  删除失败！\n");
    }


    // 在指定位置插入元素
    for (i = 5; i <= 8; i++)
    {
        InsertPos(&La, 233, i);
    }
    printf("11. 指定位置插入元素后：");
    ListTraverse(La);

    // 在指定位置删除元素
    printf("12. 指定位置被删除元素是：");
    for (i = 1; i <= 3; i++)
    {
        DeletePos(&La, &elem, i);
        printf("%d ", elem);
    }
    printf("\n13. 删除指定位置的元素后：");
    ListTraverse(La);

    // 获取顺序表当前长度
    ret = ListLength(La);
    printf("14. 顺序表当前长度为：%d\n", ret);

    // 获取指定位置的元素
    printf("15. 查找指定位置元素为：");
    for (i = 0; i < 3; i++)
    {
        s = GetElem(La, &elem, i);
        if (s)
        {
            printf("%d ", elem);
        }
        else 
        {
            printf("该元素不存在! ");
        }
    }

    // 查找元素
    elem = 233;
    ret = LocataElem(La, elem);
    printf("\n16. 查找元素%d的位置在：第%d个\n", elem, ret);
    
    // 删除指定元素
    s = DeleteElem(&La, &elem);
    if (s)
    {
        printf("17. 删除元素%d成功！\n", elem);
    }
    else
    {
        printf("17. 删除失败！\n");
    }

    printf("18. 删除指定元素后：");
    ListTraverse(La);

    // 获取顺序表当前长度
    ret = ListLength(La);
    printf("19. 顺序表当前长度为：%d\n", ret);

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

    // 表尾插入元素
    for (i = 5; i <= 15; i++)
    {
        PushBack(&Lb, i);
    }
    printf("20. 在表Lb的尾部插入元素后：");
    ListTraverse(Lb);

    // 合并表，将Lb中存在，la中不存在的添加到La中
    UnionList(&La, Lb);
    printf("21. 两表合并后La表的元素有：");
    ListTraverse(La);
    return 0;
}

在这里插入图片描述

庸人冲
关注
  • 10
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
第四次作业 6-2 有序顺序表的插入
starrynightbeats的博客
09-17 1万+
6-2 有序顺序表的插入（10 分） 本题要求实现递增顺序表的有序插入函数。L是一个递增的有序顺序表，函数Status ListInsert_SortedSq(SqList &L, ElemType e)用于向顺序表中按递增的顺序插入一个数据。 比如：原数据有：2 5，要插入一个元素3，那么插入后顺序表为2 3 5。 要考虑扩容的问题。 函数接口定义： Status List
数据结构 c++ 顺序表的实现及应用
07-12
总结来说，“数据结构 C++ 顺序表的实现及应用”这一主题涵盖了从理论到实践的全面知识，包括顺序表的基本概念、C++中的实现方式以及其在实际问题中的应用和优化。理解并掌握这一基本数据结构及其使用，对于学习和...
顺序表&链表超全大总结
yue152152的博客
03-29 1755
线性表 线性表是n个具有形同特性的数据元素的有限序列。常见的线性表：顺序表、链表、栈，队列、字符串……本文重点讲解顺序表和链表，其他结构可见数据结构专栏的其他内容 注意：线性表在逻辑上是线性结构，也就是说是连续的但在物理结构上。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 顺序表 概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可分为静态顺序表和动态顺序表
《数据结构与算法》——线性表之顺序表（SqList）总结
Kwzc4的博客
07-20 1万+
《数据结构与算法》——线性表之顺序表（SqList）总结 从前天开始着手复习线性表部分，整了3个下午才用C++对顺序表的部分内容进行了成功实现，下面就简单进行以下总结。 目录 《数据结构与算法》——线性表之顺序表总结 定义 class SqList 方法实现 错误 难点 参考文献 定义 线性表：具有线性存储结构的抽象数据类型，它是由n个数据元素组成的有限序列。其中数据元...
数据结构——顺序表总结
最新发布
2301_77987288的博客
05-06 323
顺序表
顺序表功能的实现与总结
lzy15192536135的博客
03-26 2845
顺序表所需要功能 1.创建一个空的顺序表 2.指定位置插入数据 3.判断顺序表满 4.遍历顺序表 5.判断顺序表是否为空 6.删除指定位置的数据 7.修改指定位置的数据 8.修改指定的数据(将一个数据修改为新值) 9.查找指定数据的位置 10.查找指定位置的数据 11.清空表 首先创建一个结构体 typedef int datatype;//定义一个数据类型为datatype，方便之后使用 //定义一个顺序表的结构体 typedef struct list_t { datatype data[N]
顺序表应用5：有序顺序表归并
不积跬步，无以至千里
07-26 908
Think： 这题 刚开始想直接 用冒泡来水题 ， 后来很果断的TLE （废话 O(n^2) 的复杂度 不超时才怪）， 然后 就改成了 用快排， 整体思路还是很好理解的Problem Description已知顺序表A与B是两个有序的顺序表，其中存放的数据元素皆为普通整型，将A与B表归并为C表，要求C表包含了A、B表里所有元素，并且C表仍然保持有序。 Input输入分为三行： 第一行输入m、n
数据结构课件-线性表顺序表.ppt
09-28
线性表是一种基本的数据...总结起来，线性表是一种基础但至关重要的数据结构，它的逻辑结构简单，操作直观，适用于许多实际问题。理解和掌握线性表及其操作是学习数据结构的基础，有助于提升程序设计和软件开发的能力。
数据结构C++顺序表
03-04
本主题聚焦于一种基础且重要的数据结构——顺序表，尤其关注如何在C++中实现这一概念。 顺序表是一种线性数据结构，其中元素在内存中按顺序存储。在C++中，我们可以使用数组来实现顺序表。这种结构的优点是访问速度...
单链表-C++数据结构之单链表实现.zip
03-13
单链表常用于实现队列、栈、表达式解析、图形算法等多种数据结构和算法中。 总结，C++中的单链表实现涉及到对链表节点的理解、链表操作的实现以及性能优化的考虑。通过学习单链表，开发者能够更好地掌握动态数据...
数据结构顺序表c++代码
12-06
本文将深入探讨“数据结构顺序表”的概念以及如何使用C++实现它的基本操作，包括创建、查找、插入和删除。 顺序表，顾名思义，是元素在内存中按照线性顺序排列的数组。它具有连续的存储空间，每个元素都有一个固定...
C语言实现顺序表的初始化、增删查改基本功能
MZYYZT的博客
01-25 2408
C语言实现顺序表的初始化、增删查改基本功能引言定义原理实现过程及结果代码运行结果总结 引言 定义 顺序表是线性表的顺序存储结构。形如A_1 、A_2…….A_n的表，这个表的大小为N；并且，我们称大小为0的表为空表。 原理 <1> 其实顺序表的实现就是简单的数组实现，对表的所有操作都是通过使用数组来实现的。 <2> 顺序表中的第一个元素只有一个后继节点，最后一个元素只有一个前驱节点，中间元素均只有一个前驱节点和一个后继节点。 实现过程及结果 C语言实现顺序表的所有函数操作。 代码 #
有序顺序表的插入
qq_43824618的博客
05-10 1034
#include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 typedef struct Sqlist { int data[10]; int Length; }SqList; int InitList(SqList * L) //初始化线性表 { L->Leng...
一个顺序表，并实现插入、删除、查找操作。/验证实验/
weixin_41867334的博客
06-25 1962
#include&lt;iostream.h&gt;#include&lt;stdlib.h&gt;# define maxsize 50 typedef struct {int a[maxsize]; int size;}sqlist; void Initlist(sqlist &amp;L,int n)//建立顺序表{ int i; cout&lt;&lt;"输入...
顺序表实现
m0_63185171的博客
07-07 97
了解链表这个数据结构，就先了解顺序表
顺序表的个人心得
weixin_43542902的博客
08-23 5394
为什么要有顺序表？ 为了有序存储连续的数据。 顺序表存储：开辟连续的内存空间，空间里保存真实数据的引用地址，因为地址固定存储四个字节，可以让当前数据结构产生一种规律，不管访问哪个元素，用开始位置+数据位置*4个字节都能快速找到数据。 顺序表分离和不分离存储模式：除了专门存储数据的内存，顺序表还有一个表头，分离模式下表头保存的是内存空间长度、元素合集、第一个元素的地址引用，不分离模式将空间长度和元...
数据结构小结——顺序表（数组版）
qq_34652485的博客
07-22 908
何为顺序表，引用百度百科中的一段话来说 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
数据结构学习心得——顺序表
Xiaowei's Blog
08-16 1万+
一、线性表的定义线性表是具有相同特性数据元素的一个有限序列。该序列中所含元素的个数叫做线性表的长度，用n（n>0）表示。二、线性表的存储结构线性表的存储结构有顺序存储和链式存储两种。前者称为顺序表，后者称为链表（链表见下篇博客，这里介绍下顺序表）。 顺序表 顺序表就是把线性表中的所有元素按照其逻辑顺序，一次存储到从指定的春初位置开始的一块连续的存储空间中。 顺序表的操作 顺序表的基本操作有初始化
数据结构：顺序表的基本操作
热门推荐
Keep Fighting All The Time
05-03 10万+
线性表的顺序存储 顺序表的线性存储示意图 C语言定义线性表的顺序存储结构 线性表的顺序存储        线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中，即：通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。采用顺序存储结构存储的线性表通常简称为顺序表。        顺序存
第2章 线性表.pptx
09-25
- 了解顺序表和链表在时间复杂度和空间复杂度上的差异，并能根据实际应用场景选择合适的数据结构。 - 应用线性表解决实际问题，如一元多项式的加法等。 案例分析中，例如一元多项式的运算，可以将多项式的非零项...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值