数据结构||顺序表的各种功能实现（动态增长版本)

最新推荐文章于 2023-03-18 23:43:06 发布
最新推荐文章于 2023-03-18 23:43:06 发布
阅读量208 收藏
点赞数
分类专栏： 数据结构的学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HuiDiExAg/article/details/101704939
版权

文件一common.h

#ifndef COMMON_H
      
      
        
        #define COMMOM_H
      
      
        
        

      
      
        
        #include<stdio.h>
      
      
        
        #include<stdlib.h>
      
      
        
        #include<string.h>
      
      
        
        #include<stdbool.h>
      
      
        
        #include<assert.h>
      
      
        
        //#include<vld.h>//检测内存泄漏的头文件
      
      
        
        #define DataType int
      
      
        
        #define CAPACITY 8
      
      
        
        typedef struct SeqList
      
      
        
        {
      
      
        
        	DataType* Base;//指向表头的指针
      
      
        
        	size_t size;//顺序表当前存储的个数
      
      
        
        	size_t capacity;//顺序表容量
      
      
        
        }SeqList;
      
      
        
        bool SeqListIsFull(SeqList* psl);
      
      
        
        void SeqListInit(SeqList* psl, DataType sz);
      
      
        
        bool SeqListPushBack(SeqList* psl, DataType x);
      
      
        
        void SeqList_show(SeqList* psl);
      
      
        
        bool SeqListPushFront(SeqList* psl, DataType x);
      
      
        
        size_t SeqListLength(SeqList* psl);
      
      
        
        void SeqListclear(SeqList* psl);
      
      
        
        bool SeqListIsempty(SeqList* psl);
      
      
        
        void SeqListSort(SeqList* psl);
      
      
        
        void SeqListReverse(SeqList* psl);
      
      
        
        bool SeqListModiftByPos(SeqList* psl, int pos, DataType item);
      
      
        
        void Destort_Seqlist(SeqList* psl);
      
      
        
        void ModifyByValue(SeqList* psl,int val,int x);
      
      
        
        int FindByPos(SeqList* psl, int pos, DataType* ret);
      
      
        
        int FindByVal(SeqList* psl, int val, DataType* ret);
      
      
        
        bool Pop_back(SeqList* psl);
      
      
        
        bool Pop_Front(SeqList* psl);
      
      
        
        bool SeqlistInc(SeqList* psl);



        #endif

2.test.c

