数组与广义表（数组的顺序表示和实现）

最新推荐文章于 2024-10-09 17:48:02 发布
最新推荐文章于 2024-10-09 17:48:02 发布
阅读量87 收藏 1
点赞数 2
文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75008697/article/details/133559659
版权

文章目录

此操作中需要用到的一些知识

数组的几个基址

  • 数组维界地址(int *base)：指向一个一维数组B他存放了数组A个维度元素的数目
  • 数组元素基址(*bounds)：以二维数组A为例，将数组拉成一个向量L组成一个线性结构的首地址
  • 数组映像函数基址(*constans)：指向一个数组C，它存放了数组A各维度上的数字加1时，元素在线性结构L上移动的距离

有一个二维数组A[3][4] bouds[2] = {3,4} constans[2] = [4,1] eg:求A[2][3] 地址
= A[0][0]+2constans[0]+3constans[1]

可变参数头文件:stdarg.h

声明在stdarg.h中的va_list类型代表一种用于存储形参对应的形参列表中省略号部分的数据对象(详情可变参数)
（上面链接是自己记得笔记在幕布，复制过来看的不是很明了）

代码实现部分

头文件部分

#ifdef DEBUG是测试使用的，已经把#defineDEBUg注释掉了

初始化函数


Status InitArray(Array* A, int dim, ...)
{
    va_list ap;   //声明一个存储参数对象
    int elemtotal; //A的元素总和
    int i;
    if (dim<1 || dim>MAX)
    {
        printf("请输入合法维度\n");
        return ERROR;
    }
    A->dim = dim;
    //创建维界基址数组（保存各维长度）
    A->bounds = (int*)malloc(dim * sizeof(int));
    if (!A->bounds)
    {
        printf("分配失败\n");
        exit(0);
    }
    elemtotal = 1;
    va_start(ap, dim);  //把ap初始化为一个参数列表
    for (i = 0; i < dim; i++)
    {
        A->bounds[i] = va_arg(ap, int);
        //第一个参数变量名，第二个参数变量类型
        if (A->bounds < 0)
        {
            printf("不合法\n");
            return ERROR;
        }
        elemtotal *= A->bounds[i];
    }
#ifdef DEBUG
    printf("%d\n", elemtotal);
#endif
    va_end(ap);
    //初始化数组
    A->data = (ElemType*)malloc(elemtotal * sizeof(ElemType));
    if (!A->data)
    {
        printf("1hao内存不足\n");
        exit(0);
    }
    A->constants = (int*)malloc(dim * sizeof(int));
    if (!A->constants)
    {
        printf("内存不足\n");
        exit(0);
    }
    A->constants[dim - 1] = 1;
    for (i = dim - 2; i >= 0; i--)
        A->constants[i] = A->constants[i + 1] * A->bounds[i + 1];
    
#ifdef DEBUG
    PrintData(A->constants);
#endif // DEBUG

    printf("成功\n");

    return OK;
}

销毁函数

将各个数组地址全部释放，将数组维度初始化为0

Status DestroyArray(Array* A)
{
    if (!A->data)
        return ERROR;
    free(A->data);
    A->data = NULL;
    if (!A->bounds)
        return ERROR;
    free(A->bounds);
    A->bounds = NULL;
    if (!A->constants)
        return ERROR;
    free(A->constants);
    A->constants = NULL;
    A->dim = 0;

    return OK;
}

查询位置函数

查询可变参数中的位置是数组中的第几个元素

Status Locate(Array* A, va_list ap, int* off)
{
    int i, ind;
    *off = 0;
    for (i = 0; i < A->dim; i++)
    {
        ind = va_arg(ap, int);
#ifdef DEBUG
        printf("ind是%d\n", ind);
#endif // DEBUG
        if (ind<0 || ind>A->bounds[i])
        {
            printf("%d维数组已满\n",i + 1);
            return ERROR;
        }
        *off += ind * A->constants[i];
    }
#ifdef DEBUG
    printf("*off是%d\n", *off);
#endif

    return OK;
}

将e赋值为A所指定的元素值

Status Value(Array* A, ElemType* e, ...)
{
    //A是n维数组，e是元素变量
    //若下标合法则将e赋值为A所指定的元素值
    va_list ap;
    int off;
    Status result;
    va_start(ap, *e);

    result = Locate(A, ap, &off);
    if (result <= 0)
        return result;
    *e = *(A->data + off);

    return OK;
}

插入元素

