动态顺序表（可分配内存空间）

<strong style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">前几天写了一个静态顺序表，但是觉得一开始开辟很大一部分空间却不一定可以完全用得上，会造成很大的内存浪费，于是写了一个可以自动开辟内存空间的动态顺序表作为改进。</strong>

"DynamicSeqllist.h"

#pragma once
#define __SEQ_LIST__
#ifdef __SEQ_LIST__

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

typedef int DataType;

#define DEFAULT_CAPACITY 3

typedef struct SeqList
{
	DataType* array;
	size_t size;	  // 当前的有效数据个数
	size_t capacity;  // 容量
}SeqList;

typedef enum Tag
{
	TRUE,	// 真
	FALSE,	// 假
}Tag;

typedef struct FindRet
{
	Tag isFind;		// 是否找到的标示
	size_t index;	// 找到数据的下标
}FindRet;

void InitSeqList(SeqList* pSeq);
void PrintSeqList(SeqList* pSeq);
void CheckExpandCapacity(SeqList* pSeq);
void DestorySeqList(SeqList* pSeq);

void PushBack(SeqList* pSeq, DataType x);
void PopBack(SeqList* pSeq);

void PushFront(SeqList* pSeq, DataType x);
void PopFront(SeqList* pSeq);

void Insert(SeqList* pSeq, size_t index, DataType x);
void Modified(SeqList* pSeq, size_t index, DataType x);
void Remove(SeqList* pSeq, size_t index);

FindRet Find(SeqList* pSeq, DataType x, size_t index);
Tag Erase(SeqList* pSeq, DataType x, Tag all);

void BubbleSort(SeqList* pSeq);
void SelectSort(SeqList* pSeq);
FindRet BinarySearch(SeqList * pSeq, DataType x);

#endif // __SEQ_LIST__

"DynamicSeqlist.c"

#include "DynamicSeqlist.h"

//对顺序表初始化
void InitSeqList(SeqList* pSeq)
{
	assert(pSeq);
	pSeq->array = (DataType*)malloc(sizeof(DataType)*DEFAULT_CAPACITY);
	pSeq->size = 0;
	pSeq->capacity = DEFAULT_CAPACITY;
}

//打印顺序表
void PrintSeqList(SeqList* pSeq)
{
	assert(pSeq);
	int i = 0;
	for (; i < pSeq->size; i++)
	{
		printf("%d ",pSeq->array[i]);
	}
	printf("\n");
}

//检测内存空间是否足够，若不够则自动分配二倍空间存储数据
void CheckExpandCapacity(SeqList* pSeq)
{
	assert(pSeq);
	if (pSeq->size == pSeq->capacity)
	{
		DataType* tmp = (DataType*)malloc(pSeq->capacity * 2*sizeof(DataType));
		memcpy(tmp, pSeq->array, sizeof(DataType)*pSeq->size);

		free(pSeq->array);//当开辟出新空间存储数据时要将旧空间释放掉
		pSeq->array = tmp;
		pSeq->capacity = pSeq->capacity * 2;
	}
}

//释放空间，销毁顺序表
void DestorySeqList(SeqList* pSeq)
{
	if (pSeq)
	{
		free(pSeq->array);
		pSeq->capacity = 0;
		pSeq->size = 0;
	}
}

void PushBack(SeqList* pSeq, DataType x)
{
	assert(pSeq);
	CheckExpandCapacity(pSeq);
	pSeq->array[pSeq->size++] = x;
}

void PopBack(SeqList* pSeq)
{
	assert(pSeq);
	--pSeq->size;
}

void PushFront(SeqList* pSeq, DataType x)
{
	assert(pSeq);
	CheckExpandCapacity(pSeq);
	int i = pSeq->size;
	for (; i >0 ; --i)
	{
		pSeq->array[i] = pSeq->array[i -1];
	}
	pSeq->array[0] = x;
	pSeq->size++;
}

void PopFront(SeqList* pSeq)
{
	assert(pSeq);
	int i = 0 ;
	if (pSeq->size == 0)
	{
		printf("array is empty!");
	}
	for (; i <pSeq->size; ++i)
	{
		pSeq->array[i] = pSeq->array[i + 1];
	}
	pSeq->size--;
}

void Insert(SeqList* pSeq, size_t index, DataType x)
{
	assert(pSeq);
	assert(index<pSeq->size);
	int i = pSeq->size;
	for (; i>index ; --i)
	{
		pSeq->array[i] = pSeq->array[i - 1];
	}
	pSeq->array[index] = x;
	pSeq->size++;
}

void Modified(SeqList* pSeq, size_t index, DataType x)
{
	assert(pSeq);
	assert(index<pSeq->size);
	pSeq->array[index] = x;
}