#include"common.h"
      
      
        
        int main()
      
      
        
        {
      
      
        
        	SeqList mylist;
      
      
        
        	SeqListInit(&mylist, CAPACITY);//初始化顺序表;
      
      
        
        	int select = 1;
      
      
        
        	int pos = 0;
      
      
        
        	DataType item = 0;
      
      
        
        	DataType ret = 0;
      
      
        
        	DataType flag = 0;
      
      
        
        	while (select)
      
      
        
        	{
      
      
        
        		printf("**************************************\n");
      
      
        
        		printf("****1.push_back     2.push_front******\n");
      
      
        
        		printf("****3.show_list     0.list_exit*******\n");
      
      
        
        		printf("****4.length        5.clear***********\n");
      
      
        
        		printf("****6.sort          7. reverse********\n");
      
      
        
        		printf("****8.Modify_pos    9.Modify_value****\n");
      
      
        
        		printf("****10.Find_pos     11.Find_value ****\n");
      
      
        
        		printf("****12.Pop_back     13.Pop_front  ****\n");
      
      
        
        		printf("**         14.Destory_Seqlist       **\n");
      
      
        
        		printf("请选择>");
      
      
        
        		scanf_s("%d",&select);
      
      
        
        		if (select == 0)
      
      
        
        		{
      
      
        
        			break;
      
      
        
        		}
      
      
        
        		switch (select)
      
      
        
        		{
      
      
        
        		case 1:
        		printf("请输入你要插入的数据,打印-1退出\n");
      
      
        
        			while (scanf_s("%d", &item), item != -1)
      
      
        
        			{
      
      
        
        				SeqListPushBack(&mylist, item);
      
      
        
        			}
      
      
        
        			break; 
      
      
        
        		case 2:
      
      
        
        			printf("请输入你要插入的数据,打印-1退出\n");
      
      
        
        			while (scanf_s("%d", &item), item != -1)
      
      
        
        			{
      
      
        
        				SeqListPushFront(&mylist, item);
      
      
        
        			}
      
      
        
        			break;
      
      
        
        		case 3:
      
      
        
        			SeqList_show(&mylist);
      
      
        
        			break;
      
      
        
        		case 4:
      
      
        
        			printf("%d", SeqListLength(&mylist));
      
      
        
        			printf("\n");
      
      
        
        			break;
      
      
        
        		case 5:
      
      
        
        			SeqListclear(&mylist);
      
      
        
        			break;
      
      
        
        		case 6:
      
      
        
        			SeqListSort(&mylist);
      
      
        
        			break;
      
      
        
        		case 7:
      
      
        
        			SeqListReverse(&mylist);
      
      
        
        			break;
        			case 8:
      
      
        
        			printf("请输入你要插入的位置\n");
      
      
        
        			scanf_s("%d", &pos);
      
      
        
        			printf("请输入你要插入的数据\n");
      
      
        
        			scanf_s("%d", &item);
      
      
        
        			SeqListModiftByPos(&mylist, pos, item);
      
      
        
        			break;
      
      
        
        		case 9:
      
      
        
        			printf("请输入要被修改的数据>");
      
      
        
        			scanf_s("%d", &pos);
      
      
        
        			printf("请输入要改的数据>");
      
      
        
        			scanf_s("%d", &item);
      
      
        
        			ModifyByValue(&mylist, pos,item);
      
      
        
        			break;
      
      
        
        		case 10:
      
      
        
        			printf("请输入要查找的位置>");
      
      
        
        			scanf_s("%d", &item);
      
      
        
        			flag = FindByPos(&mylist,item,&ret);
      
      
        
        			printf("%d\n", flag);
      
      
        
        		case 11:
      
      
        
        			printf("请输入要查找的值>");
      
      
        
        			scanf_s("%d", &item);
      
      
        
        		flag = FindByVal(&mylist, item, &ret);
      
      
        
        		if (flag == -1)
        		{
      
      
        
        			printf("找不到\n");
      
      
        
        		}
      
      
        
        		else
      
      
        
        		printf("%d\n", flag);
      
      
        
        			break; 
      
      
        
        		case 12:
      
      
        
        			Pop_back(&mylist);
      
      
        
        			break;
      
      
        
        		case 13:
      
      
        
        			Pop_Front(&mylist);
      
      
        
        			break;
      
      
        
        		case 14:
      
      
        
        			Destort_Seqlist(&mylist);
      
      
        
        			break;
      
      
        
        		default :
      
      
        
        			printf("输入错误,请重新输入>");
      
      
        
        		}
      
      
        
        

      
      
        
        	}
      
      
        
        	return 0;
      
      
        
        }

3.seqlist.c