查找传入的位置是数组中的那个位置，将此位置赋值为e

Status Assign(Array* A, ElemType e, ...)
{
    va_list ap;
    int off;
    Status result;
    va_start(ap, e);

    result = Locate(A, ap, &off);
    if (result <= 0)
        return result;
    *(A->data + off) = e;

    return OK;
}

打印函数

先用*bounds算出数组总公共有多少个元素，在开始遍历

void ArrPrint(Array A)
{
    int j, i;
    for (i = 0, j = 1; i < A.dim; i++)
        j *= A.bounds[i];
#ifdef DEBUG
    printf("打印函数%d\n", j);
#endif
    printf("开始遍历\n");
    for (i = 0; i < j; i++)
        printf("%d ", A.data[i]);
}

完整头文件

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#define MAX 8
#define OK 1
#define ERROR 0
#define DEBUG

typedef int Status;
typedef int ElemType;

typedef struct {
    ElemType* data; //数组元素基址
    int dim;        //数组维数
    int* bounds;    //数组维界基址
    int* constants; //数组映像函数基址
}Array;

void PrintData(int* data);

Status InitArray(Array* A, int dim, ...)
{
    va_list ap;   //声明一个存储参数对象
    int elemtotal; //A的元素总和
    int i;
    if (dim<1 || dim>MAX)
    {
        printf("请输入合法维度\n");
        return ERROR;
    }
    A->dim = dim;
    //创建维界基址数组（保存各维长度）
    A->bounds = (int*)malloc(dim * sizeof(int));
    if (!A->bounds)
    {
        printf("分配失败\n");
        exit(0);
    }
    elemtotal = 1;
    va_start(ap, dim);  //把ap初始化为一个参数列表
    for (i = 0; i < dim; i++)
    {
        A->bounds[i] = va_arg(ap, int);
        //第一个参数变量名，第二个参数变量类型
        if (A->bounds < 0)
        {
            printf("不合法\n");
            return ERROR;
        }
        elemtotal *= A->bounds[i];
    }
#ifdef DEBUG
    printf("%d\n", elemtotal);
#endif
    va_end(ap);
    //初始化数组
    A->data = (ElemType*)malloc(elemtotal * sizeof(ElemType));
    if (!A->data)
    {
        printf("1hao内存不足\n");
        exit(0);
    }
    A->constants = (int*)malloc(dim * sizeof(int));
    if (!A->constants)
    {
        printf("内存不足\n");
        exit(0);
    }
    A->constants[dim - 1] = 1;
    for (i = dim - 2; i >= 0; i--)
        A->constants[i] = A->constants[i + 1] * A->bounds[i + 1];
    
#ifdef DEBUG
    PrintData(A->constants);
#endif // DEBUG

    printf("成功\n");

    return OK;
}

Status DestroyArray(Array* A)
{
    if (!A->data)
        return ERROR;
    free(A->data);
    A->data = NULL;
    if (!A->bounds)
        return ERROR;
    free(A->bounds);
    A->bounds = NULL;
    if (!A->constants)
        return ERROR;
    free(A->constants);
    A->constants = NULL;
    A->dim = 0;

    return OK;
}


Status Locate(Array* A, va_list ap, int* off)
{
    int i, ind;
    *off = 0;
    for (i = 0; i < A->dim; i++)
    {
        ind = va_arg(ap, int);
#ifdef DEBUG
        printf("ind是%d\n", ind);
#endif // DEBUG
        if (ind<0 || ind>A->bounds[i])
        {
            printf("%d维数组已满\n",i + 1);
            return ERROR;
        }
        *off += ind * A->constants[i];
    }
#ifdef DEBUG
    printf("*off是%d\n", *off);
#endif

    return OK;
}

Status Value(Array* A, ElemType* e, ...)
{
    //A是n维数组，e是元素变量
    //若下标合法则将e赋值为A所指定的元素值
    va_list ap;
    int off;
    Status result;
    va_start(ap, *e);

    result = Locate(A, ap, &off);
    if (result <= 0)
        return result;
    *e = *(A->data + off);

    return OK;
}

Status Assign(Array* A, ElemType e, ...)
{
    va_list ap;
    int off;
    Status result;
    va_start(ap, e);

    result = Locate(A, ap, &off);
    if (result <= 0)
        return result;
    *(A->data + off) = e;

    return OK;
}

