数据结构----增删改查（静态顺序表、动态顺序表）

最新推荐文章于 2024-04-07 19:48:52 发布
最新推荐文章于 2024-04-07 19:48:52 发布
阅读量378 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 链表 增删改查
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Z_JUAN1/article/details/80749333
版权

静态顺序表实现增删改查的所有代码~

#pragma once

#include <stdlib.h>
#include <assert.h>
#include <string.h>
#include <stdio.h>

typedef int DataType;
#define MAX_SIZE	(100)

typedef struct SeqList {
	DataType array[MAX_SIZE];	// 存数据的空间
	int size;		// 1) 有效数据有多少个 2) 当前可用的数组下标
}	SeqList;

// 初始化
void SeqListInit(SeqList *pSL)
{
	// 内容初始化（不必要）
	// size = 0
	assert(pSL != NULL);

	//memset(pSL->array, 0, MAX_SIZE * sizeof(DataType));
	pSL->size = 0;
}
// 销毁
void SeqListDestroy(SeqList *pSL)
{
	assert(pSL != NULL);
	pSL->size = 0;
}

// 尾插
void SeqListPushBack(SeqList *pSL, DataType data)
{
	assert(pSL != NULL);
	assert(pSL->size < MAX_SIZE);

	pSL->array[pSL->size] = data;
	pSL->size++;
}


// 头插
void SeqListPushFront(SeqList *pSL, DataType data)
{
	assert(pSL != NULL);
	assert(pSL->size < MAX_SIZE);

	//将已有数据往后搬移一格
	// 1. 以条件写循环
#if 0
	//	1.1 以要搬移的数做循环的指示
	int pos;
	for (pos = pSL->size - 1; pos >= 0; pos--) {
		pSL->array[pos + 1] = pSL->array[pos];
	}
#endif

#if 0
	//	1.2	以要搬到的位置做循环的指示
	int space;
	for (space = pSL->size; space > 0; space--) {
		pSL->array[space] = pSL->array[space - 1];
	}
#endif

#if 3
	//	2. 以循环次数做指示
	int i;
	for (i = 0; i < pSL->size; i++) {
		// 关键把计数的 i 转成 数 和 位置的下标
		pSL->array[pSL->size - i] = pSL->array[pSL->size - 1 - i];
	}
#endif

	pSL->array[0] = data;
	pSL->size++;
}


// 根据下标插入
void SeqListInsert(SeqList *pSL, int pos, DataType data)
{
	assert(pSL != NULL);
	assert(pSL->size < MAX_SIZE);
	assert(pos >= 0 && pos <= pSL->size);

	// 把 [pos, size) 数据往后搬一格
	int space;
	for (space = pSL->size; space > pos; space--) {
		pSL->array[space] = pSL->array[space - 1];
	}

	pSL->array[pos] = data;
	pSL->size++;
}

// 尾删
void SeqListPopBack(SeqList *pSL)
{
	assert(pSL != NULL);
	assert(pSL->size > 0);

	pSL->size--;
}

// 头删
void SeqListPopFront(SeqList *pSL)
{
	assert(pSL != NULL);
	assert(pSL->size > 0);

	// 把 [1, pSL->size) 的数据往前搬移一格
	int pos;
	for (pos = 1; pos < pSL->size; pos++) {
		pSL->array[pos - 1] = pSL->array[pos];
	}
	pSL->size--;
}

// 根据下标删除
void SeqListErase(SeqList *pSL, int pos)
{
	assert(pSL != NULL);
	assert(pSL->size > 0);
	assert(pos >= 0 && pos < pSL->size);

#if 0
	// 以 要搬运到的位置下标作为循环指示
	int space;	// 要搬运到的位置下标
	for (space = pos; space < pSL->size - 1; space++) {
		pSL->array[space] = pSL->array[space + 1];
	}
#endif

#if 1
	// 以 要搬运的数据下标作为循#环指示
	int p;	// 要搬运的数据下标
	for (p = pos + 1; p < pSL->size; p++) {
		pSL->array[p - 1] = pSL->array[p];
	}
#endif

	pSL->size--;
}



// 根据数据删除，只删除遇到的第一个
void SeqListRemove(SeqList *pSL, DataType data)
{
	int pos = SeqListFind(pSL, data);
	if (pos != -1) {
		// 如果找到了
		SeqListErase(pSL, pos);
	}
}

