精华内容
下载资源
问答
  • 数据结构顺序表c语言
    2022-03-18 20:22:59

    目录

    一、定义一个结构体

    二、初始化顺序表

    三、销毁动态开辟的空间

    四、检查容量并且扩容

    五、打印顺序表

    六、尾插

    七、尾删

    八、头插

    九、头删

    十、在指定位置插入一个数

    十一、删除指定位置处的数

    十二、数据的查找

    十三、调试

      结果


    一、定义一个结构体

    //顺序表的动态存储
    typedef struct SeqList
    {
    	SLDataType* a;   //指向之后动态开辟的数组
    	int size;        //存储的有效数据的个数
    	int capacity;    //已开辟空间的容量大小
    }SeqList;

    二、初始化顺序表

    //初始化
    void SeqListInit(SeqList* psl)
    {
    	assert(psl);
    	psl->a = NULL;
    	psl->size = 0;
    	psl->capacity = 0;
    }

     三、销毁动态开辟的空间

    //动态开辟的空间使用完要销毁
    void SeqListDestroy(SeqList* psl)
    {
    	assert(psl);
    	free(psl->a);
    	psl->a = NULL;
    	psl->size = psl->capacity = 0;
    }

     四、检查容量并且扩容

      因为需要增加顺序表存储的内容,就需要先判断已有数据体的容量是否能保证下一个结构体数据的存储,所以就先要判断容量,如果不够就需要增加容量,保证数据的顺利存储。

      新开辟的顺序表的容量可以根据实际情况进行调整,若开辟的较小就需要多次频繁扩容,就造成了效率的降低;若开辟的较大又容易造成空间的浪费;这里是每次都扩大到之前的二倍。

    //检查容量,扩容
    void SeqListCheckCapacity(SeqList* psl)
    {
    	assert(psl);
    	//先判断容量是否满了,如果满了就扩容
    	if (psl->capacity == psl->size)
    	{
    		//因为可能是第一次进来扩容,所以需要应该判断开始容量是否为0
    		size_t newCapacity = psl->capacity == 0 ? 4 : 2 * psl->capacity;
    		SLDataType* tmp = realloc(psl->a, sizeof(SeqList) * newCapacity);
    		if (tmp == NULL)
    		{
    			printf("realloc fail\n");
    			exit(-1);
    		}
    		else
    		{
    			psl->a = tmp;
    			psl->capacity = newCapacity;
    		}
    	}
    }

     

    五、打印顺序表

      这里直接根据顺序表结构的特点依次根据地址找到对应结构体中存储的值打印

    void SeqListPrint(SeqList* psl)
    {
    	assert(psl);
    
    	for (int i = 0; i < psl->size; i++)
    	{
    		printf("%d ", psl->a[i]);
    	}
    
    	printf("\n");
    }

    六、尾插

      插入数据前都要先检查容量并且不够的话还需要扩容,这里直接调用之前定义的函数。尾插就需要知道顺序表的尾在哪儿,因为顺序表在内存中是一段空间,所以可以类比对数组的理解,顺序表的size位置就是尾之后的一个位置,将需要插入的数据放入size位置就可以,插入一个数据之后再将size++

    void SeqListPushBack(SeqList* psl, SLDataType x)
    {
    	assert(psl);
    	SeqListCheckCapacity(psl);
    
    	psl->a[psl->size] = x;
    	psl->size++;
    }

     七、尾删

      尾删类似于尾插,都需要知道尾的位置。这里不需要将尾所在的空间free()释放掉,直接让size--就相当于把尾位置的数据给删除了,因为之后就不会再访问到那个的位置,之后插入新的数据到该位置时就将原数据覆盖了。

    void SeqListPopBack(SeqList* psl)
    {
    	assert(psl);
    
    	psl->a[psl->size] = 0;
    
    	//注意:要确保psl->size大于0,否则减减之后,再之后使用会发生非法访问
    	if (psl->size > 0)
    	{
    		psl->size--;
    	}
    }

    八、头插

      基于顺序表的结构以及内存结构,不能直接在顺序表的头直接开辟空间插入新的数据。这里还是需要知道尾的位置,同上,从尾开始依次将数据先后移动,给头部让出一个空间来插入新的数据

    void SeqListPushFront(SeqList* psl, SLDataType x)
    {
    	assert(psl);
    	SeqListCheckCapacity(psl);
    
    	int end = psl->size - 1;
    	while (end >= 0)
    	{
    		psl->a[end + 1] = psl->a[end];
    		end--;
    	}
    	psl->a[0] = x;
    	psl->size++;
    }

    九、头删

      头删也是类似于尾删,不用释放掉头部对应的空间,只需要从头的下一个位置开始,依次覆盖掉前面的数据

    void SeqListPopFront(SeqList* psl)
    {
    	assert(psl);
    	int begin = 1;
    	if (psl->size > 0)
    	{
    		while (begin < psl->size)
    		{
    			psl->a[begin - 1] = psl->a[begin];
    			begin++;
    		}
    		psl->size--;
    	}
    }

    十、在指定位置插入一个数

      这里就类似于头插,先从尾部依次将数据向后移一个位置,将指定位置移完之后,再将所要插入的数据放入该位置

    //在指定位置插入一个数
    void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
    {
    	assert(psl);
    	SeqListCheckCapacity(psl);
    
    	//暴力检查
    	//assert(pos <= psl->size)
    
    	//温和检查
    	if (pos > psl->size)
    	{
    		printf("pos 越界:%d", pos);
    		return;
    		//exit(-1);
    	}
    
    	//int end = psl->size - 1;
    	//while (end >= (int)pos)      //注意:不同类型的数据作比较会发生整型提升
    	//{
    	//	psl->a[end + 1] = psl->a[end];
    	//	end--;
    	//}
    
    	size_t end = (size_t)psl->size;
    	while (end > pos)
    	{
    		psl->a[end] = psl->a[end - 1];
    		end--;
    	}
    
    	psl->a[pos] = x;
    	psl->size++;
    }

    十一、删除指定位置处的数

      这里也是类似头删,从指定位置的之后一个位置开始,依次将数据向前一个位置覆盖。需要注意指定位置的大小必须大于等于顺序表有效数据的个数,如果小于顺序表有效数据的个数就存在错误,在这就需要对这一前提条件进行断言

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

    十二、数据的查找

      直接遍历查找

    int SeqListFind(SeqList* psl, SLDataType x)
    {
    	assert(psl);
    	for (int i = 0; i < psl->size; i++)
    	{
    		if (psl->a[i] == x)
    			return i;
    	}
    	return -1;
    }

    十三、调试

    #include"SeqList.h"
    
    void SeqListTest1()
    {
    	SeqList s;
    	SeqListInit(&s); //初始化
    	//尾插
    	SeqListPushBack(&s, 1);
    	SeqListPushBack(&s, 2);
    	SeqListPushBack(&s, 3);
    	SeqListPushBack(&s, 4);
    	SeqListPrint(&s);
    
    	//尾删
    	SeqListPopBack(&s);
    	SeqListPrint(&s);
    
    	//尾插
    	SeqListPushBack(&s, 4);
    	SeqListPushBack(&s, 5);
    	SeqListPushBack(&s, 6);
    	SeqListPrint(&s);
    
    	//头插
    	SeqListPushFront(&s, 0);
    	SeqListPrint(&s);
    
    	//头删
    	SeqListPopFront(&s);
    	SeqListPrint(&s);
    
    	//在指定位置插入一个数
    	SeqListInsert(&s, 2, 3);
    	SeqListPrint(&s);
    
    	//删除指定位置的数
    	SeqListErase(&s, 2);
    	SeqListPrint(&s);
    
    	//数据的查找
    	int a = SeqListFind(&s, 6);
    	printf("%d\n", a);
    }
    
    int main()
    {
    
    	SeqListTest1();
    
    	return 0;
    }

      结果

     

    通过上面的顺序表基础功能的实现可以发现一个明显的缺点,就是在头插和头删需要遍历顺序表,时间复杂度较大

    更多相关内容
  • 数据结构顺序表C语言实现)

    千次阅读 多人点赞 2022-03-16 21:52:37
    线性表是一种在实际中广泛使用的数据结构,常见的线性表有:顺序表、链表、栈、队列、字符串等。 线性表在逻辑上是线性结构,也就是连续的一条直线。但在物理结构上并不一定是连续的,线性表在物理上存储时,通常以...

    线性表

    线性表(linear list)是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构,常见的线性表有:顺序表、链表、栈、队列、字符串等。

    线性表在逻辑上是线性结构,也就是连续的一条直线。但在物理结构上并不一定是连续的,线性表在物理上存储时,通常以数组和链式的形式存储。
    在这里插入图片描述

    顺序表

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

    一般情况下,顺序表可以分为一下两种:
    1.静态顺序表:使用定长数组存储元素。
    2.动态顺序表:使用动态开辟的数组存储。
    在这里插入图片描述

    顺序表接口实现

    静态顺序表只适用于确定知道需要存储多少数据的场景。静态顺序表不够灵活。所以我们基本都使用动态顺序表,根据需要空间的多少来分配大小,所有下面我们实现动态顺序表。

    先定义一个结构体:

    typedef int SLDataType;
    typedef struct SeqList
    {
    	SLDataType* a;
    	int size;     //存储数据个数
    	int capacity; //容量空间大小
    }SeqList;
    

    1.顺序表初始化

    void SeqListInit(SeqList* ps);
    
    void SeqListInit(SeqList* ps)
    {
    	assert(ps); //检查指针的有效性
    	ps->a = NULL; //不知道开多大的空间,就先赋值NULL
    	ps->capacity = ps->size = 0;
    }
    

    我们在给ps->a开辟空间的时候,还可以以如下方式开辟,这样甚至更简单一点(开辟完空间后需要检查空间的有效性),但这两种都可以。

    STDataType*tmp=(STDataType*)malloc(sizeof(SeqList)*2);
    

    2.顺序表空间增容

    //检查空间,如果满了,就进行增容
    void SeqListCheckCapacity(SeqList* ps);
    
    void SeqListCheckCapacity(SeqList* ps)
    {
    	assert(ps);
    	if (ps->capacity == ps->size)
    	{
    		size_t newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    		SLDataType* tmp = realloc(ps->a, sizeof(SLDataType) * newcapacity);
    		if (tmp == NULL)
    		{
    			printf("CheckCapacity::%s\n", strerror(errno));//若空间开辟失败,则打印开辟失败的原因
    			exit(-1);//若空间开辟失败,则直接终止程序
    		}
    		else
    		{
    			ps->a = tmp;
    			ps->capacity = newcapacity;
    		}
    	}
    }
    

    1.此处realloc空间,如果容量不够,我们就将容量扩展为原来的两倍,但是我们一开始初始化的空间有可能是0,所以我们应该把这种情况考虑进去。
    2.realloc空间可能因为一些原因而失败,所以要对开辟的空间进行检查,即判断申请的空间是否为空(NULL)。

    3.顺序表打印

    //顺序表打印
    void SeqListPrint(SeqList* ps);
    
    void SeqListPrint(SeqList* ps)
    {
    	assert(ps);
    	for (int i = 0;i < ps->size;++i)//依次遍历,打印出每一个信息
    	{
    		printf("%d ", ps->a[i]);
    	}
    	printf("\n");
    }
    

    4.尾插数据

    在这里插入图片描述

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

    5.尾删数据

    //顺序表尾删
    void SeqListPopBack(SeqList* ps);
    
    void SeqListPopBack(SeqList* ps)
    {
    	assert(ps);
    	if (ps->size > 0)//防止尾删将数据删完了,size出现负数
    	{
    		ps->size--;
    	}
    }
    

    注意:size减的时候一定要加条件限制,防止下标出现负数。

    6.头插数据

    在这里插入图片描述

    /顺序表头插
    void SeqListPushFront(SeqList* ps, SLDataType x);
    
    void SeqListPushFront(SeqList* ps, SLDataType x)
    {
    	assert(ps);
    	SeqListCheckCapacity(ps);//检查空间容量
    	int end = ps->size - 1;
    	while (end >= 0)
    	{
    		ps->a[end + 1] = ps->a[end];
    		--end;
    	}
    	ps->a[0] = x;
    	ps->size++;
    }
    

    7.头删数据

    //顺序表头删
    void SeqListPopFront(SeqList* ps);
    
    void SeqListPopFront(SeqList* ps)
    {
    	assert(ps);
    	//依次挪动数据覆盖删除
    	if (ps->size > 0)//确保有数据可删除,防止下标出现负数
    	{
    		int begin = 1;
    		while (begin < ps->size)
    		{
    			ps->a[begin - 1] = ps->a[begin];
    			++begin;
    		}
    		ps->size--;
    	}
    }
    

    注意:头删一定要保证下标大于0,不然删掉一个下标减一下,当下标减为负数的时候,程序就会出错。头删的时候数据从前向后数据依次向前覆盖一位。

    8.在pos下标处插入数据

    在这里插入图片描述

    //顺序表在pos位置插入数据
    void SeqListInsert(SeqList* ps, size_t pos, SLDataType x);
    
    void SeqListInsert(SeqList* ps, size_t pos, SLDataType x)
    {
    	assert(ps);
    	if (pos > ps->size)
    	{
    		printf("pos越界\n");
    		return;
    	}
    	SeqListCheckCapacity(ps);
    	size_t end = ps->size;
    	while (end > pos)
    	{
    		ps->a[end] = ps->a[end - 1];
    		--end;
    	}
    	ps->a[pos] = x;
    	ps->size++;
    }
    

    这里需要特别注意一下下标的问题,如下图:
    在这里插入图片描述
    在这里循环有两种写法,一种如上,还有一种就是下边这种。

    int end =ps->size-1;
    while(end>=(int)pos)
    {
        ps->a[end+1]=ps->a[end];
        --end;
    }
    

    注意:对比以上两种写法,我们注意到了pos和end的类型。因为坐标不可能为负数,所以pos为size_t类型。对于第二种情况:int end=ps->size-1时,循环执行到最后end的值会变为-1,但pos的类型为size_t,所以当end与pos比较的时候,会发生整形提升,使无符号的end整形提升为有符号的数字和pos比较,所以while条件成立,会继续循环,导致越界访问内存。对于这种我们的解决方法是将pos强制转换为int类型,如上诉代码。
    对于第一种情况: int end=ps->size,循环执行到最后end的值为0,为无符号数,因此刚好完美的进行了移动覆盖,不会出现越界访问的情况。所以我们推荐使用第一种方法。

    9.删除pos下标处数据

    //顺序表删除pos位置的数据
    void SeqListErase(SeqList* ps, size_t pos);
    
    void SeqListErase(SeqList* ps, size_t pos)
    {
    	assert(ps);
    	if (pos >= ps->size)
    	{
    		printf("pos越界\n");
    		return;
    	}
    	size_t begin = pos + 1;
    	while (begin < ps->size)
    	{
    		ps->a[begin - 1] = ps->a[begin];
    		++begin;
    	}
    	ps->size--;
    }
    

    10.数据查找

    依次遍历数据查找,若找到了对应的数据,则返回它的下标。若找不到,则返回-1.

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

    11.顺序表摧毁

    当我们使用动态申请空间时,使用完后,一定要释放动态开辟的内存。否则可能会造成内存泄漏。

    //顺序表销毁
    void SeqListDestroy(SeqList* ps);
    
    void SeqListDestroy(SeqList* ps)
    {
    	assert(ps);
    	free(ps->a);
    	ps->a = NULL;
    	ps->size = ps->capacity = 0;
    }
    
    展开全文
  • 静态顺序表的部分简单操作

    注:以下只记录了静态顺序表的内容!写此博客其目的为记录学习的内容。本人仅为一名计算机小白,如有需改善之处,请大佬指正。

    一、什么是顺序表

    顺序表,顾名思义就是有许多数据元素按照顺序存储结构在存储在线性表中!其实就是这样:(表中含有i个小表情)

    ......

    i

                                    对应的下标:      0              1                2                3               4            ...     ...      i-1

    即该顺序表的长度为i,也就是说顺序表的第i个元素对应的数组下标为i-1,因为顺序表通常使用一维数组来实现,以至于顺序表在他出生的那一刻就已经确定了他的长度,即顺序表的长度确定!

    二、如何实现顺序表

    1.顺序表的结构定义:

    #define M 520                 //定义一个最多存储520个元素的顺序表
    typedef int DataList;         //定义int型线性表
    typedef struct{               //创建结构体
    	DataList data[M];         //用于存放数据元素的一维数组
    	int length;               //表长
    }SeqList;

    2.初始化

    void InitList(SeqList *L){
    	L->length = 0;            //将表长初始化为0
    }                                   

    3.查找

    (1)按值查找

    int Getnum(SeqList *L,Data num){
    	for(int i=0;i<L->length;i++){
    		if(L->data[i] == num)
    			return i+1;            //返回值所在的位置序号
    	}
    	return 0;
    }

    (2)按位查找

    int Getlocate(SeqList *L,int i,Data *num){
    	if(i<1||i>L->length){          //判断非法查找位置
    		return 0;
    	}else{
    		*num = L->data[i-1];
    		return 1;
    	}
    }

    4.插入操作

    从最后一个元素开始一直到待插位置i,逐个往后移。

    L->data[j] = L->data[j-1];

    使第i个位置为空,将元素num填入其中即可。

    完整算法实现

    //i为插入位置,num为待插元素
    int insert(SeqList *L,int i,Data num){
    	if(L->length >= M||i<1||i>L->length+1){
    		return 0;
    	}
    	int j;
    	for(j = L->length;j>=i;j--){
    		L->data[j] = L->data[j-1];
    		L->data[i-1] = num;
    		L->length++;
    	}
    	return 1;
    }

    展开全文
  • 1.建立两个顺序表(通过随机函数生成); 2.排序(升序),输出合并前的结果; 3.对这两个顺序表进行合并(保持升序); 4.输出合并结果
  • 这是数据结构和算法设计课程设计一个选题。实践了顺序表的基本操作的封装,及实践中的调用。特别的对顺序表上的插入和删除操作做出详细的介绍。课设采用静态存储,按值查找。希望能够对其他同学有所帮助
    1. 课程设计题目

    设计出顺序表结构的相关函数库,以便在程序设计中调用。

    1. 题目要求

    (1)包括线性表的各种基本函数以及常用函数(自己确定函数、函数形式及理由)

    (2)最好能借助语言环境实现图形显示功能,以便能将抽象的数据结构以图形方式显示出来,将复杂的运行过程以动态方式显示出来。

    (3)给出若干例程,演示通过调用自己的库函数来实现相关问题的求解。

    1. 题目分析

    基于在《数据结构与算法设计》课程的学习,学习物理结构之顺序存储结构,结合线性表的特点和逻辑结构以及基于线性表实际设计的基本操作。我们设计出以函数为核心、C语言实现、顺序表结构的相关数据库,并通过main主函数进行了集合,能够通过实践的演示,利用对相关函数的调用来实现相关问题解决。

          这里我们选用静态存储作为数组存储方式。

        这里我们需要说明顺序表结构(元素)与数组(元素)联系:

    1. 地址连续
    2. 依次存储
    3. 数据类型相同
    4. 随机存取

    这里我们需要充分了解C语言中利用指针、数组名做参数进行传址方式及传值方式

    这里我们设计的顺序表所完成的基本操作并以函数封装:

    • 创建顺序表CreateList()
    • 顺序表初始化InitList()
    • 按数值进行查找LocateElem()
    • 插入元素操作InsertList()
    • 删除元素数值操作ListDelete ()
    • 清空顺序表ClearList ()
    • 打印顺序表PrintList()

    最后对一些准备工作的介绍

    我们使用了cstdio等6个头文件,3个宏定义进行常量和类型定义以及对顺序表数据结构的表示

    #include<cstdio>
    
    #include<cstdlib>
    
    #include<cstring>
    
    #include<cmath>
    
    #include<algorithm>
    
    #include<iostream>
    
    #define MaxSize 100
    
    #define ElemType int
    
    #define Status int
    
    using namespace std;
    
    typedef struct
    
    {
    
          ElemType data[MaxSize]
    
          Int length;
    
    }SqList;
    1. 课题设计

    1. 函数的模块化设计

    1. 顺序表插入元素

    InsertList(SqList &L,int i,ElemType e)

    【算法步骤】

    • 判断插入位置i是否合法(1<=i<=L.length+1)
    • 判断顺序表的存储空间是否已满
    • 将第L.length至第i序号上的元素依次向后移动一个位置,直至空出第i个位置
    • 将待插入元素e放入第i个位置
    • L.length++
    1. 顺序表上的删除

    ListDelete (SqList &L,int i)

    【算法步骤】

    • 判断删除位置i是否合法(1<=i<=L.length)
    • 将第i+1至第L.length个的元素依次向前移动一个位置

    • L.length--

    这里对典型的插入和删除函数设计思路进行描述。ASL(平均查找长度)因位置不同存在较大差异。

    1. 函数功能的描述

    CreateList(SqList &l,int n):

    参数:顺序表L,顺序表长度n

    功能:创建长度为n的顺序表L

    时间复杂度:O(n)

    操作前提:L是一个未初始化的线性表

            操作结果:将L初始化为一个空的线性表

    InitList(SqList &L)

    参数:表L

    功能:对表L进行初识化

    时间复杂度:O(1)

    操作前提:L是一个已初始化的空表

    操作结果:建立一个非空的线性表L

    InsertList(SqList &L,int i,ElemType e)

    参数:表L,位置i,元素e

    功能:在位置i处插入元素e

    时间复杂度:O(n)

    操作前提:线性表L已存在

    操作结果:将元素s插入到线性表L的i位置

    ListDelete (SqList &L,int i)

    参数:表L,位置i

    功能:删除位置i处元素

    时间复杂度:O(n)

    操作前提:线性表L已存在

    操作结果:将线性表L中i位置的元素删除,

    LocateList (SqList L,int i,ElemType &e)

    参数:表L,位置i,

    功能:返回i序号上的元素,并以e返回其值

    时间复杂度:O(n)

    操作前提:线性表L已存在

    操作结果:在线性表L中查找i位置上元素,若存在,返回元素;若不存在,返回-1

    PrintList(SqList L)

    参数:表L,

    功能:输出L

    操作前提:

    操作结果:在屏幕上显示表中元素

    ClearList (SqList &L)

    参数:表L

    功能:清空顺序表L

    操作前提:

    操作结果:空表

    1. 代码实现
    1. 源代码
    
    #define  _CRT_SECURE_NO_WARNINGS
    #include<cstdio>
    #include<cstdlib>
    #include<cstring>
    #include<cmath>
    #include<algorithm>
    #include<iostream>
    #define MaxSize 100
    #define ElemType int
    #define Status int
    using namespace std;
    //顺序表数据结构
    typedef struct
    {
    	ElemType data[MaxSize];//顺序表元素
    	int length;            //顺序表当前长度
    }SqList;
    //***************************基本操作函数*******************************//
    //初始化顺序表函数,构造一个空的顺序表 
    Status InitList(SqList& L)
    {
    	memset(L.data, 0, sizeof(L));//初始化数据为0
    	L.length = 0;                //初始化长度为0
    	return 0;
    }
    //创建顺序表函数 初始化前n个数据
    bool CreateList(SqList& L, int n)
    {
    	if (n<0 || n>MaxSize)false;//n非法
    	for (int i = 0; i < n; i++)
    	{
    		scanf("%d", &L.data[i]);
    		L.length++;
    	}
    	return true;
    }
    //插入函数 位置i插入数据 i及之后元素后移  1=<i<=length+1 
    bool InsertList(SqList& L, int i, ElemType e)
    {
    	if (i<1 || i>L.length + 1) //判断位置是否有效
    	{
    		printf("位置无效!!!\n");
    		return false;
    	}
    	if (L.length >= MaxSize)//判断存储空间是否已满
    	{
    		printf("当前存储空间已满!!!\n");
    		return false;
    	}
    	for (int j = L.length; j >= i; j--)//位置i及之后元素后移
    	{
    		L.data[j] = L.data[j - 1];
    	}
    	L.data[i - 1] = e;
    	L.length++;
    	return true;
    }
    //删除函数 删除位置i的元素 i之后的元素依次前移
    bool  ListDelete(SqList& L, int i)
    {
    	if (i<1 || i>L.length)
    	{
    		printf("位置无效!!!\n");
    		return false;
    	}
    	for (int j = i; j <= L.length - 1; j++)//位置i之后元素依次前移覆盖
    	{
    		L.data[j - 1] = L.data[j];
    	}
    	L.length--;
    	return true;
    }
    //查找函数 按位置从小到大查找第一个值等于e的元素 并返回位置
    int LocateElem(SqList L, ElemType e)
    {
    	for (int i = 0; i < L.length; i++)//从低位置查找
    	{
    		if (L.data[i] == e)
    			return i + 1;
    	}
    	return 0;
    }
    
    //清空顺序表
    void ClearList(SqList& L) {
    	L.length = 0;
    }
    //********************************功能函数*****************************************//
    //输出功能函数 按位置从小到大输出顺序表所有元素
    void PrintList(SqList L)
    {
    	printf("当前顺序表所有元素:");
    	for (int i = 0; i < L.length; i++)
    	{
    		printf("%d ", L.data[i]);
    	}
    	printf("\n");
    }
    //创建顺序表函数
    void Create(SqList& L)
    {
    	int n; bool flag;
    	L.length = 0;
    	printf("请输入要创建的顺序表长度(>1):");
    	scanf("%d", &n);
    	printf("请输入%d个数(空格隔开):", n);
    	flag = CreateList(L, n);
    	if (flag) {
    		printf("创建成功!\n");
    		PrintList(L);
    	}
    	else printf("输入长度非法!\n");
    
    }
    //插入功能函数 调用InsertList完成顺序表元素插入 调用PrintList函数显示插入成功后的结果
    void Insert(SqList& L)
    {
    	int place; ElemType e; bool flag;
    	printf("请输入要插入的位置(从1开始)及元素:\n");
    	scanf("%d%d", &place, &e);
    	flag = InsertList(L, place, e);
    	if (flag)
    	{
    		printf("插入成功!!!\n");
    		PrintList(L);
    	}
    }
    //删除功能函数 调用ListDelete函数完成顺序表的删除 调用PrintList函数显示插入成功后的结果
    void Delete(SqList& L)
    {
    	int place; bool flag;
    	printf("请输入要删除的位置(从1开始):\n");
    	scanf("%d", &place);
    	flag = ListDelete(L, place);
    	if (flag)
    	{
    		printf("删除成功!!!\n");
    		PrintList(L);
    	}
    }
    //查找功能函数 调用LocateElem查找元素
    void Search(SqList L)
    {
    	ElemType e; int flag;
    	printf("请输入要查找的值:\n");
    	scanf("%d", &e);
    	flag = LocateElem(L, e);
    	if (flag)
    	{
    		printf("该元素位置为:%d\n", flag);
    	}
    	else
    		printf("未找到该元素!\n");
    }
    //菜单
    void menu()
    {
    	printf("********1.创建                        2.插入*********\n");
    	printf("********3.删除                        4.查找*********\n");
    	printf("********5.输出                        6.清空*********\n");
    	printf("********7.退出                              *********\n");
    }
    int main()
    {
    	SqList L; int choice;
    	InitList(L);
    	while (1)
    	{
    		menu();
    		printf("请输入菜单序号:\n");
    		scanf("%d", &choice);
    		if (9 == choice) break;
    		switch (choice)
    		{
    		case 1:Create(L); break;
    		case 2:Insert(L); break;
    		case 3:Delete(L); break;
    		case 4:Search(L); break;
    		case 5:PrintList(L); break;
    		case 6:ClearList(L); break;
    		default:printf("输入错误!!!\n");
    		}
    	}
    	return 0;
    
    
    1. 程序运行结果

    1. 课程设计感悟

    在课程设计中,巩固了知识,锻炼了实践能力,在ASL和时间复杂度上的考虑,更能接感受到顺序表的特点:
    随机访问,既可以在O(1)时间内找到第i个元素。可以像数组是一样利用存储位置直接访问元素
    存储密度高,每个节点只存储数据元素。
    扩展容量不方便(即便采用动态分配的方式实现,扩展长度的时间复杂度也比较高)。
    插入、删除操作不方便,当头插法、和尾插法时,相对好理解简单。但当在中间插入时需要移动大量元素。但是链式存储结构在这方面做的很好。

           总的来说,在C语言的学习时非常有必要的,是理解和掌握数据结构和算法的直接逻辑和语言基础。当然目前接触的数据结构和算法只是冰山一角,一定会存在优化程度更高的算法和数据结构,要怀有空杯心态,进一步学习数据库、kafka、hadoop等等,再者也要注重合作能力的提升,人尽其责,物尽其用。

    1. 参考资料

    《数据结构C语言版第二版》/严蔚敏,李冬梅,吴伟民编

    《数据结构与算法设计》/张小艳,李占利编

    《c/c++语言程序设计》/龚尚福,贾澎涛编

    目录

    课程设计题目

    题目要求

    题目分析

    课题设计

    函数的模块化设计

    函数功能的描述

    《数据结构C语言版第二版》/严蔚敏,李冬梅,吴伟民编

    《数据结构与算法设计》/张小艳,李占利编

    《c/c++语言程序设计》/龚尚福,贾澎涛编


    展开全文
  • C语言实现顺序表数据结构

    千次阅读 多人点赞 2022-04-22 19:00:54
    以下是我们需要实现的顺序表的功能。 以下是写在SeqList.h中的内容,我们将全部需要声明的内容放在此处 pragma once #include <stdio.h> #include <assert.h> #include <stdlib.h> typedef ...
  • c语言中,顺序表通常用数组来存储,这与python中的列表不同,数组是给定长度的,数组中元素的地址也是相邻的,且数组中的元素类型一定要相同,而列表list是的长度理论上是可以无限添加的,(因为pyt...
  • 顺序表各种接口实现
  • 数据结构实验报告1-顺序表实现简易的学生信息管理系统(C语言),包括实验环境,实验的小结,实验的源代码,实验截图等。 说明:仅供参考,如有bug,还请反馈!
  • C语言数据结构学生成绩管理系统
  • 数据结构c语言版)顺序表的实现

    千次阅读 2020-09-12 16:49:42
    数据结构原本的书籍上面只写了算法部分,不能直接运行,在此贴上c语言实现的完整代码,需要注意的地方已在代码中注释 #include <stdio.h> #include <malloc.h> #define LIST_SIZE 100//初始分配空间的...
  • 顺序表顺序储存结构C语言实现版 #include <stdio.h> #define MAXSIZE 100 #define OVERFLOW 0 #define OK 1 #define ERROR 0 int main(){ } //顺序表顺序储存结构 ,这里泛型定义为整形 typedef struct{ ...
  • 顺序表,全名顺序存储结构,是线性表的一种。线性表用于存储逻辑关系为“一对一”的数据顺序表自然也不例外。
  • 数据结构-顺序表基本操作-C语言代码

    千次阅读 多人点赞 2020-01-22 13:37:06
    #顺序表-初始化 #include<stdio.h> #include<stdlib.h> #define maxSize 100 //顺序表的结构体定义 typedef struct { int *data; //存放顺序表元素的数组 int length; //存放顺序表的长度 }...
  • 数据结构--顺序表的实现(c语言实现)

    千次阅读 2021-05-25 18:22:12
    最近终于开始学数据结构了,开个坑记录一下 首先,顺序表是一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为: 1.静态顺序表:...
  • 问题:试写一算法,实现顺序表的就地逆置,即利用原表的存储空间将线性表(a1,a2,...,an)逆置为(an,an-1,...,a1) 算法思想:观察原表和新表顺序,逆置后的线性表是将原表相应位置的元素进行交换,即交换第一个和...
  • C语言描述数据结构 —— 顺序表

    多人点赞 热门讨论 2022-07-29 15:11:58
    线性表是一种在实际中广泛使用的数据结构,常见的线性表顺序表、链表、栈、队列、字符串……线性表在逻辑上是线性结构,也就是说是连续的一条直线。但是在物理结构上并不一定是连续的,线性表在物理上存储时,通常以...
  • 数据结构C语言完成顺序表基本操作,上数据结构课的时候的任务,可以在vs上实现,用switch函数选择
  • 洛阳理工学院实验报告 系别 计算机 班级 学号 姓名 课程名称 数据结构 实验日期 10/23 实验名称 顺序表的基本操作 成绩 实验目的 熟悉掌握线性表顺序存储结构掌握与应用顺序表的查找插入删除等基本操作算法训练和...
  • c语言数据结构顺序表.doc
  • 线性表是n个具有相同特性的数据元素的有限序列,是一种实际中广泛使用的数据结构,常见的线性表有顺序表、链表、栈、队列、字符串。 线性表在逻辑上是线性结构,即连续的一条直线,但在物理上不一定连续,线性表在...
  • 数据结构基础入门】顺序表的概念、结构和接口实现
  • 顺序表C语言实现详解

    千次阅读 2022-04-03 19:43:38
    线性表并不是一种具体的存储结构,它包含 顺序存储结构 和 链式存储结构,是顺序表和链表的统称。除了数组,链表、队列、栈等也是线性表结构。 顺序存储结构:将数据依次存储在连续的整块物理空间中 链式存储结构...
  • 用的数据结构,常见的线性表:顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构,也就说是连续的一条直线,但是在物理结构上并不一定是连续的, 线性表在物理上存储时,通常以数组和链式结构的...
  • C语言数据结构实现顺序表的动态申请内存并且合并,代码可以直接使用。
  • 数据结构-基于C语言实现线性顺序表的增删改查+排序,合表操作
  • 数据结构-顺序表详解(C语言版)

    千次阅读 多人点赞 2021-08-04 09:11:13
    顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储。在数组上完成数据的增删查改。 注意:在顺序表数据的存储是依次的。 顺序表的动态存储 如果空间不够,则...
  • PTA平台数据结构课程顺序表参考答案
  • 基于C语言实现顺序表的基本操作函数,并调用各项函数来完成相应的功能。 #include <stdio.h> #include <stdlib.h> // 静态分配存储 #define maxSize 100 typedef int DataType; typedef struct { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 103,903
精华内容 41,561
关键字:

数据结构顺序表c语言

数据结构 订阅