void Remove(SeqList* pSeq, size_t index)
{
	assert(pSeq);
	assert(index<pSeq->size );
	for (; pSeq->size>index; index++)
	{
		pSeq->array[index] = pSeq->array[index + 1];
	}
	pSeq->size--;
}

FindRet Find(SeqList* pSeq, DataType x, size_t index)
{
	assert(pSeq);
	FindRet ret = { FALSE, NULL };
	for (; index < pSeq->size; index++)
	{
		if (x == pSeq->array[index])
		{
			Tag isFind = TRUE;
			ret.isFind = TRUE;
			ret.index = index;
			return ret;
		}
	}
	Tag isFind = FALSE;
	return ret;
}

void Swap(DataType *left,DataType *right)
{
	DataType tmp = *left;
	*left = *right;
	*right = tmp;
}
//冒泡排序（升序）
//X1和X2进行比较，如果X1<X2，则交换位置，直到X1是余下的数中最大的
void BubbleSort(SeqList* pSeq)
{
	assert(pSeq);
	size_t index,end;
	int count = 0;
	int exchange = 0;
	for (end = pSeq->size - 1; end > 0; --end)
	{
		exchange = 0;
		for (index=0; index < end; ++index)
		{
			count++;
			if (pSeq->array[index] > pSeq->array[index + 1])
			{
				Swap(pSeq->array +index,pSeq->array +index+1);
				exchange = 1;
			}
			if (exchange == 0)
				break;
		}
	}
	printf("%d\n",count);

}

void SelectSort(SeqList* pSeq)
{
	assert(pSeq);
	size_t index, minIndex, begin;
	for (begin = 0; begin < pSeq->size; ++begin)
	{
		minIndex = begin;
		for (index = begin + 1; index < pSeq->size; ++index)
		{
			if (pSeq->array[minIndex]>pSeq->array[index])
			{
				minIndex = index;
			}
		}
		if (minIndex != begin)
		{
			Swap(pSeq->array +minIndex,pSeq->array +begin);
		}
	}
}

FindRet BinarySearch(SeqList * pSeq, DataType x)
{
	assert(pSeq);
	FindRet ret;
	ret.isFind = FALSE;
	size_t right, mid ,left;
	left = 0;
	right = pSeq->size - 1;
	while (left <= right)
	{
		mid = (right + left) / 2;
		if (pSeq->array[mid] == x)
		{
			ret.isFind = TRUE;
			ret.index = mid;
			return ret;
		}
		else if (pSeq->array[mid] > x)
		{
			right = mid - 1;
		}
		else
			left = mid + 1;
	}
	return ret;
}

Tag Erase(SeqList* pSeq, DataType x, Tag all)
{
	Tag success = FALSE;
	FindRet ret;
	assert(pSeq);
	ret = Find(pSeq, x, 0);

	while(ret.isFind == TRUE)
	{
		success = TRUE;
		Remove(pSeq, ret.index);

		if (all == FALSE)
		{
			break;
		}

		ret = Find(pSeq, x, ret.index);
	}

	return success;
}

"main.c"

#include "DynamicSeqlist.h"

void Test1()
{
	SeqList s;
	InitSeqList(&s);
	CheckExpandCapacity(&s);
	PushBack(&s, 1);
	PushBack(&s, 2);
	PushBack(&s, 3);
	PushBack(&s, 4);
	PrintSeqList(&s);
	PopBack(&s);
	PrintSeqList(&s);
	PushFront(&s,0);
	PrintSeqList(&s);
	PopFront(&s);
	PrintSeqList(&s);
	DestorySeqList(&s);
}