// 根据数据删除，删除所有遇到的
void SeqListRemoveAll(SeqList *pSL, DataType data)
{


#if 0	// 为啥不好，时间复杂度 #
	int pos;

#if 0
	while (1) {
		pos = SeqListFind(pSL, data);
		if (pos == -1) {
			break;
		}

		SeqListErase(pSL, pos);
	}
#endif

	while ((pos = SeqListFind(pSL, data)) != -1) {
		SeqListErase(pSL, pos);
	}

	/*
	while (size) {
	while (size) {
	}
	}
	*/
#endif

#if 0
	DataType *newArray = (DataType *)malloc(sizeof(DataType)* pSL->size);
	assert(newArray);

	int i, j, k;

	for (i = 0, j = 0; i < pSL->size; i++) {
		if (pSL->array[i] != data) {
			newArray[j] = pSL->array[i];
			j++;
		}
	}

	pSL->size = j;

	// 把数据从 newArray 放回到 array
	for (k = 0; k < pSL->size; k++) {
		pSL->array[k] = newArray[k];
	}

	free(newArray);
#endif

	int i, j;

	for (i = 0, j = 0; i < pSL->size; i++) {
		if (pSL->array[i] != data) {
			pSL->array[j] = pSL->array[i];
			j++;
		}
	}

	pSL->size = j;
}

// 根据下标更新
void SeqListUpdate(SeqList *pSL, int pos, DataType data)
{
	assert(pSL != 0);
	assert(pos >= 0 && pos < pSL->size);

	pSL->array[pos] = data;
}

// 查询
// 返回遇到的第一个下标，如果没有遇到，返回 -1
int SeqListFind(SeqList *pSL, DataType data)
{
	assert(pSL != 0);
	int i;

	for (i = 0; i < pSL->size; i++) {
		if (pSL->array[i] == data) {
			return i;
		}
	}

	// 没找到
	return -1;
}

void Swap(DataType *a, DataType *b)
{
	DataType t = *a;
	*a = *b;
	*b = t;
}

void SelectOP(SeqList *pSL)
{
	/*
	minSpace 用来放找到的最小的数的下标
	maxSpace 用来放找到的最大的数的下标

	minIndex 整个数列中（[minSpace,maxSpace])找到的最小数的下标
	maxIndex 整个数列中（[minSpace,maxSpace])找到的最大数的下标
	*/
	int minSpace = 0;
	int maxSpace = pSL->size - 1;
	int i;
	int minIndex, maxIndex;

	while (minSpace < maxSpace) {
		minIndex = minSpace;
		maxIndex = minSpace;

		for (i = minSpace; i <= maxSpace; i++) {
			// 遍历 [minSpace, maxSpace]，找到最小数的下标，找到最大数的下标

			if (pSL->array[i] < pSL->array[minIndex]) {
				minIndex = i;
			}

			if (pSL->array[i] > pSL->array[maxIndex]) {
				maxIndex = i;
			}
		}

		// 到这里后，minIndex 就是找到的最小数的下标
		// 到这里后，maxIndex 就是找到的最大数的下标
		Swap(pSL->array + minIndex, pSL->array + minSpace);
		if (minSpace == maxIndex) {
			// 特殊情况处理，例如	9	1	7	3	2
			maxIndex = minIndex;
		}
		Swap(pSL->array + maxIndex, pSL->array + maxSpace);

		minSpace++;
		maxSpace--;
	}
}

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

void TestSeqList()
{
	SeqList sl;
	SeqListInit(&sl);

	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPushBack(&sl, 3);

	SeqListRemoveAll(&sl, 3);

	SeqListPrint(&sl);

	

	/*SeqListPrint(&sl);

	SeqListDestroy(&sl);*/
}

动态顺序增删改查的所有代码~

#pragma once

#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#define CAPACITY (2)
typedef int DataType;

