顺序表基本实现（非扩容方法）

最新推荐文章于 2024-08-10 18:31:58 发布
最新推荐文章于 2024-08-10 18:31:58 发布
阅读量84 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ghost_199503/article/details/121056333
版权

顺序表

首先，我们来定义一个顺序表结构，其中包含两个部分：

  1. 顺序表申请的存储容量
  2. 当前使用顺序表的长度
    按照以上两点，我们定义顺序表结构如下：
#define MAX_SIZE 100     /* 定义顺序表的大小 */

typedef struct List{
	int date[MAX_SIZE];  /* 申请存储容量 */
	unsigned int length; /* 当前使用顺序表的长度 */
}List;

顺序表的常用操作接口如下：

#include <stdio.h>
#include <stdbool.h>
#include <string.h>

#define MAX_SIZE 100     /* 定义顺序表的大小 */

typedef struct List {
	int date[MAX_SIZE];  /* 申请存储容量 */
	unsigned int length; /* 当前使用顺序表的长度 */
}List;

#define LI_IS_NULL(li) \
{ \
	if ((li == NULL)) { \
		printf("%s:li is null or index is large!\n",__FUNCTION__); \
		return -1; \
	} \
} 

#define LI_IS_FULL(li) \
{ \
	if (listIsFull(li)) { \
		printf("%s:list is full\n", __FUNCTION__); \
		return -1; \
	} \
}

#define LI_IS_EMPTY(li) \
{ \
	if (listIsEmpty(li)) { \
		printf("%s:list is empty\n", __FUNCTION__); \
		return -1; \
	} \
}

#define INDEX_IS_LARGE(index,li) \
{ \
	if (index > (li->length - 1)) { \
			printf("%s:index is large!\n",__FUNCTION__); \
			return -1; \
	} \
}