#include"common.h"
      
      
        
        //函数的实现
      
      
        
        void SeqListInit(SeqList* psl, DataType sz)
      
      
        
        {
      
      
        
        	psl->capacity = sz > CAPACITY ? sz : CAPACITY;
      
      
        
        	psl->Base = (DataType*)malloc(sizeof(DataType)* (psl->capacity));
      
      
        
        	psl->size = 0;
      
      
        
        }
      
      
        
        bool SeqlistInc(SeqList* psl)
      
      
        
        {
      
      
        
        	assert(psl != NULL);
      
      
        
        	psl->Base = realloc(psl->Base, sizeof(DataType)* 2);
      
      
        
        	if (psl->Base == NULL)
      
      
        
        	{
      
      
        
        		printf("内存开辟失败>");
      
      
        
        		psl->capacity += 2;
      
      
        
        		return true;
      
      
        
        	}
      
      
        
        }
      
      
        
        bool SeqListIsempty(SeqList* psl)
      
      
        
        {
      
      
        
        

      
      
        
        	DataType i = 0;
      
      
        
        	for (i = 0; i < psl->size; i++)
      
      
        
        	{
      
      
        
        		if (psl->Base[i] != 0)
      
      
        
        		{
      
      
        
        			return false;
      
      
        
        		}
      
      
        
        	}
      
      
        
        	return true;
      
      
        
        }
      
      
        
        bool SeqListIsFull(SeqList* psl)
      
      
        
        {
      
      
        
        	return psl->size >= psl->capacity;
      
      
        
        }
      
      
        
        bool SeqListPushBack(SeqList* psl, DataType x)
      
      
        
        {
        assert(psl!=NULL);
      
      
        
        	if (SeqListIsFull(psl))
      
      
        
        	{
      
      
        
        		printf("顺序表已满,%d不能插入\n", x);
      
      
        
        	}
      
      
        
        	psl->Base[psl->size] = x;
      
      
        
        	psl->size++;
      
      
        
        	return true;
      
      
        
        }
      
      
        
        void SeqList_show(SeqList* psl)
      
      
        
        {
      
      
        
        	DataType i = 0;
      
      
        
        	for (i = 0; i < psl->size; i++)
      
      
        
        	{
      
      
        
        		printf("%d ", psl->Base[i]);
      
      
        
        	}
      
      
        
        	printf("\n");
      
      
        
        }
      
      
        
        bool SeqListPushFront(SeqList* psl, DataType x)
      
      
        
        {
      
      
        
        	DataType i = 0;
      
      
        
        	assert(psl != NULL);
      
      
        
        	if (SeqListIsFull(psl))
      
      
        
        	{
      
      
        
        		printf("顺序表已满 x不能插入\n", x);
      
      
        
        	}
      
      
        
        	for (i = psl->size; i>0; i--)
      
      
        
        	{
      
      
        
        		psl->Base[i] = psl->Base[i-1];
      
      
        
        	}
      
      
        
        	psl->Base[i] = x;
      
      
        
        	psl->size++;
      
      
        
        	return true;
      
      
        
        }
      
      
        
        size_t SeqListLength(SeqList* psl)
      
      
        
        {
      
      
        
        	assert(psl);
      
      
        
        	return psl->size;
      
      
        
        }
      
      
        
        void SeqListclear(SeqList* psl)
      
      
        
        {
        assert(psl);
      
      
        
        	if (SeqListIsempty(psl))
      
      
        
        	{
      
      
        
        		printf("顺序表为空");
      
      
        
        		
      
      
        
        	}
      
      
        
        	else
      
      
        
        	{
      
      
        
        		psl->size = 0;
      
      
        
        	}
      
      
        
        }
      
      
        
        void SeqListSort(SeqList* psl)
      
      
        
        {
      
      
        
        	DataType BegainNumber = 0;
      
      
        
        	DataType LastNumber = 0;
      
      
        
        	DataType tmp = 0;
      
      
        
        	for (BegainNumber = 0; BegainNumber < (psl->size)-1; BegainNumber++)
      
      
        
        	{
      
      
        
        		for (LastNumber = 0; LastNumber < (psl->size) - BegainNumber - 1; LastNumber++)
      
      
        
        		{
      
      
        
        			if (psl->Base[LastNumber]>psl->Base[LastNumber + 1])
      
      
        
        			{
      
      
        
        				tmp = psl->Base[LastNumber];
      
      
        
        				psl->Base[LastNumber] = psl->Base[LastNumber + 1];
      
      
        
        				psl->Base[LastNumber + 1] = tmp;
      
      
        
        			}
      
      
        
        		}
      
      
        
        	}
      
      
        
        }
      
      
        
        void SeqListReverse(SeqList* psl)
      
      
        
        {
      
      
        
        	DataType i = 0;
      
      
        
        	DataType Left = 0;
      
      
        
        	DataType Right = (psl->size) - 1;
      
      
        
        	DataType tmp = 0;
      
      
        
        	while (Left < Right)
      
      
        
        	{
      
      
        
        		tmp = psl->Base[Left];
      
      
        
        		psl->Base[Left] = psl->Base[Right];
      
      
        
        		psl->Base[Right] = tmp;
      
      
        
        		Left++;
      
      
        
        		Right--;
      
      
        
        	}
      
      
        
        }
        bool SeqListModiftByPos(SeqList* psl, int pos, DataType item)
      
      
        
        {
      
      
        
        	assert(psl != NULL);
      
      
        
        	if (SeqListIsempty(psl))
      
      
        
        	{
      
      
        
        		return false;
      
      
        
        	}
      
      
        
        	if (pos<0 || pos>psl->size - 1)
      
      
        
        	{
      
      
        
        		printf("输入的位置不合法\n");
      
      
        
        		return false;
      
      
        
        	}
      
      
        
        	psl->Base[pos] = item;
      
      
        
        	return true;
      
      
        
        }
      
      
        
        void ModifyByValue(SeqList* psl,int val,int x)
      
      
        
        {
      
      
        
        	DataType i = 0;
      
      
        
        	while (psl != NULL&& psl->Base[i] != val)
      
      
        
        	{
      
      
        
        		i++;
      
      
        
        	}
      
      
        
        	psl->Base[i] = x;
      
      
        
        }
      
      
        
        int FindByPos(SeqList* psl, int pos,DataType* ret)
      
      
        
        {
      
      
        
        	if (pos<0 || pos>psl->size)
      
      
        
        	{
        	printf("输入的位置不合法>");
      
      
        
        		return 0;
      
      
        
        	}
      
      
        
        	*ret = psl->Base[pos];
      
      
        
        	return *ret;
      
      
        
        }
      
      
        
        int FindByVal(SeqList* psl, int val, DataType* ret)
      
      
        
        {
      
      
        
        	DataType i = 0;
      
      
        
        	while (psl != NULL && psl->Base[i] != val&&i<psl->size)
      
      
        
        	{
      
      
        
        		i++;
      
      
        
        	}
      
      
        
        	if (i < psl->size)
      
      
        
        	{
      
      
        
        		*ret = psl->Base[i];
      
      
        
        		return *ret;
      
      
        
        	}
      
      
        
        	return -1;
      
      
        
        }
      
      
        
        bool Pop_back(SeqList* psl)
      
      
        
        {
      
      
        
        	DataType i = 0;
      
      
        
        	if (psl->size == 0)
      
      
        
        	{
      
      
        
        		printf("顺序表为空，不能删除>");
      
      
        
        		return false;
        		psl->size--;
      
      
        
        	return true;
      
      
        
        }
      
      
        
        bool Pop_Front(SeqList* psl)
      
      
        
        {
      
      
        
        	int i = 0;
      
      
        
        	if (SeqListIsempty(psl))
      
      
        
        	{
      
      
        
        		printf("顺序表为空，不能头删>");
      
      
        
        		return false;
      
      
        
        	}
      
      
        
        		for (i = 0; i <psl->size-1; i++)
      
      
        
        		psl->Base[i] = psl->Base[i + 1];
      
      
        
        		psl->size--;
      
      
        
        	return true;
      
      
        
        }
      
      
        
        void Destort_Seqlist(SeqList* psl)
      
      
        
        {
      
      
        
        	free(psl->Base);
      
      
        
        	psl->Base = NULL;
      
      
        
        	psl->capacity = psl->size = 0;
      
      
        
        }
      
      
        
        	}