typedef struct SeqListDynamic {
	DataType	*array;
	int			capacity;
	int			size;
}SeqListD;
//初始化
void SeqListDInit(SeqListD *pSLD)
{
	assert(pSLD != NULL);
	pSLD->capacity = CAPACITY;
	pSLD->size = 0;
	pSLD->array = (DataType *)malloc(pSLD->capacity * sizeof(DataType));//堆上
	assert(pSLD->array != NULL);
}
//销毁
void SeqListDDestroy(SeqListD * pSLD)
{
	assert(pSLD != NULL);
	pSLD->size = 0;
	//关键步骤
	free(pSLD->array);
	pSLD->capacity = 0;
}
void ExpandifRequired(SeqListD *pSLD)
{
	if (pSLD->size < pSLD->capacity)
	{
		return;
	}
	//肯定空间不够
	//1.容量变大
	//2.开辟空间
	//3.将老数据写进新空间
	//4.释放老空间
	//5.将新空间挂起
	//realloc
	//伙伴算法

	pSLD->capacity *= 2;
	DataType *NewArray = (DataType *)malloc(sizeof(DataType)*pSLD->capacity);
	int i;
	for (i = 0; i < pSLD->size; i++)
	{
		NewArray[i] = pSLD->array[i];
	}
	free(pSLD->array);
	pSLD->array = NewArray;
}
void SeqListDPushBack(SeqListD *pSLD, DataType data)
{
	assert(pSLD != NULL);
	//这是静态的处理过程
	//assert(pSLD->size<pSLD->capacity)
	
	//函数自己去判断，有必要就扩容
	ExpandifRequired(pSLD);

	//到这里就是容量肯定够了
	pSLD->array[pSLD->size++] = data;

}
//头插
void SeqListDPushFront(SeqListD *pSLD, DataType data)
{
	assert(pSLD != NULL);
	ExpandifRequired(pSLD);
	int space;
	for (space = pSLD->size; space > 0; space--)
	{
		pSLD->array[space]=pSLD->array[space - 1];
	}
	pSLD->array[space]= data;
	pSLD->size++;
}
void charu(SeqListD *pSLD, int pos, DataType data)
{
	int space;
	for (space = pSLD->size; space > pos; space--)
	{
		pSLD->array[space] = pSLD->array[space - 1];
	}
	pSLD->array[pos] = data;
	pSLD->size++;
}

//按下标插
void SeqListDInsert(SeqListD *pSLD,int pos, DataType data)
{
	assert(pSLD != NULL);
	assert(pos >= 0 && pos <= pSLD->size);

	ExpandifRequired(pSLD);
	charu(pSLD,pos,data);

	/*int space;
	for (space = pSLD->size; space > pos; space--)
	{
		pSLD->array[space] = pSLD->array[space - 1];
	}
	pSLD->array[pos]=data;
	pSLD->size++;*/
}

//打印
void SeqListDPrint(SeqListD *pSLD)
{
	int i;
	for (i = 0; i < pSLD->size; i++)
	{
		printf("%d  ", pSLD->array[i]);
	}
}
void TestSeqListD()
{
	SeqListD sld;
	SeqListDInit(&sld);//初始化

	SeqListDPushBack(&sld,2);//尾插
	SeqListDPushBack(&sld, 3);
	SeqListDPushBack(&sld, 4);
	SeqListDPushFront(&sld, 12);//头插

	SeqListDInsert(&sld, 13, 2);//下标插
	
	SeqListDPrint(&sld);
	SeqListDDestroy(&sld);//销毁
}