void Test2()
{
	SeqList s;
	InitSeqList(&s);
	CheckExpandCapacity(&s);
	PushBack(&s, 1);
	PushBack(&s, 2);
	PushBack(&s, 3);
	PushBack(&s, 4);
	PrintSeqList(&s);
	Insert(&s,1,8);
	PrintSeqList(&s);
	Modified(&s,2,5);
	PrintSeqList(&s);
	Remove(&s, 1);
	PrintSeqList(&s);
	Find(&s,3,0);
	DestorySeqList(&s);
}
void Test3()
{
	SeqList s;
	InitSeqList(&s);
	CheckExpandCapacity(&s);
	PushBack(&s, 9);
	PushBack(&s, 4);
	PushBack(&s, 6);
	PushBack(&s, 2);
	PrintSeqList(&s);
	BubbleSort(&s);
	PrintSeqList(&s);
	SelectSort(&s);
	PrintSeqList(&s);
	DestorySeqList(&s);
}
void Test4()
{
	SeqList s;
	InitSeqList(&s);
	CheckExpandCapacity(&s);
	PushBack(&s, 9);
	PushBack(&s, 4);
	PushBack(&s, 6);
	PushBack(&s, 2);
	PushBack(&s, 4);
	PushBack(&s, 3);
	PushBack(&s, 1);
	PrintSeqList(&s);
	Erase(&s,4,TRUE);
	PrintSeqList(&s);
	DestorySeqList(&s);
}
int main()
{
	Test1();
	printf("\n");
	Test2();
	printf("\n");
	Test3();
	printf("\n");
	Test4();
	getchar();
	return 0;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-10-10 10:57:49

动态顺序表（可分配内存空间）的相关文章

【C语言】静态顺序表和动态顺序表的实现

静态顺序表 定义一张顺序表也就是在内存中开辟一段连续的存储空间,并给它一个名字进行标识.只有定义了一个顺序表,才能利用该顺序表存放数据元素,也才能对该顺序表进行各种操作. 有两种定义顺序表的方法:一是静态地定义一张顺序表:二是动态地生成一张顺序表. 静态地定义一张顺序表的方法与定义一个数组的方法类似.可以描述如下: #define MAX_SIZE 100 typedef int DataType; typedef struct SeqList { DataType array[MAX_SIZE

c实现的动态顺序表

第一篇文章中用c实现了静态顺序表,但是使用静态顺序表还有不足的地方.当我们需要存储的数据很少时,如果静态顺序表的数组容量较大就会造成空间的浪费:当我们需要存储的数据很多时,如果静态顺序表的数组容量较小可能就会造成数据丢失.所以一般情况我们应该尽量把顺序表实现成动态的.需要多大容量就开辟多大容量. 静态顺序表和动态顺序表只有以下函数不同: 1.定义结构体时,多定义一个capacity,并对capacity进行初始化和增加大小的设置: #define INIT_CAPACITY 3 #define 

C语言：【动态顺序表】动态顺序表的初始化、打印、尾插PushBack、尾删PopBack

#include<stdio.h> #include<stdlib.h> #include<assert.h> #include<string.h> #include<malloc.h> typedef int DateType; typedef struct SeqList {     DateType *arr;     size_t capacility;     size_t size; }SeqList; //创建空间 void Che

静态顺序表和动态顺序表

实现一个静态顺序表,首先,要定义一个保存数据的数组,保存在结构体中,用size来存储数组中的元素个数, typedef struct SeqList { DataType array[MAX_SIZE]; size_t size; }SeqList; 首先来实现一下静态顺序表的初始化函数,可以借用系统的memset函数来实现,开辟一块空间全部初始化为0,没有存入数据所以size也为0 void InitSeqList(SeqList *pSeq) { assert(pSeq); memset(p

动态顺序表 与 双向链表的模板类

//////////////////////////////////////////////////////////////////////// /////////////////////泛型编程之动态顺序表的模板///////////////////////// //////////////////////////////////////////////////////////////////////// #include<iostream> #include<string> u

java分配内存空间

分配内存空间 数组名=new 数据类型[数组长度]: new关键字用来实现为数组或对象分配内存 (堆内存) 数组具有固定的长度.获取数组的长度: 数组名.length 定义数组+分配内存空间 数据类型[]数组名=new 数据类型[数组长度]; 定义数组时不指定长度,分配空间时指定数组长度:如:String cities[] = new String[6]; 数组元素: 数组名[下标值]; 数组下标从0开始  scores[0]=75: 数组的内存分配  栈内存和堆内存 如定义一个数组 int[]

C++实现动态顺序表

顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构.这样的存储方式使得线性表逻辑上相邻的元素,其在物理存储单元中也是相邻的.只要知道了第一个元素的存储地址,就可以知道线性表中任何一个元素的存储地址.本文利用C++语言,在Windows平台 Visual Studio 2015开发环境下实现.功能:应用C++语言实现顺序表的各项操作.基本的成员函数:构造函数.拷贝构造函数.赋值运算符的重载.析构函数. // 顺序表构造成功之后,里面存放了n个元素

动态顺序表的基本实现

#include<stdio.h> #include<stdlib.h> #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define Status int #define OVERFLOW -1 #define OK 1 #define ERROR 0 #define ElemType int typedef struct { ElemType * elem; int length; //有效元素的个数 int lists

C++模板实现动态顺序表（更深层次的深浅拷贝）与基于顺序表的简单栈的实现

前面介绍的模板有关知识大部分都是用顺序表来举例的,现在我们就专门用模板来实现顺序表,其中的很多操作都和之前没有多大区别,只是有几个比较重要的知识点需要做专门的详解. 1 #pragma once 2 #include<iostream> 3 #include<string> 4 #include<stdlib.h> 5 using namespace std; 6 7 template <class T> 8 class Vector 9 { 10 publ