用C语言编写动态顺序表

最新推荐文章于 2022-01-18 21:35:54 发布
最新推荐文章于 2022-01-18 21:35:54 发布
阅读量505 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_39630193/article/details/76296544
版权

数组是一种线性数据结构，而这种数据结构就称之为顺序表。

动态顺序表将静态顺序表中的数组数据类型改成了指针类型方便内存的开辟。

动态顺序表相较于静态顺序表的优点：开辟的空间灵活自如，添加元素时自动增容，删除元素时自动减容，节省内存空间。

*注意：malloc开辟的内存空间以后调用销毁空函数destory_mylist(&my_list)进行内存释放。


SeqListD.h

#define _CRT_SECURE_NO_WARNINGS 1
#ifndef __SEQLIST_H__     
#define __SEQLIST_H__     
#include<stdio.h>    
#include<stdlib.h>    
#include <assert.h>    
#define DEDAULT_SZ 2   //定义顺序表容量的初始化值  
#define INC 1   
typedef int DataType;//定义顺序表数据类型    
typedef struct SeqList
{
	DataType *data;//数据类型    
	int sz;//元素数量    
	int capacity;//容量  
}SeqList, *pSeqList;

void InitSeqList(pSeqList ps);//初始化顺序表    
void destory_mylist(pSeqList ps);//销毁初始化的空间  
void checkcapalist(pSeqList ps);//增容函数  
void delecapalist(pSeqList ps);//减容函数  
void PushBack(pSeqList ps, DataType d);//在尾部插入元素    
void PopBack(pSeqList ps);//在尾部删除元素     
void Display(const pSeqList ps);//打印顺序表    
void PushFront(pSeqList ps, DataType d);//在头部插入元素     
void PopFront(pSeqList ps);//删除首元素    
int Find(pSeqList ps, DataType d);//查找你要的元素    
void Insert(pSeqList ps, DataType d, int pos);//在指定的位置插入元素    
void Remove(pSeqList ps, DataType d);//删除指定元素    
void RemoveAll(pSeqList ps, DataType d);//删除你要删除的的出现的所有元素    
void Reverse(pSeqList ps);//逆序  
void Sort(pSeqList ps);//排序   
int BinarySearch(pSeqList ps, DataType d);//二分查找    
#endif //__SEQLIST_H__
Test.c 