/* 初始化一个顺序表 */
int initList(List *li)
{
	LI_IS_NULL(li);
	memset(li->date, 0, MAX_SIZE);
	li->length = 0;
	
	return 0;
}
/* 判断是否是空顺序表 */
bool listIsEmpty(List *li)
{
	if (li == NULL) {
		printf("%s:li is null!\n",__FUNCTION__);
		return false;
	}
	
	return (li->length == 0)?true:false;
}
/* 判断是否是满顺序表 */
bool listIsFull(List *li)
{
	if (li == NULL) {
		printf("%s:li is null!\n",__FUNCTION__);
		return false;
	}
	
	return (li->length == MAX_SIZE)?true:false;
}
/* 获取顺序表的存储大小 */
int getListSize(List *li)
{
	if (li == NULL) {
		printf("%s:li is null!\n",__FUNCTION__);
		return -1;
	}
	
	return (sizeof(li->date)/sizeof(li->date[0]));
}
/* 获取顺序表的已使用大小 */
int getListLength(List *li)
{
	if (li == NULL) {
		printf("%s:li is null!\n",__FUNCTION__);
		return -1;
	}
	
	return li->length;
}
/* 顺序表中指定位置插入元素 */
int insertList(List *li, unsigned int index, int date)
{
	LI_IS_NULL(li);
	LI_IS_FULL(li);
	INDEX_IS_LARGE(index, li);
	
	int i = li->length;
	for (i;i > index;i--) {
		li->date[i] = li->date[i-1];
	}
	li->date[i] = date;
	li->length++;
	
	return 0;
}
/* 顺序表中头部插入元素 */
int insertListFromHead(List *li, int date)
{
	LI_IS_NULL(li);
	LI_IS_FULL(li);
	
	int i = li->length;
	for (i;i > 0;i--) {
		li->date[i] = li->date[i-1];
	}
	li->date[i] = date;
	li->length++;
	
	return 0;	
}
/* 顺序表中尾部插入元素 */
int insertListFromTail(List *li, int date)
{
	LI_IS_NULL(li);
	LI_IS_FULL(li);
	
	li->date[li->length] = date;
	li->length++;	

	return 0;
}
/* 顺序表中删除指定元素 */
int delListFromDate(List *li,int date)
{
	LI_IS_NULL(li);
	LI_IS_EMPTY(li);
	
	int i = 0;
	int flag = 0;
	for (i = 0;i < li->length;i++) {
		if (li->date[i] == date) {
			for (int j = i;j < li->length;j++) {
				li->date[j] = li->date[j+1];
			}
			li->length--;
			flag++;
		}
	}
	if (flag == 0) {
		printf("no find date %d\n", date);
	}
	return 0;
}
/* 顺序表中删除指定元素(删除N个) */
int delListFromDateN(List *li,int date, unsigned int n)
{
	LI_IS_NULL(li);
	LI_IS_EMPTY(li);
	
	int i = 0;
	int count = 0;
	for (i = 0;i < li->length;i++) {
		if (li->date[i] == date) {
			for (int j = i;j < li->length;j++) {
				li->date[j] = li->date[j+1];
			}
			li->length--;
			count++;
		}
		
		if (count == n) {
				printf("delete done!\n");
				return 0;
		}
	}
	
	printf("only find %d\n", count);

	return 0;	
}
/* 顺序表中删除指定位置元素 */
int delListFromIndex(List *li, unsigned int index)
{
	LI_IS_NULL(li);
	INDEX_IS_LARGE(index, li);
	LI_IS_EMPTY(li);
	
	int i = 0;
	for (i = index;i < li->length - 1;i++) {
		li->date[i] = li->date[i+1];
	}
	li->length--;

	return 0;	
}
/* 顺序表中头部删除元素 */
int delListFromHead(List *li)
{
	LI_IS_NULL(li);
	LI_IS_EMPTY(li);
	
	int i = 0;
	for (i = 0;i < li->length - 1;i++) {
		li->date[i] = li->date[i+1];
	}
	li->length--;
	
	return 0;
}
/* 顺序表中尾部删除元素 */
int delListFromTail(List *li)
{
	LI_IS_NULL(li);
	LI_IS_EMPTY(li);

	li->length--;
	
	return 0;
}
/* 顺序表中修改指定元素 */
int modifyList(List *li,int oldDate, int newDate)
{
	LI_IS_NULL(li);
	LI_IS_EMPTY(li);
	
	int i = 0;
	int flag = 0;
	for (i = 0;i < li->length;i++) {
		if (li->date[i] == oldDate) {
			li->date[i] = newDate;
			flag++;
		}
	}
	
	if (flag == 0) {
		printf("modify filed,no find %d\n", oldDate);
	}
	return 0;
}
/* 顺序表中修改指定位置元素 */
int modifyListForIndex(List *li, unsigned int index, int newDate)
{
	LI_IS_NULL(li);
	INDEX_IS_LARGE(index, li);
	LI_IS_EMPTY(li);
	
	li->date[index] = newDate;
	
	return 0;	
}
/* 顺序表中查找指定元素首次出现的位置 */
int findDateInListFrist(List *li, int date)
{
	LI_IS_NULL(li);
	LI_IS_EMPTY(li);
	
	int i = 0;
	for (i = 0;i < li->length;i++) {
		if (li->date[i] == date) {
			return i;
		}
	}
	
	printf("not find ！\n");
	return -1;
}
/* 顺序表中查找指定元素所有出现的位置 */
int findDateInListAll(List *li, int date, unsigned int *locations)
{
	LI_IS_NULL(li);
	LI_IS_EMPTY(li);
	if (locations == NULL) {
		printf("%s:locations is null\n", __FUNCTION__);
	}
	
	int i;
	int j = 0;
	for (i = 0;i < li->length;i++) {
		if (li->date[i] == date) {
			locations[j] = i;
			j++;
		}
	}
	if (j == 0) {
		printf("not find ！\n");
	}
	
	return 0;	
}
/* 顺序表中查找指定元素出现的次数 */
unsigned int findDateInListSum(List *li, int date)
{	
	LI_IS_NULL(li);
	LI_IS_EMPTY(li);
	
	int i;
	int count = 0;
	for (i = 0;i < li->length;i++) {
		if (li->date[i] == date) {
			count++;
		}
	}
	if (count == 0) {
		printf("not find ！\n");
		return -1;
	}
	
	return count;
}
/* 顺序表中遍历元素 */
int showList(List *li)
{
	LI_IS_NULL(li);
	LI_IS_EMPTY(li);
	
	int i;
	for (i = 0;i < li->length;i++) {
		printf("date[%d] = %d ", i, li->date[i]);
	}
	printf("\n");

	return 0;
}