void ArrPrint(Array A)
{
    int j, i;
    for (i = 0, j = 1; i < A.dim; i++)
        j *= A.bounds[i];
#ifdef DEBUG
    printf("打印函数%d\n", j);
#endif
    printf("开始遍历\n");
    for (i = 0; i < j; i++)
        printf("%d ", A.data[i]);
}

void PrintData(int* data)
{
    int j;
    int i = sizeof(data) / sizeof(data[0]);
    for (j = 0; j < i; j++)
        printf("%d ", data[j]);
}

主函数测试部分

中间有一对中括号作用是防止变量重复，第二对i，j，e只在中括号中起作用

#define _CRT_SECURE_NO_WARNINGS 1

#include "Array.h"

int main()
{
	Array A;

	printf("测试InitArray函数\n");
	printf("声明一个三行五列的二维数组\n");
	InitArray(&A, 2, 3, 5);

	printf("测试Assign函数\n");
	printf("将e插入第i行第j列的二维数组中\n");
	int i, j;
	ElemType e;
	for (i = 0; i < A.bounds[0]; i++)
	{
		for (j = 0; j < A.bounds[1]; j++)
		{
			printf("请输入要插入的值\n");
			scanf("%d", &e);
			Assign(&A, e, i, j);
		}
	}
	ArrPrint(A);

	printf("测试Value函数\n");
	{
		printf("将数组中第i行第j列的元素赋值给m\n");
		int i, j;
		ElemType e;
		printf("请输入要获取第i行第j列的元素：");
		scanf("%d %d", &i, &j);
		Value(&A, &e, i, j);
		printf("赋值后m为%d\n", e);
	}

	printf("测试DestroyArray函数\n");
	printf("销毁前数组地址是%p 维度是%d\n", A.data,A.dim);
	DestroyArray(&A);
	printf("销毁后%p 维度是%d\n", A.data,A.dim);

	return 0;
}

留下你的大赞嘿嘿！！！