#include"SeqListD.h"    
void test1()
{
	SeqList my_list;
	InitSeqList(&my_list);//初始化顺序表
	PushBack(&my_list, 1);
	PushBack(&my_list, 2);
	PushBack(&my_list, 3);
	PushBack(&my_list, 4);
	Display(&my_list);
	//打印时候可以不传地址，因为只打印，不会改它，只要拿到里面的数据就可以了。 
	//形参是实参的临时拷贝，数据sz全部传过去，打印没有任何问题，但这样做不好。
	//结构体传参，传地址，不要传变量，因为传变量系统压栈的开销比较大，结构体可能会大。所以传地址比较好。
	PopBack(&my_list);
	Display(&my_list);
	PopBack(&my_list);
	Display(&my_list);
	PopBack(&my_list);
	Display(&my_list);
	PopBack(&my_list);
	Display(&my_list);
	destory_mylist(&my_list);
}
void test2()
{
	SeqList my_list;
	InitSeqList(&my_list);//初始化顺序表
	PushFront(&my_list, 1);
	PushFront(&my_list, 2);
	PushFront(&my_list, 3);
	PushFront(&my_list, 4);
	Display(&my_list);
	PopFront(&my_list);
	Display(&my_list);
	PopFront(&my_list);
	Display(&my_list);
	PopFront(&my_list);
	Display(&my_list);
	PopFront(&my_list);
	Display(&my_list);
	destory_mylist(&my_list);
}
void test3()
{
	SeqList my_list;
	int pos = 0;
	InitSeqList(&my_list);//初始化顺序表
	PushFront(&my_list, 1);
	PushFront(&my_list, 2);
	PushFront(&my_list, 3);
	PushFront(&my_list, 4);
	PushFront(&my_list, 5);
	pos = Find(&my_list, 4);
	if (pos == -1)
	{
		printf("要查找的元素不存在\n");
	}
	else
	{
		Insert(&my_list, 6, pos);//把6插入pos的位置上
	}
	Display(&my_list);
	destory_mylist(&my_list);
}
void test4()
{
	SeqList my_list;
	int pos = 0;
	InitSeqList(&my_list);//初始化顺序表
	PushFront(&my_list, 1);
	PushFront(&my_list, 2);
	PushFront(&my_list, 3);
	PushFront(&my_list, 4);
	PushFront(&my_list, 5);
	Display(&my_list);
	Remove(&my_list, 3);
	Display(&my_list);
	destory_mylist(&my_list);
}
void test5()
{
	SeqList my_list;
	int pos = 0;
	InitSeqList(&my_list);//初始化顺序表
	PushFront(&my_list, 1);
	PushFront(&my_list, 3);
	PushFront(&my_list, 3);
	PushFront(&my_list, 2);
	PushFront(&my_list, 3);
	PushFront(&my_list, 4);
	PushFront(&my_list, 3);
	PushFront(&my_list, 5);
	PushFront(&my_list, 3);
	Display(&my_list);
	RemoveAll(&my_list, 3);
	Display(&my_list);
	destory_mylist(&my_list);
}
void test6()
{
	SeqList my_list;
	InitSeqList(&my_list);//初始化顺序表
	PushFront(&my_list, 1);
	PushFront(&my_list, 2);
	PushFront(&my_list, 3);
	PushFront(&my_list, 4);
	PushFront(&my_list, 5);
	Display(&my_list);
	Reverse(&my_list);
	Display(&my_list);
	destory_mylist(&my_list);
}
void test7()
{
	SeqList my_list;
	int pos = 0;
	InitSeqList(&my_list);//初始化顺序表
	PushFront(&my_list, 1);
	PushFront(&my_list, 2);
	PushFront(&my_list, 3);
	PushFront(&my_list, 4);
	PushFront(&my_list, 5);
	Display(&my_list);
	Sort(&my_list);
	Display(&my_list);
	pos = BinarySearch(&my_list, 3);
	printf("%d\n", pos);
	pos = BinarySearch(&my_list, 6);
	printf("%d\n", pos);
	destory_mylist(&my_list);
}
int main()
{
	test6();
	system("pause");
	return 0;
}

SeqListD.C 