int main()
{
	List li;
	int locations[MAX_SIZE] = {0};
	printf("初始化：\n");
	initList(&li);
	printf("判断是否是满顺序表");
	if(listIsFull(&li)) {
		printf("li is full!\n");
	} else {
		printf("li is not full!\n");
	}
	printf("判断是否是空顺序表");
	if(listIsEmpty(&li)) {
		printf("li is empty!\n");
	} else {
		printf("li is not empty!\n");
	}
	printf("使用头插法插入1,2,3\n");
	insertListFromHead(&li,1);
	insertListFromHead(&li,2);
	insertListFromHead(&li,3);
	showList(&li);
	printf("顺序表容量：%d\n", getListSize(&li));
	printf("顺序表已使用大小：%d\n", getListLength(&li));
	printf("使用尾插法插入4,5,6\n");
	insertListFromTail(&li,4);
	insertListFromTail(&li,5);
	insertListFromTail(&li,6);
	printf("使用尾插法插入3,4,5\n");
	insertListFromTail(&li,3);
	insertListFromTail(&li,4);
	insertListFromTail(&li,5);
	showList(&li);
	printf("在下标为2的位置插入数据6\n");
	insertList(&li, 2, 6);
	showList(&li);
	printf("删除表中的3\n");
	delListFromDate(&li, 3);
	showList(&li);
	printf("删除表中的7\n");
	delListFromDate(&li, 7);
	showList(&li);
	printf("删除表中的两个2\n");
	delListFromDateN(&li, 2, 2);
	showList(&li);
	printf("删除表中的下标为3的数据\n");
	delListFromIndex(&li, 3);
	showList(&li);
	printf("删除表头一个数据\n");
	delListFromHead(&li);
	showList(&li);
	printf("删除表尾一个数据\n");
	delListFromTail(&li);
	showList(&li);
	printf("修改表中的2为8\n");
	modifyList(&li, 2, 8);
	showList(&li);
	printf("修改表中下标1的数据为9\n");
	modifyListForIndex(&li, 1, 9);
	showList(&li);
	printf("查找数据4首次出现的位置\n");
	printf("首次出现的下标为：%d", findDateInListFrist(&li, 4));
	printf("查找数据4出现的次数\n");
	int count = findDateInListSum(&li, 4);
	printf("首次出现的下标为：%d", count);
	printf("查找数据4出现的所有位置\n");
	findDateInListAll(&li, 4, locations);
	for(int i = 0;i < count;i++) {
		printf("locations[%d] = %d\n", i, locations[i]);
	}
	
	return 0;
}

持续更新，关注公众号
在这里插入图片描述