Z_JUAN1
关注
专栏目录
数据结构-顺序表的增删改查
weixin_47750507的博客
07-11 313
数据结构顺序表的增删改查。注释写的很详细，如果看不懂的话可以评论会不定时回复的（考研人准备数据结构）
数据结构入门-顺序表的增删改查
m0_66654161的博客
03-04 478
目录 一、从数组入手，一步步构建动态顺序表 二、顺序表的增删改查 1.增 2.删 3.改 4.查 总结 前言 在学习数据结构的时候，课本上的代码与我们学习C语言的时候有较大出入，这是因为课本在很多地方都用define或者typedef重定义了，我在学习了很多相关视频的情况下，尝试写出一些自己的想法，新手一枚，如有错误，还希望各位大神不吝赐教。 阅读这篇文章需要的基础知识： define和typedef的使用。 malloc和realloc的用法。 指针的基础知识。 a..
数据结构--顺序表的增删改查
Hahahlqz的博客
05-15 440
#include <stdio.h> #include <string.h> #include <stdlib.h> #include <strings.h> #define MAXLEN 100 typedef int DataType; typedef struct seqlist { DataType Data[MAXLEN]; int Length; }SeqList; SeqList L; void InitList(SeqList
数据结构 顺序表之增删改查
记录读博日常，记录一些零碎的东西，包括但不限于：工具分享、论文分享、读博心得
03-03 438
初识数据结构之顺序表，码上说话????。 #include<iostream> #define maxSize 100 using namespace std; typedef struct { int data[maxSize]; //存放数据 int length; //数组长度 }SqList; //构建一个结构体 void printList(SqLi...
【数据结构】顺序表的增删改查
haonanren2bu2的专栏
02-13 1695
简单顺序表的增删改查实例： #include #define MAX 100typedef struct {int length;int data[MAX];}Sqlist,*PSqlist;void initList(PSqlist p);void insertList(PSqlist p,int elem);void deleteList(PSqlist p,int locate);void
C-数据结构之顺序表的增删改查
nnluop的博客
11-21 223
11.21-学习笔记 #include<stdio.h> #include<stdlib.h> #define MaxSIZE 100 #define ElemType int //定义一个顺序表 typedef struct{ ElemType data[MaxSIZE];//顺序表的元素 int length;//顺序表的长度 }seqlist,*list; //顺序表的创建 list creatlist(seqlist *L) { // printf("1.L=%d\n
数据结构顺序表，链表，队列，栈，串，二叉树的存储结构，增删改查操作和主函数实现
03-10
适用于考研初试数据结构顺序表，链表，队列，栈，串，二叉树基础操作的代码练习，里面有实现函数和注释，可以通过运行程序来加深对数据结构的理解。顺序表包含静态存储和动态存储的结构体定义，初始化，插入和删除...
数据结构顺序初始化增删改查以及销毁原码
11-07
在这个主题中，"数据结构顺序初始化增删改查以及销毁原码"主要指的是在C语言中实现顺序存储结构（如数组）的基本操作：初始化、增加元素、删除元素、修改元素以及销毁结构。以下是对这些操作的详细讲解： 1. **初始...
[数据结构]---C语言实现: 顺序表的增删改查等操作
夜微雨的博客
09-05 1525
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组存储。(栈上) 动态顺序表：使用动态开辟的数组存储。(堆上) // 顺序表的静态存储 #define N 100 typedef int SLDataType; typedef struct SeqList { SL...
数据结构--顺序表VS链表--王道考研阅读笔记
weixin_50311592的博客
04-25 183
顺序表VS链表 逻辑结构：都属于线性表，都是线性结构 存储结构： 顺序表 优点：支持随机存取、存储密度高 缺点：大片连续空间分配不方便，改变容量不方便 链表 优点：离散的小空间分配方便，改变容量方便 缺点：不可随机存取，存储密度低 基本操作 创建 顺序表 需要预分配大片连续空间。若分配空间过小，则之后不方便拓展容量，若分配空间过大，则浪费内存资源 静态分配：静态数组（容量不可改变） 动态分配：动态数组（malloc、free）（容量可改变，但需要移动大量元素，时间代价高）
算法与数据结构中的数据增删改查代码
11-16
算法与数据结构中的数据增删改查代码。在该算法中，通过链表和指针实现了数据的增上改查。
数据结构 —— 顺序表的结构、功能（增删查改）。
wihkum
07-08 588
数据结构 —— 顺序表
数据结构--单链表的增删改查
Hahahlqz的博客
05-15 259
学生党一枚 ，希望把自己的学习过程记录下来方便以后查找和代码的改进。 希望和CSDN社区的小伙伴们一起进步
数据结构—动态数组增删改查
qq_52655865的博客
04-18 1158
目录 一线性表 二.动态数组 三.添加元素 一.默认添加在数组末尾 二.在指定位置index添加 四.删除 一.删除首位元素 二.按下标删除 三.按值删除 五.修改 六.查询 一线性表 二.动态数组 三.添加元素 一.默认添加在数组末尾 动态数组类： package seqlist; import java.util.Arrays; /** 动态数组的类：具备增删改查的功能，逻辑结构对外不可见。用户只知道该功能 */ public c
数据结构与算法（1）-数组的增删改查
Jak的博客
08-15 967
数组的增删改查 public class MyArray { private long[] arr; //表示有效数据的长度 private int elements; public MyArray(){ arr = new long[50]; } public MyArray(int maxsize){ arr = new long[maxsize]; } /** ...
【数据结构】动态顺序栈的增删改查
haonanren2bu2的专栏
02-21 1100
#include #include #define INITIAL_STACK_SIZE 100 #define INCREASE_STACK_SIZE 10 // 大于一个元素的内存大小 typedef int ElemType; typedef struct Stack { ElemType *top; ElemType *base; int stacksize; //
【数据结构】顺序表的增删查改
最新发布
烧鸡配油茶的博客
04-07 163
是用一段的存储单元依次存储数据元素的，一般情况下采用。在数组上完成数据的增删查改。1.静态顺序表：使用定长数组存储元素。2. 动态顺序表：使用动态开辟的数组存储。
7.19 数据结构顺序表的增删改查
努力努力再努力
07-19 590
C语言数据结构中对顺序表的增删改查
顺序表增删改查的实现技巧与分析
4. 异常处理：在顺序表的增删改查操作中，需要注意异常情况的处理，如插入位置不存在、删除位置无效等，应当通过抛出异常或者返回错误码来通知调用者。 5. 缓存局部性原理：顺序表的连续存储特性符合计算机缓存局部...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值