【C语言实现数据结构】顺序表

已于 2022-10-06 22:54:51 修改
阅读量1.1k 收藏 9
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构
于 2022-10-06 22:41:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66032294/article/details/127178196
版权

顺序表

文章目录

一、线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结
构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物
理上存储时，通常以数组和链式结构的形式存储。

什么是线性表

二、顺序表

1、什么是顺序表？

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表在内存中是连续存储的

2、顺序表的分类
1、静态顺序表
使用定长数组进行存储元素
在这里插入图片描述
2、动态顺序表

动态申请空间，进行存储元素
在这里插入图片描述
静态顺序表相比于动态顺序表，有很大的缺陷
如果是静态顺序表，在数据量很多的情况下，我们申请的空间可能会不够用，当数据量很小的情况下，又会造成很大的空间浪费问题
但如果是动态顺序表，我们能够根据需要自由申请空间，相比于静态顺序表，动态顺序表在空间利用上的优势就很明显

三、顺序表的实现

顺序表结构的定义

静态顺序表

//静态顺序表
#define N 10
typedef int SLTDataType;
typedef struct SeqList
{
	SLTDataType a[N];
}SeqList;

动态顺序表

//动态顺序表
typedef int SLTDataType;
typedef struct SeqList
{
	SLTDataType* a;//指向顺序表的指针
	int size;//顺序表中有效数据的个数
	int capacity;//顺序表的容量大小
}SeqList;

int类型typedef定义为SLTDataType 在后面要存储其他类型的数据的时候，直接修改就可以，比较方便，要指定有效数据的个数和顺序表容量的大小

1、顺序表的初始化

在初始化顺序表的时候，把capacity和size都赋值到相应的初值

//顺序表的初始化
void SeqListInit(SeqList* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

2、顺序表的销毁

销毁顺序表的时候，要把申请的空间给释放掉，并把指针置为空，避免野指针，把size和capacity置为0

//顺序表的销毁
void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

3、顺序表的打印

根据顺序表中size，也就是有效数据的个数，来限制打印的数据个数

//顺序表的打印
void SeqListPrint(SeqList* ps)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

4、检查容量

在进行插入的时候，如果size和capacity的值是相等的，那么我们就需要扩容，在扩容的时候，要避免直接用a指针来接收realloc的返回值，因为如果开辟失败，realloc就会返回一个空指针，那样如果我们用a指针直接进行接收的话，就会造成以前申请的空间也找不到了

//检查容量
void SeqListCheckCapacity(SeqList* ps)
{
	if (ps->capacity == ps->size)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		SLTDataType* ptr = (SLTDataType*)realloc(ps->a, sizeof(SLTDataType) * newcapacity);
		if (ptr == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = ptr;
		ps->capacity = newcapacity;
	}

}

5、顺序表的尾插

顺序表在尾插过程中，要进行容量检查，如果空间不够，就需要扩容，顺序表的尾插相对比较简单，就是直接在数组的最后面插入就可以了

//顺序表的尾插
void SeqLisPushBack(SeqList* ps, SLTDataType x)
{
	assert(ps);
	SeqListCheckCapacity(ps);
	ps->a[ps->size] = x;
	ps->size++;

}

6、顺序表的头插

顺序表头插过程需要挪动数据，就是把所有的数据往后面挪动一个位置，然后再下标为0的位置进行插入就可以，插入以后，记得把有效数据的个数size+1

//顺序表的头插
void SeqListPushFront(SeqList* ps, SLTDataType x)
{
	assert(ps);
	SeqListCheckCapacity(ps);
	int end = ps->size;
	while (end>=0)
	{
		ps->a[end + 1] = ps->a[end];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}

7、顺序表的尾删和头删

尾删直接就size–就可以完成了，如果是头删的话，就把所有的数据往前挪动一位，然后再把size–就可以完成了，需要注意的事，如果数组中有效数据的个数小于0，是不能够进行删除的，此时我们会添加一个断言，就是来断言数组中有效数据的个数大于0，否则会直接报错

//顺序表的头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	int start = 0;
	while (start < ps->size)
	{
		ps->a[start] = ps->a[start + 1];
		start++;
	}
	ps->size
}

//顺序表的尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	
	ps->size--;
}

8、查找数据

在整个顺序表中查找等于x的值，当找到的时候，直接返回x的位置

//查找
int SeqListFind(SeqList* ps, SLTDataType x)
{
	assert(ps);
	int i = 0;
	while (i < ps->size)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
		i++;
	}
	return -1;
}