半夏丶ExAg3r
关注
专栏目录
顺序表（动态）
L_R
09-13 385
上篇博客介绍了静态顺序表的增删查改以及排序，我们知道了: 静态顺序表的长度是固定的，但是如果我们在使用顺序表是并不知道顺序表的长度，或者在使用过程中，顺序表的长度不够了，难道我们要重新再创建一个新的顺序表吗？这样显然是很麻烦的。所以本篇博客将讨论动态顺序表。 那么动态顺序表和静态顺序表又有什么区别呢？ 上面我们提到了静态顺序表的局限性，那么动态顺序表很有效的解决了静态的不足之处，当在使用顺序...
数据结构之顺序表和链表
lang_965的博客
08-10 1424
本文用通俗易懂的方式详细讲解了顺序表和链表，是数据结构的精品讲解内容，适合大学在校生和自学的社会人士使用。
数据结构顺序表的基本功能的实现
01-03
数据结构课程顺序表的基本功能实现，包括顺序表的创建、插入、删除元素等。
顺序表静态与动态实现及基本的操作（增删查改等）
博客
12-12 660
//seqlist.h #define _CRT_SECURE_NO_WARNINGS 1 #ifndef _SEQLIST_ #define _SEQLIST_ #define MAX_SIZE 8 typedef int Datatype; typedef struct seqlist//静态顺序表的声明 { Datatype array[MAX_SIZE]; unsigned
顺序表的动态增长
_ACME_的博客
01-31 949
其实这个实现起来不难，现在来分析一下。首先一开始先分配一块固定大小的内存空间，当这块空间用完之后，然后就需要另一块更大的空间来存放数据。所以思路就是当空间用完之后，再分配一块比原来大的空间来存放数据。C++代码下载 JAVA代码下载步骤如下： 1、创建一块临时存放原始数据的内存块 2、将原始数据复制过去 3、释放存放原始数据的空间 4、重新分配一块新的内存块，其大小为原来的两倍（至少比
数据结构 顺序表及其功能的实现
flf1234567898的博客
10-18 259
小编在正式讲解知识的时候不得不吐槽一下这个C语言的链表了，真的还是很有难度的，在开始链表之前还是先来看下顺序表吧。一起来看 首先我们要了解顺序表是一种线性的存储结构，这就够了。。。。 什么是表？就是多个成员构成的具有一定联系的集合，表中最重要的是具有一定的集合，还要注意各自之间的联系。 首先看到成员，我们不得不联想到C语言的结构体，在结构体里面定义成员，我们使用的表具有某种联系，而且都是相同类型，...
【数据结构实现】C语言实现顺序表
03-06
内容概要：线性表是一种相当灵活的数据结构，其长度可以根据需要增长或缩短，对线性表的数据元素不仅可以进行访问，还可以进行插入和删除等操作。本次试验用C语言实现顺序表，实现 Init 初始化线性表 Destory 销毁...
数据结构-时间复杂度的计算和顺序表基本运算实现
06-05
任务二是实现顺序表的基本操作，顺序表是一种线性数据结构，所有元素存储在一块连续的内存区域中。以下是实现这些操作的函数框架： 1. `InitList(SqList *&L)`：初始化顺序表，分配内存并设置长度为0。 2. `...
【C数据结构】顺序表的基本操作
最新发布
winkxw的博客
03-18 1829
【数据结构】顺序表的基本操作（C语言实现）
C语言实现顺序表基本操作汇总
09-04
顺序表是一种在计算机科学中常见的数据结构，它将一组元素存储在一块连续的内存区域中。这种结构允许快速访问元素，因为可以通过索引来直接定位元素。本文将深入讨论如何使用C语言来实现顺序表的基本操作，包括初始...
顺序表(二)----可动态增长的顺序表的实现
qq_41052753的博客
05-13 217
可实现的功能与固定长度的顺序表相同 优点,可以扩充空间防止越界 //不定长顺序表 #pragma once #define INITSIZE 10 typedef struct DSeqList { int *elem;//保存动态内存的地址,用于存放数据 int length;//有效数据个数 int listsize;//总单元个数 }DSeqList,*PDSeqList; //...
数据结构（一）线性表（顺序表实现的功能)
红叶的博客
08-02 590
头文件 #ifndef SEQUENCELIST_H #define SEQUENCELIST_H //必须和上面的一模一样，而且是大写 #include<stdio.h> #include<stdlib.h> #include<time.h> //用到的头文件 #define SIZE 10 #define SUCCESS 10000...
数据结构—顺序表的基本功能实现
qq_42932834的博客
06-05 1506
顺序表的基本功能实现 线性表是数据结构的基础结构。数据结构+算法=程序，今天结束了C++的书本自学，扎进数据结构和算法的世界里。 线性表分为顺序存储，链式存储，索引存储，散列存储等。 顺序存储即顺序表，链式存储即链表。 关于数据结构，最重要的是会画图，明白逻辑结构和物理结构。不急不燥，代码不是一气呵成的，需要长久的练习和耐心。 下面是顺序表的实现代码： #include <iostrea...
【数据结构入门】顺序表
weixin_69479577的博客
11-25 210
数据结构初阶---->顺序表的增删查改
【数据结构】实现顺序表的增删查改
m0_51064412的博客
03-01 905
文章目录一.顺序表介绍二.动态顺序表增删查功能实现三.完整代码四.动态顺序表总结 一.顺序表介绍 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。顺序表可分为静态顺序表和动态顺序表。 (1)静态顺序表：使用定长数组存储，适用于确定知道需要存多少数据的场景 #define N 100 typedef int SeqListDataType; typedef struct SeqList { SLDataType array[N]; // 定长
【Vue】elementUI实现动态表单功能（实现表格的增加行、删除行的功能）
zzf_forgot的博客
01-20 6636
需求：当需要给用户填写表格时，并且用户填写行数未知，会需要使用到动态表单功能，这个和通常的写死form表单不同，如下图所示： 实现： 1）前端代码如下图所示：采用el-form嵌套el-table的方法，整体结构如下图所示： <el-form :model="instance.items" ref="data" label-width="auto"> <el-table :data="instance.items.filter((dat
数据结构：顺序表实现增删查改基本功能
weixin_53472920的博客
09-12 3227
顺序表实现增删查改基本功能
动态顺序表的实现
编程入门指南
05-25 1584
动态顺序表顺序表基本概念顺序表基本数据结构用数组表示用指针表示线性表基本操作初始化动态分配内存插入元素删除元素完整的测试用例 顺序表基本概念 顺序表是用一组连输地址实现的线性表,其优点是可以随机访问表中元素和修改指定位置元素比较简单,但插入和删除元素需要移动元素,表长扩展也比较麻烦. 顺序表基本数据结构 用数组表示 typedef struct{ ElenType data[MaxSize]...
数据结构之顺序表的增删查改等操作详解
小赵小赵福星高照的博客
08-03 2159
顺序表的增删查改 文章目录顺序表的增删查改顺序表静态顺序表：使用定长数组存储元素动态顺序表：使用动态开辟的数组存储顺序表的初始化顺序表的销毁打印顺序表数据顺序表尾插数据顺序表头插数据顺序表头删数据顺序表指定位置插入元素指定位置元素删除返回顺序表总数据的个数修改数据三个文件的源代码：SeqList.h(头文件的包含以及顺序表结构以及函数的声明)SeqList.c(顺序表操作函数的定义)test.c(顺序表操作的测试) 顺序表 一段物理地址连续的存储单元依次存储数据元素的线性结构，其实就是数组，要求存储的数
C语言动态顺序表实现详解及代码
在编程领域，动态顺序表是一种常见的数据结构，它在内存中分配一块可变大小的空间来存储数据，能够随着数据量的增长自动进行扩容。与静态顺序表不同，静态顺序表的大小在编译时就已经确定，而动态顺序表允许在运行时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值