简单的动态顺序表实现

最新推荐文章于 2021-10-30 11:58:43 发布

原创最新推荐文章于 2021-10-30 11:58:43 发布 · 372 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#SeqListD #动态顺序表

本文介绍了一个动态顺序表的数据结构实现，包括初始化、插入、销毁等基本操作，并通过测试实例展示了其使用方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

动态顺序表文件定义

#pragma once

typedef int DataType;
typedef unsigned size_t;

typedef struct SeqListD
{
	DataType* _Array;
	size_t _Size;
	size_t _Capcity;
}SeqListD, *PSeqListD;

void InitSeqListD(PSeqListD pSeqListD);
void PushBack(PSeqListD pSeqListD, int x);
void PushFront(PSeqListD pSeqListD, int x);

void Insert(PSeqListD pSeqListD, size_t pos, int x);
void DestroySeqListD(PSeqListD pSeqListD);
int CheckCapcity(PSeqListD pSeqListD);

void PrintSeqListD(PSeqListD pSeqListD);

动态顺序表文件实现

#include"SeqListD.h"
#include<assert.h>
#include<malloc.h>

//#define NULL 0
#include<iostream>
using namespace std;

/*int BinarySearch(Array* a, int x)
{ 
	int left = 0;
	int right = a->size;
	while (left <= right)
	{
		int mid = left + (right - left) / 2;
		if (a->array[mid] < x)
		{
			left = mid + 1;
		}
		else if (a->array[mid] > x)
		{
			right = mid - 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}*/

/*void GetMemory(int* pMemory, int iSize)
{
	pMemory = (int*)malloc(sizeof(int)*iSize);
}*/


void InitSeqListD(PSeqListD pSeqListD)
{
	
	assert(pSeqListD);
	pSeqListD->_Array = NULL;
	pSeqListD->_Capcity = 0;
	pSeqListD->_Size = 0;
}

void PushBack(PSeqListD pSeqListD, int x)
{
	assert(pSeqListD);
	if (!CheckCapcity(pSeqListD))
	{
		return;
	}
	pSeqListD->_Array[pSeqListD->_Size++] = x;
}

void PushFront(PSeqListD pSeqListD, int x)
{
	int i = pSeqListD->_Size;
	assert(pSeqListD);
	if (!CheckCapcity(pSeqListD) )
	{
		return;
	}
	for (; i > 0; i--)
	{
		pSeqListD->_Array[i] = pSeqListD->_Array[i-1];
	}
	pSeqListD->_Array[0] = x;
	pSeqListD->_Size++;
}

int CheckCapcity(PSeqListD pSeqListD)
{
	if (pSeqListD->_Size >= pSeqListD->_Capcity)
	{
		int Capcity = pSeqListD->_Capcity * 2 + 3;
		DataType* tmp = (DataType*)malloc(sizeof(DataType)*Capcity);
		if (tmp != NULL)
		{
			pSeqListD->_Capcity = Capcity;
			pSeqListD->_Array = tmp;
			return 1;
		}
		return 0;
	}
	return 1;
}

void Insert(PSeqListD pSeqListD, size_t pos, int x)
{
	int i = pSeqListD->_Size;
	assert(NULL != pSeqListD);
	if (!CheckCapcity(pSeqListD))
	{
		return;
	}
	for (i; pos <= i; i--)
	{
		pSeqListD->_Array[i] = pSeqListD->_Array[i - 1];
	}
	pSeqListD->_Array[pos-1] = x;
	pSeqListD->_Size++;
}

void DestroySeqListD(PSeqListD pSeqListD)
{
	delete[]pSeqListD->_Array;
}

void PrintSeqListD(PSeqListD pSeqListD)
{
	assert(pSeqListD);
	int i = 0;
	for (; i < pSeqListD->_Size; i++)
	{
		printf("%d ", pSeqListD->_Array[i]);
	}
	printf("\n");
}

测试实例
void Test()
{
	SeqListD seqlist;
	//PrintSeqListD(&seqlist);

   /* PushBack(&seqlist, 1);
	PushBack(&seqlist, 2);
	PushBack(&seqlist, 3);
	PrintSeqListD(&seqlist);*/
	//InitSeqListD(&seqlist);

	/*PushFront(&seqlist, 4);
	PushFront(&seqlist, 5);
	PushFront(&seqlist, 6);
	PrintSeqListD(&seqlist);*/
	InitSeqListD(&seqlist);
	Insert(&seqlist, 1, 4);
	Insert(&seqlist, 2, 5);
	Insert(&seqlist, 3, 6);
	PrintSeqListD(&seqlist);
	DestroySeqListD(&seqlist);
	PrintSeqListD(&seqlist);

}

int main()
{

	Test();
	/*PSeqListD pSeqList;
	InitSeqListD(&pSeqList);*/
	/*Array a;
	for (int i = 0; i < 10; i++)
	{
		a.array[i] = i;
		a.size += 1;
	}

	int key = BinarySearch(&a, 4);
	cout << key << endl;*/

	//int* pTest = NULL;
	//GetMemory(pTest, 10);
	system("pause");
	return 0;
}