9、在pos位置插入数据

删除pos位置上的数据主要的要求是要控制好边界，并且，pos位置必须要在顺序表中，那么就要用到断言，没有在顺序表中就会报错

//插入
void SeqListinsert(SeqList* ps, size_t pos, SLTDataType x)
{
	assert(ps);
	assert(pos <= (size_t)ps->size);
	SeqListCheckCapacity(ps);
	size_t end = (size_t)ps->size;
	while (end > pos)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}

10、删除pos位置的值

删除的时候，pos位置的值必须要小于size，因为在顺序表中，是跟数组的存储逻辑是一样的，顺序表的最后一个元素的存储的地方其实是size-1

//删除
void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	assert(pos < (size_t)ps->size);
	size_t begin = pos;
	while (begin < (size_t)ps->size)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}

11、修改pos位置的值

//修改
void SeqListModify(SeqList* ps, size_t pos, SLTDataType x)
{
	assert(ps);
	ps->a[pos] = x;
}

四、完整代码实现

SeqList.h

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int SLTDataType;
typedef struct SeqList
{
	SLTDataType* a;
	int size;//有效数据的个数
	int capacity;//容量大小
}SeqList;
//初始化
void SeqListInit(SeqList* ps);
//销毁
void SeqListDestroy(SeqList* ps);
//打印
void SeqListPrint(SeqList* ps);
//容量检查
void SeqListCheckCapacity(SeqList* ps);
//尾插
void SeqListPushBack(SeqList* ps, SLTDataType x);
//头插
void SeqListPushFront(SeqList* ps, SLTDataType x);
//尾删
void SeqListPopBack(SeqList* ps);
//头删
void SeqListPopFront(SeqList* ps);
//查找
int SeqListFind(SeqList* ps, SLTDataType x);
//插入
void SeqListinsert(SeqList* ps, size_t pos, SLTDataType x);
//删除
void SeqListErase(SeqList* ps, size_t pos);
//修改
void SeqListModify(SeqList* ps, size_t pos, SLTDataType x);

SeqList.c

#include"SeqList.h"
//初始化
void SeqListInit(SeqList* ps)
{
	assert(ps);
	//a的地址置为空 容量和有效数据的大小置为0
	ps->a = NULL;
	ps->capacity = ps->size = 0;
}
//销毁
void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;

}
//打印
void SeqListPrint(SeqList* ps)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
//容量检查
void SeqListCheckCapacity(SeqList* ps)
{
	assert(ps);
	int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
	SLTDataType* tmp = (SLTDataType*)realloc(ps->a, newCapacity * sizeof(SLTDataType));
	if (tmp == NULL)
	{
		perror("realloc fail");
		exit(-1);
	}
	ps->a = tmp;
	ps->capacity = newCapacity;
}
//尾插
void SeqListPushBack(SeqList* ps, SLTDataType x)
{
	assert(ps);
	SeqListCheckCapacity(ps);
	int end = ps->size;
	ps->a[ps->size] = x;
	ps->size++;
}
//头插
void SeqListPushFront(SeqList* ps, SLTDataType x)
{
	assert(ps);
	SeqListCheckCapacity(ps);
	int end = ps->size;
	while (end > 0)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[0] = x;
	ps->size++;
}
//尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	ps->size--;
}
//头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	int begin = 0;
	while (begin < ps->size - 1)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}
//查找
int SeqListFind(SeqList* ps, SLTDataType x)
{
	assert(ps);
	int i = 0;
	while (i < ps->size)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
		i++;
	}
	return -1;
}
//插入
void SeqListinsert(SeqList* ps, size_t pos, SLTDataType x)
{
	assert(ps);
	assert(pos <= (size_t)ps->size);
	SeqListCheckCapacity(ps);
	size_t end = (size_t)ps->size;
	while (end > pos)
	{
		ps->a[end] = ps->a[end - 1];
		end--;
	}
	ps->a[pos] = x;
	ps->size++;
}
//删除
void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	assert(pos < (size_t)ps->size);
	size_t begin = pos;
	while (begin < (size_t)ps->size)
	{
		ps->a[begin] = ps->a[begin + 1];
		begin++;
	}
	ps->size--;
}
//修改
void SeqListModify(SeqList* ps, size_t pos, SLTDataType x)
{
	assert(ps);
	ps->a[pos] = x;
}

test.c