#include"SeqListD.h"    
void InitSeqList(pSeqList ps)//初始化顺序表,动态开辟内存  
{
	assert(ps != NULL);
	ps->sz = 0;
	ps->capacity = DEDAULT_SZ;//容量初始化为2  
	ps->data = (DataType *)malloc((ps->capacity)*sizeof(DataType));
	if (ps->data == NULL)
	{
		perror("molloc");
		exit(EXIT_FAILURE);
	}
	memset(ps->data, 0, (ps->capacity)*sizeof(DataType));
}
void destory_mylist(pSeqList ps)//free初始化的时候动态开辟的空间  
{
	assert(ps != NULL);
	free(ps->data);
	ps->data = NULL;
	ps->sz = 0;
	ps->capacity = 0;
}
void checkcapalist(pSeqList ps)
{
	assert(ps != NULL);
	if (ps->sz == ps->capacity)//如果等于容量就满了就增容  
	{
		DataType *ptr = realloc(ps->data, (ps->capacity + INC)*sizeof(DataType));
		if (ptr != NULL)
		{
			ps->data = ptr;
			ps->capacity += INC;
		}
		else
		{
			perror("realloc");
			exit(EXIT_FAILURE);
		}
	}
}
void PushBack(pSeqList ps, DataType d)//在尾部插入尾函数    
{
	assert(ps != NULL);
	checkcapalist(ps);//进行增容  
	ps->data[ps->sz] = d;
	ps->sz++;
}
void Display(const pSeqList ps)//打印函数    
{
	int i = 0;
	assert(ps != NULL);
	for (i = 0; i < ps->sz; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}
void PopBack(pSeqList ps)//删除尾部的元素函数    
{
	assert(ps != NULL);
	ps->sz--;
}
void PushFront(pSeqList ps, DataType d)//从头部开始插入元素    
{
	assert(ps != NULL);
	checkcapalist(ps);//是否需要增容  
	int i = 0;
	for (i = ps->sz; i>0; i--)
	{
		ps->data[i] = ps->data[i - 1];
	}
	ps->data[0] = d;
	ps->sz++;

}
void delecapalist(pSeqList ps)//减容函数  
{
	assert(ps != NULL);
	if (ps->sz < ps->capacity)
	{
		DataType *ptr = realloc(ps->data, (ps->capacity - INC)*sizeof(DataType));
		if (ptr != NULL)
		{
			ps->data = ptr;
			ps->capacity -= INC;
		}
		else
		{
			perror("realloc");
			exit(EXIT_FAILURE);
		}
	}
}
void PopFront(pSeqList ps)//删除头部    
{
	int i = 0;
	assert(ps != NULL);
	for (i = 0; i < ps->sz; i++)
	{
		ps->data[i] = ps->data[i + 1];
	}
	ps->sz--;
	delecapalist(ps);//减容  
}
int Find(pSeqList ps, DataType d)//查找第几个元素    
{
	int i = 0;
	if (ps != NULL);
	for (i = 0; i < ps->sz; i++)
	{
		if (ps->data[i] == ps->data[d - 1])
			return ps->data[i];
	}
	return -1;
}
void Insert(pSeqList ps, DataType d, int pos)//指定位置插入元素，d要插入的元素,pos指定位置    
{
	assert(ps != NULL);
	checkcapalist(ps);//增容  
	int i = 0;
	for (i = ps->sz; i>pos - 1; i--)
	{
		ps->data[i] = ps->data[i - 1];
	}
	ps->data[pos - 1] = d;
	ps->sz++;

}
void Remove(pSeqList ps, DataType d)//删除你要删除的第一个出现的元素    
{
	int i = 0, j = 0;;
	assert(ps != NULL);
	for (i = 0; i < ps->sz; i++)
	{

		if (ps->data[i] == d)
		{
			for (j = i; j < ps->sz; j++)
			{
				ps->data[j] = ps->data[j + 1];
			}
			ps->sz--;
			delecapalist(ps);//减容  
			break;
		}
	}
}
void RemoveAll(pSeqList ps, DataType d)//删除你要删除的所有元素  
{
	int i = 0, j = 0;;
	assert(ps != NULL);
	for (i = 0; i < ps->sz; i++)
	{
		if (ps->data[i] == d)
		{
			for (j = i; j < ps->sz; j++)
			{
				ps->data[j] = ps->data[j + 1];
			}
			ps->sz--;
			delecapalist(ps);//减容  
			i = 0;
		}
	}
}
void Reverse(pSeqList ps)//逆序   
{
	assert(ps != NULL);
	int i = 0, j = ps->sz - 1;
	int n = ps->sz / 2;
	for (i = 0; i <= n / 2; i++, j--)
	{
		int temp = 0;
		temp = ps->data[i];
		ps->data[i] = ps->data[j];
		ps->data[j] = temp;
	}
}
void Sort(pSeqList ps)//排序，采用的是冒泡排序    
{
	assert(ps != NULL);
	int i = 0, j = 0;
	for (i = 0; i < ps->sz - 1; i++)
	{
		for (j = 0; j < ps->sz - 1 - i; j++)
		{
			int temp = 0;
			if (ps->data[j]>ps->data[j + 1])
			{
				temp = ps->data[j];
				ps->data[j] = ps->data[j + 1];
				ps->data[j + 1] = temp;
			}
		}
	}
}
int BinarySearch(pSeqList ps, DataType d)//二分查找,d表示你要查找的元素    
{
	int left = 0;
	int right = ps->sz - 1;
	while (left < right)
	{
		int mid = (right - left) / 2 + left;
		if (d>ps->data[mid])
		{
			left = mid + 1;
		}
		else if (d < ps->data[mid])
		{
			right = mid - 1;
		}
		else
		{
			return mid;
		}
	}
}


钢男一步一步在成长
关注
【数据结构】C语言实现顺序表(动态顺序表)
Begin
06-21 608
相比上一篇博客所写的静态顺序表，本篇介绍的动态版本主要通过增加动态扩容以及内存资源回收两个接口实现动态顺序表 使得顺序表的使用相较上一个版本比较灵活 具体实现代码： SeqList.h #ifndef __SEQLIST_D_H__ #define __SEQLIST_D_H__ #include #include #include #include typedef int DataT
（C语言）顺序表之动态实现
snow_5288的博客
06-01 1114
点击打开链接（静态实现版） 头文件： #define _CRT_SECURE_NO_WARNINGS 1 #ifndef _SEQLIST_H__ #define _SEQLIST_H__ #include #include #include #include #define MAX 2 #define CHANGE_MAX 2 typedef int TYPE; typedef stru
【动态顺序表】 c语言的动态顺序表
weixin_33778544的博客
03-22 112
动态顺序表： 容量不够时 自动增容（静态顺序表的改进） 动态顺序表的结构：typedef int DataType;typedef struct SeqList{ DataType* _array; //指向数据块的指针 size_t _size; //有效数据个数 size_t _capacity; //容量}SeqList;增容：...
动态顺序表【C语言】
Henyry的博客
01-18 310
线性表的顺序存储结构 顺序表
C语言实现动态顺序表
MJ813的专栏
09-06 419
/*********************************************************************************** xxx.h: Copyright (c) , Inc.(2016), All rights reserved. Purpose: C语言实现动态顺序表 Author: MaJing Reviser: yyy Cre
C语言实现顺序表的顺序查找和折半查找
08-25
C语言实现顺序表的顺序查找和折半查找 在计算机科学中，查找是指在一组数据中找到特定元素的过程。顺序表是一种基本的数据结构，在实际应用中非常常见。因此，学习如何在顺序表中实现查找是非常重要的。下面，我们...
基于C语言的顺序表实现图书管理系统
01-06
1.动态内存管理 2.C语言编写 3.超级人性化，欢迎大家下载查询
c语言实现顺序表的基本操作
01-20
数据结构顺序表操作 代码如下:#include <stdio>#include <stdlib>#include <malloc>#define LIST_INIT_SIZE 100#define LISINCREMENT 10#define ElemType int#define Status inttypedef struct Sq{ ElemType *elem...
C语言编写顺序表（包含主要函数）
04-18
C语言编写的顺序表的基本函数，学到这方面的同志可以作为参考。
动态顺序表（C语言实现）
Lonely_Mr_zhang的博客
05-31 666
数据结构： typedef int DataType,*pDataType;typedef struct Seqlist { pDataType pdata;//指向动态开辟的区域 int sz;//有效个数 int capacity;//容量 } Seqlist,*pSeqlist; 方法： void InitSeqlist(pSeqlist ps);//初始化 voi
C语言动态顺序表的实现
小白的Coding之旅
07-17 250
静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。 seqlist.h #ifndef _SEQLIST_H_ #define _SEQLIST_H_ #include<stdio.h> #include<stdlib.h&gt...
c语言动态顺序表的实现
IT_iverson的博客
07-28 790
动态顺序表是在静态顺序表的基础上优化更改的 1.其中将静态顺序表中的数组数据类型改成了指针类型方便内存的开辟 2.多增加了一个容量的变量来表示顺序表的容量 3.初始化的时候需要给*data动态开辟空间 4.多增加的函数有1.增容函数  2.减容函数  3.空间销毁函数（因为malloc的空间使用完毕后一定要释放内存，不然会造成内存泄露） 动态顺序表的优点：开辟的空间灵活自如，添加元素时自
c语言实现动态顺序表
孙堂吉de博客
09-22 364
seqlist.h#ifndef __SEQLIST_H__ #define __SEQLIST_H__ #include <stdio.h> #include <stdlib.h> //#include //#include #define DEFAULT_SZ 3 #define DEFAULT_INC 2 typedef int DataType; typedef struct SeqL
C语言动态顺序表
guorong520的博客
07-28 321
顺序表是将表中的节点依次存放在计算机内存中一组地址连续的存储单元中，表可以动态增长，尾插元素，尾删元素，头插元素，头删元素，打印元素，查找元素，插入指定位置的元素，删除指定元素，删除所有指定的元素，逆序顺序表，排序顺序表，二分查找。  ☆☆☆代码实现 seqlist.h #ifndef __SEQLIST_H__ #define __SEQLIST_H__ #define DEFAULT_
动态顺序表c语言实现
漫鱼
04-12 498
主要操作结构体中的指针，在init函数里对指针进行内存开辟，checkCapacity函数在每次插入之前检查一遍，如果可用空间没有了，就开辟当前最大容量的两倍。其他操作与静态顺序表无大区别。 seqList.h #pragma once #define DataType int typedef struct seqList { DataType * array; ...
C语言动态实现顺序表
Demons的博客
04-25 617
顺序表的动态存储结构： typedef int DataType; typedef struct SeqListD { DataType* array;//数据指针 size_t capacity; //容量 size_t size; //有效元素的个数 }SeqListD, *PSeqListD; 部分函数操作：   void InitSeqListD(P...
用c语言编写顺序表删除元素
最新发布
09-20
在C语言中，顺序表（也叫数组）通常是一个固定大小的连续内存区域，用来存储一系列同类型的元素。删除顺序表中的某个元素需要考虑到元素移动的问题，因为我们需要保留列表的连续性和顺序。这里有一个简单的例子展示如何从一个整型顺序表中删除指定索引的元素： ```c #include <stdio.h> // 定义顺序表结构体 typedef struct { int* data; // 存储元素的指针 int size; // 序列长度 int capacity; // 序列容量 } SeqList; // 创建新的顺序表 SeqList* create_list(int capacity) { SeqList* list = (SeqList*)malloc(sizeof(SeqList)); list->data = (int*)malloc(capacity * sizeof(int)); // 分配空间 list->size = 0; list->capacity = capacity; return list; } // 删除指定位置的元素并调整其他元素的位置 void delete_element(SeqList* list, int index) { if (index >= list->size || index < 0) { printf("Invalid index.\n"); return; } // 将后面的元素向前移动一位 for (int i = index; i < list->size - 1; i++) { list->data[i] = list->data[i + 1]; } // 减小序列长度并释放多余的空间（如果满了） list->size--; if (list->size == list->capacity / 2 && list->size > 0) { // 避免频繁扩容 list->capacity /= 2; list->data = (int*)realloc(list->data, list->capacity * sizeof(int)); // 调整内存 } } // 打印顺序表示例 void print_list(SeqList* list) { for (int i = 0; i < list->size; i++) { printf("%d ", list->data[i]); } printf("\n"); } int main() { SeqList* list = create_list(5); // 创建一个有5个初始空位的列表 // 添加元素... list->data[0] = 1; list->data[1] = 2; // ... // 删除元素（例如，删除第2个元素） delete_element(list, 1); // 输出修改后的列表 print_list(list); free(list->data); // 释放内存 free(list); // 释放结构体自身 return 0; } ``` 注意：这个实现假设列表可能会变得很短，并对容量进行了一些优化，以避免频繁地扩容。实际使用时，你可能需要更精细的策略来处理这种情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值