Ghost_199503
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java 实现顺序表的基本操作
近未来
06-08 7267
顺序表 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储。 接口 package com.github.sqlist; public interface ISequence { // 在 pos 位置插入 val boolean add(int pos, Object data); // 查找关键字 key 找到返回 key 的下表，没有返回 -1 ...
C语言实现动态顺序表的实现代码
08-29
本文主要介绍了C语言实现动态顺序表的实现代码，动态顺序表是指在内存中开辟一块空间，可以随我们数据数量的增多来扩容的线性表。下面将详细介绍动态顺序表的实现代码。 一、顺序表的基本概念 顺序表是在计算机...
数据结构 - 顺序表及其基本操作的实现
Nonpc的博客
03-31 2363
线性表的顺序存储结构 顺序表定义 线性表的顺序存储结构, 指的是用一段地址连续的存储单元依次存储线性表的数据元素. 线性表的(a1,a2,…,an)的顺序存储示意图如下: 顺序表的存储方式         线性表的顺序存储结构,就是在内存中找一块地方,通过占位的形式,把一定的空间占用,然后把相同数据类型的数据元素依次...
动态顺序表（可扩容）的基本操作
fern_girl的博客
04-24 1452
头文件：#define _CRT_SECURE_NO_WARNINGS 1 #ifndef _STATICSEQLIST_H__ #define _STATICSEQLIST_H__#include<stddef.h> #include<assert.h> #include<string.h> #include<stdlib.h> #include<stdio.h>#define MAXSIZE 1
顺序表的基本操作（及动态扩容）
qq_40692598的博客
11-02 2202
顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。顺序表的存储特点是：只要确定了起始位置...
数据结构-顺序表基本功能的实现
qq_61167424的博客
03-23 2703
详细的基本功能实现（顺序表其实一点也不难）
数据结构：顺序表实现增删查改基本功能
weixin_53472920的博客
09-12 2321
顺序表实现增删查改基本功能
【数据结构趣味多】顺序表基本操作实现（Java）
努力
12-02 1965
用java对顺序表的实现
【Java 数据结构】顺序表
程序猿教你打篮球的博客
11-01 3768
本期主要讲解： 1、什么是顺序表？ 2、模拟实现ArrayList 2.1 模拟实现前的约定 2.2构造方法 2.3 add方法 2.4 contains 方法 2.5 indexOf 方法 2.6 get 方法 2.7 set 方法 2.8 remove 方法 2.9 getSize 和 clear 方法 3、ArrayList 的学习 3.1 ArrayList的成员属性 3.2 ArrayList的构造方法 4、ArrayList的使用 4.1 ArrayList的遍历 4.2 扑克牌例子
Hashmap实现原理及扩容机制详解
热门推荐
lkforce
04-25 11万+
目录 HashMap基础 HashMap实现原理 Node和Node链 拉链法 关于Node数组 table 散列算法 HashMap和红黑树 关于TreeNode 红黑树基础 HashMap扩容机制 JDK1.7下的扩容机制 JDK1.8下的扩容机制 HashMap基础 HashMap继承了AbstractMap类，实现了Map，Cloneable，Serializa...
【数据结构】顺序表实现超详解（保姆级教程）
~
10-15 2205
目录 ​ 前言 顺序表 接口实现 各项功能 接口详解 顺序表初始化 顺序表释放 顺序表展示 顺序表容量检查 顺序表数据尾插 顺序表数据头插 顺序表数据前删 顺序表数据尾删 顺序表数据查找 顺序表指定位置插入数据 顺序表指定位置删除数据 前言 本章主要讲解： 顺序表以及顺序表的接口实现 注：保姆级教程，相信你一定会的~ 顺序表 顺序表是线性标的一种 概念： 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储...
顺序表的基本操作.rar
03-16
如果顺序表已满，需要进行扩容操作，通常是翻倍当前容量。插入操作的时间复杂度在最坏情况下为O(n)。 3. **删除操作**：从顺序表中删除一个元素，需要将之后的所有元素向前移动一位以填补空位。删除操作的时间...
顺序表测试1_WordforWord_用顺序表实现词频统计_
10-03
5. **动态扩容**：为了适应不同数量的单词，顺序表可能需要动态扩容。当表满时，创建一个新的、更大的数组，并将旧数组中的元素复制过去。C语言中可以使用`realloc()`函数实现。 6. **排序与输出**：在统计完所有...
实验一 顺序表基本操作的实现
12-18
在本实验“实验一 顺序表基本操作的实现”中，我们将深入探讨数据结构的核心概念——顺序表。数据结构是计算机科学中一个至关重要的领域，它研究如何有效地组织和存储数据，以便进行高效的检索、更新和删除等操作。...
顺序表的实现
04-21
4. **插入操作**：插入操作在顺序表中需要找到合适的位置插入新元素，如果表满，则需要进行扩容操作。扩容通常通过创建一个更大的新数组，将旧数组中的元素复制过来，然后插入新元素并释放旧数组来实现。 5. **查找...
【数据结构初阶】队列
最新发布
稻草人
08-10 959
1、概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有的特性。进行插入操作的一端称为进行删除操作的一端称为队列也可以数组和链表的结构实现，使⽤链表的结构实现更优⼀些，因为如果使⽤数组的结构，出队列在数组头上出数据，效率会比较低。
数据结构----链表
2301_80339238的博客
08-06 1060
在计算机科学中，链表是数据元素的线性集合，其每个元素都指向下一个元素，元素存储上并不连续。这与我们所认识的数组有相同之处，二者都是线性集合，但是数组在元素存储上是连续的。
常见8种数据结构
qq_43575301的博客
08-08 1299
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
基础算法模板
2301_79235379的博客
08-08 328
欢迎订阅专栏，数据结构实验，期末大作业，前端后端，算法都有哦，想我发哪个方面的资源或文章可以私信我，免费的哦。
Python实现顺序表基本操作
本资源提供了使用Python实现顺序表基本操作的代码，包括创建、插入、删除、访问和遍历元素。" 顺序表是计算机科学中常用的一种数据结构，它以数组为基础，数组中的每个元素都有一个唯一的索引，索引从0开始。在这个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Ghost_199503

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值