#include"SeqList.h"
void SeqListTest()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushFront(&s, 100);
	SeqListPushFront(&s, 200);
	SeqListPushFront(&s, 300);
	SeqListPushFront(&s, 400);
	SeqListPushFront(&s, 500);
	SeqListPrint(&s);
	int ret = SeqListFind(&s, 100);
	printf("%d ", ret);
	SeqListModify(&s, ret, ret * 100);
	SeqListPrint(&s);

	SeqListDestroy(&s);
}
int main()
{


	SeqListTest();

	return 0;
}

五、顺序表相关题目

一、移除元素

移除元素
在这里插入图片描述
在这里插入图片描述

思路一：遍历删除，实现方法是，一直往后遍历，遇到等于val的值，就把它覆盖，直到把所有的val删除


思路二：开辟一个数组空间，遇到不是val的值，就把它拷贝到新开辟的数组中，然后再把这个数组空间中的内容拷贝回去，输出数组中内的内容

思路三：定义两个指针src和dst，ruguo val遇到等于val的值，只是src往前面走，dst就不动，最后返回的是dst的长度

int removeElement(int* nums, int numsSize, int val){
    int src = 0;
    int dst = 0;
    while(src<numsSize)
    {
        if(nums[src]!=val)
        {
            nums[dst++] = nums[src++];
        }
        else
        {
            src++;
        }
    }
    return dst;
}

二、删除数组中的重复项

删除数组中的重复项
在这里插入图片描述

思路：双指针src和dst，遇到src和dst相等的时候，就移动src，dst不动，直到遍历到最后一个数，这道题注意画图
在这里插入图片描述

int removeDuplicates(int* nums, int numsSize){

    int src = 0;
    int dst  =0;
    nums[dst] = nums[src];
    while(src<numsSize)
    {
        if(nums[src]==nums[dst])
        {
            src++;
        }
        else
        {
            nums[++dst] = nums[src++];
        }

    }
    return dst+1;

}

三、合并两个有序数组

合并两个有序数组

在这里插入图片描述

思路一：开辟一个新数组，把两个数组中的元素放入新数组中，并对数组中的数据进行重新排序

思路一：代码实现
在实现开辟数组空间的时候，我们可以用到calloc函数，calloc=malloc+memset

函数的功能是为num个大小为size的空间开辟一个空间，并且把空间的每个字节初始化为0
与函数malloc的区别只在于calloc会在返回地址之前把申请的空间的每个字节初始化为全0

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n)
{

    int arr1 = 0;
    int arr2 = 0;
    int index = 0; //定义的index是标识的位置
    // 这里用到calloc函数，是既申请空间，又能把空间给初始化
    int* tmp = (int*)calloc(m+n,sizeof(int));

    while(arr1<m && arr2<n)//只有当满足这个条件的时候，才会继续
    {
        if(nums1[arr1] > nums2[arr2])//nums1的值大于nums2的值的时候
                                    //就把nums2数组的内容放到新数组中
        {
            tmp[index++] = nums2[arr2++];
        }
        else
        {
            tmp[index++] = nums1[arr1++];
        }
    }

        if(arr1 < m)  //如果nums1中的元素有剩余
    {
        while(arr1 < m)
        {
            tmp[index++] = nums1[arr1++];
        }
    }

    if(arr2 < n)  //如果nums2中的元素有剩余
    {
        while(arr2 < n)
        {
            tmp[index++] = nums2[arr2++];
        }
    }
memcpy(nums1,tmp, (m+n)*sizeof(int));//将nums1数组中的数据覆盖
    free(tmp);
    tmp = NULL;

    }

思路二：nums1和nums2同时存在，因为要把nums2中的元素拷贝到nums1中，所以nums1中的空间是足够大的，逐一比较两个数组中的元素，把两个数组中稍大的元素放到nums1中的靠后位置
因为nums1中的数组是有序的，所以在nums1中有还有元素剩余的时候，是不需要管的

思路二：代码实现

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
    int end1 = m-1;//这里的end1指向的是nums1的最后一个有效元素
    int end2 = n-1;//这里的end2指向的是nums2的最后一个有效元素
    int end = m+n-1;//这里的end指向的是nums数组的最后一个位置
    while(end1>=0 && end2>=0)
    //只有在end1和end2都有效的时候循环才会继续，否则就会跳出循环
    {
        if(nums1[end1]<nums2[end2])
        {
            nums1[end--] = nums2[end2--];
        }
        else
        {
            nums1[end--] = nums1[end1--];
        }
       
    }
     //因为nums1中的数据是一直有序的，所以不需要判断nums1中的熟悉怒
        //如果nums2中的数组元素还有剩余，我们就可以直接把数组中的内容拷贝放入到nums1中去
        if(end2>=0)
        {
            while(end2>=0)
            {
                nums1[end--] = nums2[end2--];
            }
        }

}