羊羊茶！
关注
顺序表(数组)实现
hxy1625309592的博客
12-15 3362
1.1 基本介绍 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。 数组是最常见的顺序表，数组(Array)是有限个相同类型的变量所组成的有序集合，数组中的每一个变量被称为元素。数组是最为简单、最为常用的数据结构。 1.2 相关原理分析 1、基本概念 数组用一组连续的内存空间来存储一组具有相同类型的
第5章数组和广义表.ppt
11-28
本章节主要介绍数组和广义表的概念、定义、存储结构和实现算法。数组是由多个相同类型的数据元素组成的有限序列，存储在一块地址连续的内存单元中。数组可以是一维、二维、三维甚至高维数组，每个维度的数组元素个数...
数组的三种初始方法 静态初始化 默认初始化 动态初始化
qq_42384510的博客
07-31 9980
  package cn.sxt.arrays; /**  * 测试数组的三种初始化的方式  * @author 高淇  *  */ public class Test02 { public static void main(String[] args) { //静态初始化 int[]  a = {2,4,65}; User[]  b ={ new User(1001,"高淇"), new ...
数组的顺序存储表示和实现（第五章 P93）
但行好事，莫问前程
03-24 1845
数组的顺序存储表示和实现 数组的顺序存储结构： A[3][4][2]数组的存储结构： 如果要实现的是两维数组，参数中要包括两维的 长度，两个整型量；而如果是三维数组，则参数中要包括三维的长度，三个整型量。随着 所构造的数组的维数不同，参数的个数也不同。这就必须使用变长参数表才能解决参数个 数不定的问题。因此有些函数的形参有“...”...
数据结构基础与算法图解（6）—— 数组和广义表
zyw2002的博客
05-10 1498
6.数组和广义表 6.1 数组 介绍数组的抽象数据类型 ADT Array{ 数据对象： D={aj1,j2...ji|ji=0,....bi-1,i=1,2,....n,n(>0)是数组的维数，bi是数组第i维的长度} 数据关系： R={R1,R2,....,RN} RI={<aj1,j2,...,aji,j+1,...jn|0<=jk<=bk-1,1<=k<=n且k≠i，0<=j1<=bi-2,i=
C++数据结构——数组与广义表
GeekZW的博客
06-29 2597
                                 C++数据结构——数组与广义表 参考博客： （1）理论：https://www.cnblogs.com/KennyRom/p/5971853.html （2）理论：https://www.cnblogs.com/zyrblog/p/6870097.html （3）题型：https://www.cnblogs.com/xing...
数据结构（串、数组和广义表）
会思想的苇草i的博客
02-16 1342
串(String)----零个或多个字符组成的有限序列，是一种特殊的线性表，其数据元素为一个字符，即内容受限的线性表。数组是由类型相同的数据元素构成的有序集合，每个元素称为数组元素。广义表：n ( ≥0)个表元素组成的有限序列。
数据结构-数组和广义表
zp1834446146的博客
12-03 362
二、矩阵的压缩存储 1.特殊矩阵 (1)对称矩阵
数据结构之数组与广义表
L*YUE的博客
01-27 5396
目录联系数组广义表 联系 数组和广义表可看作一种扩展的线性数据结构，其特殊性在于数据元素的构成上。从组成线性表的元素角度看，数组是由具有某种结构的数据元素构成，广义表则是由单个元素或子表构成的。数组和广义表是线性表的推广。 数组 1.数组的定义 从逻辑结构上，数组可以看成是对一般线性表的扩充。一维数组即为线性表，而二维数组可以定义为其数据元素为一维数组（线性表）的线性表。以此类推，N维数组是数据元...
数组与广义表
weixin_61611746的博客
02-14 368
数组和广义表
数据结构【串、数组和广义表】
huajian225的博客
06-28 1431
串的逻辑结构与线性表相似，是一种特殊的线性表，区别仅在于串的数据对象限定为字符；串通常以整体作为操作的对象，而线性表通常以单个元素作为操作对象。串或字符串：是由零个或多个字符组成的有序序列字串：串中任意个连续的字符组成的子序列空串：零个字符的串空格串：由空格组成的串数组是由类型相同的数据元素构成的有序集合，每个元素称为数组元素。(一般用顺序结构)数组可以看成线性表的推广，其特点是结构中的元素本身可以具有某种结构的数据，但属于同一数据类型。广义表是线性表的推广，也称为列表。
数据结构实验报告-数组与广义表-用顺序存储的半三角矩阵生成杨辉三角形5分-实验内容及要求.docx
03-11
本次实验通过对杨辉三角形的生成与输出，不仅巩固了学生对于数组与广义表等基础数据结构的理解，还加深了对半三角矩阵存储方式的认识。通过实际编程实现了对这些理论知识的应用，有助于提高学生的编程能力和解决问题...
第五章 数组和广义表.ppt
12-05
数组的顺序表示和实现通常指的是线性存储结构，即数组中的元素在内存中连续存放，通过下标可以直接计算出元素的存储位置。这种表示方式使得数组的访问非常高效，但插入和删除元素时需要移动大量元素，效率较低。 接...
数据结构实验报告数组和广义表.doc
09-22
"数据结构实验报告数组和广义表" 本实验报告的目的是通过上机练习，熟悉和掌握课堂所讲授的基本知识点。实验内容包括稀疏矩阵的三元组顺序存储和实现稀疏矩阵的转置。 1. 数据结构概述 数据结构是一种组织和存储...
图+查找+排序+循环链表+循环链表+数组+广义表+二叉树与树的转换+哈夫曼树.pptx
11-10
这份名为"图+查找+排序+循环链表+循环链表+数组+广义表+二叉树与树的转换+哈夫曼树.pptx"的文档涵盖了多个关键知识点，下面将对这些主题进行详细解释。 1. **数组**：数组是最基本的数据结构，它允许存储具有相同...
【数据结构】双向链表（Doubly Linked List）
2301_77727857的博客
10-05 537
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
查找与排序-插入排序
wlq_567的博客
10-02 580
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。是一种简单直观的排序算法，其基本思想是将未排序的元素逐个插入到已排序的部分中，直到所有元素都被插入到合适的位置为止。假设我们有以下待排序的数组：[5, 3, 8, 6, 2]最终，数组变为有序状态：[2, 3, 5, 6, 8]
Java：数据结构-ArrayList和顺序表（2）
最新发布
blamep的博客
10-09 381
创建一个空的ArrayList，指定容量为initialCapacity。
（JAVA）浅入数据结构 “堆” - 实现和理论
ZunXin_2580的博客
10-09 406
在树结构上做出一部分改变的堆结构，是如何实现的呢？强烈建议初学者来看一看噢~！
数组与广义表的数据结构描述
算法描述-数组与广义表 本节将详细介绍数组和广义表的概念、特点、存储方式和操作方法，并结合算法描述，展示如何使用数组和广义表来解决实际问题。 一、数组 数组是一种基本的数据结构，由类型相同的数据元素...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值