让我比较困惑的是，在进行赋值的时候，为什么数组中的元素没有变化，原来是oj题目中并没有把[1,2,3,0,0,0]中的0给算到数组中的元素，所以end1是从第3个元素开始算起的，于是说，很困惑的问题就解决啦。
在这里插入图片描述

四年过后。
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
顺序表销毁
骆驼胡杨的博客
07-24 3233
顺序表销毁之后不可进行添加数据, 插入数据, 以及删除数据等操作 #include <iostream> #include <Windows.h> #include <string> using namespace std; #define MAX_SIZE 100 typedef struct { int *elems; //顺序表的基地址 int length; //顺序表的长度 int size; //顺序表总空间大小 } Sqlist; boo
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
C语言顺序表
12-08
C语言，顺序表的构建和简单操作。顺序表 //定义结构类型 typedef struct list //构建一个空线性表 void CreateList(List *lst, int maxsize) //若线性表为空，则返回TURE，否则返回FALSE BOOL IsEmpty(List lst) //若线性表已满，则返回TURE，否则返回FALSE BOOL IsFull(List lst) //移除所有元素，线性表为空表 void Clear(List *lst) //若线性表未满且0<=pos<=n，则原表中位置在pos及其以后的所有元素后移一位，元素x插在位置pos处，并且函数返回TURE，否则返回FALSE BOOL Insert(List *lst, int pos, int x) //若线性表非空且0<=pos<=n，则位置在pos处的元素复制到参数*x，从原表中移去该元素，表中pos之后所有元素前移一位，并且函数返回TURE，否则返回FALSE BOOL Remove(List *lst, int pos, int *x) //若线性表非空且0<=pos<=n，则位置在pos处的元素复制到参数*x，并且函数返回TURE，否则返回FALSE BOOL Retrive(List lst, int pos, int *x) //若线性表非空且0<=pos<=n，则位置在pos处的元素值被x替代，并且函数返回TURE，否则返回FALSE BOOL Replace(List *lst, int pos, int x) //输出顺序表 void PrintList(List lst,int maxsize)
顺序表的创建，销毁，查找，插入，删除
2201_75919511的博客
12-24 510
顺序表是一种数据结构，它采用线性存储方式将数据元素按照元素值的大小依次存储在一段连续的地址空间中。顺序表通过数组来实现，数组中的每个元素对应一个数据元素，通过数组下标可以方便地访问任意位置的数据元素。顺序表具有随机存取的特点，即可以快速地访问任意位置的数据元素。顺序表也具有插入和删除操作复杂度较高的缺点，因为当需要插入或删除某个位置的数据元素时，可能需要移动大量的元素来保持数组中元素的连续性。本文描述了顺序表的基本操作，顺序表的创建，销毁，查找，插入，删除
数据结构之顺序表（创建、使用、销毁）
不落风渊的博客
07-23 1万+
顺序表是在计算机内存中采用顺序存储的方式存储的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。顺序表的物理结构和逻辑结构都是连续的。顺序表的增删操作麻烦，需要移动的元素可能很多，修改和查找操作方便，通过下标访问，访问速度快。 下面，我将实现顺序表的创建、使用和删除。（包含头文件与源文件）
数据结构 -＞顺序表的输入 输出 查找 删除 销毁 快速排序
MeOutsider的博客
01-09 3147
《 顺序表 》 顺序表，全名顺序储存结构，是线性表的一种。 顺序表储存数据时，会提前申请一整块足够大小的物理空间，然后将数据依次储存起来，储存时做到数据元素之间不留一丝缝隙。 顺序表_百度百科 个人理解：顺序表储存数据的模式同数组十分相近，但是（当然有但是，（狗头）） ...
数据结构系列学习（二） - 顺序表（Contiguous_List）
曾铎的博客
10-23 1888
在计算机内部存储一张线性表（线性结构的数表），最为方便简单的就是用一组连续的地址的内存单元来存储整张线性表。这种存储结构称为顺序存储结构。这种存储结构下的线性表就称为顺序表。一张顺序表包括这几个特征：有一个唯一的表名来标识该顺序表；内存单元连续存储，也就是说一张顺序表必须要占据一块连续的内存空间；数据顺序存放，元素之间有先后关系；定义一张顺序表也就是在内存中开辟一段连续的存储空间，同时我们定义的顺序表也应该实现增删查改这四个功能。
数据结构—顺序表的销毁
热门推荐
qq_39830449的博客
08-20 1万+
//顺序表的销毁 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define OK 1 #define OVERFLOW -2 #define LIST_INIT_SIZE 10// 线性表存储空间的初始分配量 typedef int Status; //Status是函数数据类型 ，其值是函数结果状态，如OK typedef ...
数据结构—顺序表的初始化与销毁（C语言详细解读版1/3）
怕什么真理无穷，进一寸有一寸的欢喜！
01-31 1239
顺序表的【初始化】实现：全面解读，直接编译。 怎样学好数据结构呢？ ① 自己上手敲代码！ ② 逐行看看别人的代码！
C语言-数据结构-顺序表的创建、插入、删除、销毁
weixin_45925895的博客
08-16 3473
C语言实现数据结构顺序表的创建、添加、删除、销毁
数据结构之顺序表
Python_programer的博客
04-05 417
顺序表是数据结构里最基础的，今天分享关于顺序表的一些操作： 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 因为顺序表又分为静态和动态，而静态的顺序表使用的是定长数组存储，而动态顺序表使用动态开辟的数组存储，生活中常常不知道数据规模的时候居多，需要使用的时候动态扩容，所以静态顺序表局限性更大。 下面就主要讲解动态顺序表： 1.首...
【数据结构实现】C语言实现顺序表
03-06
本次试验用C语言实现顺序表，实现 Init 初始化线性表 Destory 销毁线性表 Clear 清空线性表 IsEmpty 判断线性表是否为空 Length 获取线性表的长度 GetElem 获取线性表中某个元素的值 Locate 在线性表中查找指定元素 ...
PTA—C语言数据结构：顺序表.ppt
10-11
PTA平台数据结构课程顺序表参考答案
数据结构+顺序表的C语言实现
04-24
本工程实现了严蔚敏 《数据结构 C语言》中顺序表的实现以及常用的操作。包括顺序表的初始化、销毁、求表长、查找、查询前驱节点、查询后继节点、插入、删除、遍历、打印等功能。并且写了测试代码，对每个函数都做了...
数据结构顺序表，c语言简单实现
01-12
数据结构顺序表，c语言简单实现
数据结构之单链表之环形链表
zxybf_的博客
05-06 166
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。
【数据结构（邓俊辉）学习笔记】向量06——位图
weixin_44399845的博客
05-03 1019
学习了解下bitmap
数据结构相关
最新发布
weixin_44525733的博客
05-06 627
数据结构——后续还会补充，用Java实现！！
数据结构九：线性表之链式队列的设计
weixin_47040031的博客
04-30 632
现在，我们可以知道，其实从本质上来讲，链式队列就是重新设计头节点的单链表结构，并且只允许头删和尾插（队尾入队头出）；对于循环队列与链队列的比较，可以从两方面来考虑，从时间上，其实它们的基本操作都是常数时间，即都为O(1)的，不过循环队列是事先申请好空间，使用期间不释放，而对于链队列，每次申请和释放结点也会存在一些时间开销，如果入队出队频繁，则两者还是有细微差异。对于空间上来说，循环队列必须有一个固定的长度，所以就有了存储元素个数和空间浪费的问题。
数据结构c语言实现顺序表创建
06-03
以下是C语言实现顺序表创建的示例代码： ``` #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 // 定义顺序表的最大长度 typedef struct { int data[MAXSIZE]; // 存储顺序表元素的数组 int length; // 记录顺序表当前长度 } SqList; // 定义顺序表类型 int main() { SqList L; // 定义顺序表变量 int n, i; printf("请输入顺序表的长度: "); scanf("%d", &n); if (n < 1 || n > MAXSIZE) { // 判断输入的长度是否合法 printf("输入的顺序表长度不合法！\n"); exit(1); // 退出程序 } L.length = n; // 记录顺序表的长度 printf("请输入 %d 个整数作为顺序表的元素:\n", n); for (i = 0; i < n; i++) { scanf("%d", &L.data[i]); // 读取顺序表元素 } printf("顺序表创建完成，当前长度为 %d，元素为:\n", L.length); for (i = 0; i < n; i++) { printf("%d ", L.data[i]); // 输出顺序表元素 } printf("\n"); return 0; } ``` 使用该程序，用户可以输入顺序表的长度和元素，程序可以创建一个顺序表并输出创建结果。在程序中，我们使用了结构体来定义顺序表类型，并定义了一个包含顺序表元素和当前长度的结构体变量L来存储顺序表。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值