动态顺序表

//SeqList.h
#ifndef __SEQLIST_H__
#define __SEQLIST_H__
#include<string.h>
#include<assert.h>
#include<stdlib.h>

typedef int DataType;
typedef struct SeqList
{
	DataType* array;
	size_t size;
	DataType capacity;    //容量
}SeqList,*pSeqList;

void InitSeqList(pSeqList pSeq);
void PushBack(pSeqList pSeq,DataType x);
void PrintSeqList(pSeqList pSeq);

void PopBack(pSeqList pSeq);
void PushFront(pSeqList pSeq, DataType x);
void PopFront(pSeqList pSeq);

void Insert(pSeqList pSeq, int pos, DataType x);
void Remove(pSeqList pSeq, DataType x);
void RemoveAll(pSeqList pSeq, DataType x);

int Find(pSeqList pSeq,DataType x);
void Erase(pSeqList pSeq,DataType pos);
void ReverseList(pSeqList pSeq);

void SortList(pSeqList pSeq);
void SelectSortList(pSeqList pSeq);
int  BinarySearch(pSeqList Seq, DataType x);

void CheckCapacity(pSeqList pSeq)   //检查容量
{
	if(pSeq->size >= pSeq->capacity)
	{
		pSeq->capacity = pSeq->capacity*2+3;
		pSeq->array = (DataType*)realloc(pSeq->array,pSeq->capacity*sizeof(DataType));
	//	DataType *tmp = (DataType *)malloc(sizeof(DataType)*pSeq->capacity*2);
	//	memcpy(tmp,pSeq->array,sizeof(DataType)*pSeq->size);
	//	free(pSeq->array);
	//	pSeq->array = tmp;
	}
}

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

void PushBack(pSeqList pSeq,DataType x)  //尾插
{
	assert(pSeq);
	CheckCapacity(pSeq);
	pSeq->array[pSeq->size++] = x;
}

void PopBack(pSeqList pSeq)     //尾删
{
	assert(pSeq);
	if(pSeq->size <= 0)
	{
		printf("SeqList is empty");
		return;
	}
	pSeq->array[pSeq->size-1] = NULL;
	pSeq->size--;
}

void PushFront(pSeqList pSeq, DataType x)   //头插
{
	int i = 0;
	assert(pSeq);
	CheckCapacity(pSeq);
	for(i = pSeq->size-1; i >= 0; i--)
	{
		pSeq->array[i+1] = pSeq->array[i];
	}
	pSeq->array[0] = x;
	pSeq->size++;
}
void PopFront(pSeqList pSeq)    //头删
{
	int i = 0;
	assert(pSeq);
	if(pSeq->size <= 0)
	{
		printf("SeqList is empty");
		return;
	}
	for(i = 1; i < pSeq->size; i++)
	{
		pSeq->array[i-1] = pSeq->array[i];
	}
	pSeq->size--;
}

void Destroy(pSeqList pSeq)  //销毁
{
	assert(pSeq);
	pSeq->array = NULL;
	pSeq->size = 0;
	pSeq->capacity = 0;
}

void PrintSeqList(pSeqList pSeq)  //打印
{
	int i = 0;
	assert(pSeq);
	for(i = 0; i < pSeq->size;i++)
	{
		printf("%d ",pSeq->array[i]);
	}
}

void Insert(pSeqList pSeq, int pos, DataType x)  //在某个位置处插入
{
	int i = 0;
	assert(pSeq);
	CheckCapacity(pSeq);
	for(i = pSeq->size-1; i >= pos; i--)
	{
		pSeq->array[i+1] = pSeq->array[i];
	}
	pSeq->array[pos] = x;
	pSeq->size++;
}
int Find(pSeqList pSeq,DataType x)    //查找
{
	int i = 0;
	assert(pSeq);
	if(pSeq->size <= 0)
	{
		printf("SeqList is empty");
		return -1;
	}
	for(i = 0; i < pSeq->size; i++)
	{
		if(pSeq->array[i] == x)
		{
			return i;
		}
	}
	return -1;
}

void Erase(pSeqList pSeq,DataType pos)   //按位置删除
{
	int i = 0;
	assert(pSeq);
	if(pSeq->size <= 0)
	{
		printf("SeqList is empty");
		return;
	}
	for(i = pos+1; i < pSeq->size; i++)
	{
		pSeq->array[i-1] = pSeq->array[i];
	}
	pSeq->size--;
}
void Remove(pSeqList pSeq, DataType x)   //删除
{
	int pos = Find(pSeq,x);
	assert(pSeq);
	if(pos != -1)
	{
		Erase(pSeq,pos);
	}
	else
	{
		printf("not exist");
	}
}
void RemoveAll(pSeqList pSeq, DataType x)  //删除所有的x
{
	int count = 0;
	int i = 0;
	assert(pSeq);
	if(pSeq->size <= 0)
	{
		printf("SeqList is empty");
		return;
	}
	for(i = 0; i < pSeq->size; i++)
	{
		if(pSeq->array[i] == x)
		{
			count++;
		}
		else
		{
			pSeq->array[i-count] = pSeq->array[i];
		}
	}
	pSeq->size-=count;
}

void ReverseList(pSeqList pSeq)   // 逆置
{
	int left = 0;
	int right = pSeq->size-1;
	assert(pSeq);
	while(left < right)
	{
		int tmp = pSeq->array[left];
		pSeq->array[left] = pSeq->array[right];
		pSeq->array[right] = tmp;
		left++;
		right--;
	}
}

void SortList(pSeqList pSeq)  //冒泡排序
{
	int i = 0, j = 0;
	assert(pSeq);
	for(i = 0; i < pSeq->size-1; i++)
	{
		int exchange = 0;
		for(j = 0; j < pSeq->size-i-1; j++)
		{
			if(pSeq->array[j] > pSeq->array[j+1])
			{
				int tmp = pSeq->array[j];
				pSeq->array[j] = pSeq->array[j+1];
				pSeq->array[j+1] = tmp;
				exchange = 1;
			}
		}
		if(exchange == 0)
		{
			return;
		}
	}
}

void SelectSortList(pSeqList pSeq)   //选择排序
{
	int i = 0, j = 0;
	int min = 0;
	int tmp;
	assert(pSeq);
	for(i = 0; i < pSeq->size-1; i++)
	{
		min = i;
		for(j = i+1; j < pSeq->size; j++)
		{
			if(pSeq->array[min] > pSeq->array[j])
			{
				min = j;
			}
			    tmp = pSeq->array[min];
				pSeq->array[min] = pSeq->array[i];
				pSeq->array[i] = tmp;
		}
	}
}

int BinarySearch(pSeqList pSeq, DataType x)   //二分查找
{
	int left = 0;
	int right = pSeq->size-1;
	assert(pSeq);
	while(left <= right)
	{
		int mid = left - (left - right)/2;
		if(pSeq->array[mid] > x)
		{
			right = mid-1;
		}
		else if(pSeq->array[mid] < x)
		{
			left = mid+1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}

#endif // __SEQLIST_H__

//SeqList.c
#include<stdio.h>
#include"SeqList.h"

void Test1()
{
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,2);
	PushBack(&seq,3);
	PushBack(&seq,4);
	PopBack(&seq);
	PrintSeqList(&seq);
	Destroy(&seq);
}
void Test2()
{
	SeqList seq;
	int ret;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,2);
	PushBack(&seq,3);
	PushBack(&seq,4);
	PushFront(&seq,0);
	PopFront(&seq);
	Insert(&seq,2,6);
	ret = Find(&seq,6);
	printf("%d\n",ret);
	PrintSeqList(&seq);
}
void Test3()
{
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,2);
	PushBack(&seq,3);
	PushBack(&seq,4);
	PushBack(&seq,4);
	PushBack(&seq,2);
	PushBack(&seq,5);
	PushBack(&seq,6);
	PopBack(&seq);
	Erase(&seq,2);
	Remove(&seq,2);
	RemoveAll(&seq,4);
	PrintSeqList(&seq);
}
void Test4()
{
	SeqList seq;
	int pos;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,2);
	PushBack(&seq,3);
	PushBack(&seq,4);
	PushBack(&seq,4);
	PushBack(&seq,5);
	ReverseList(&seq);
	SortList(&seq);
	pos = BinarySearch(&seq,2);
	printf("%d\n",pos);
	PrintSeqList(&seq);
}

void Test5()
{
	SeqList seq;
	int pos;
	InitSeqList(&seq);
	PushBack(&seq,1);
	PushBack(&seq,2);
	PushBack(&seq,3);
	PushBack(&seq,4);
	PushBack(&seq,4);
	PushBack(&seq,5);
	ReverseList(&seq);
//	SelectSortList(&seq);
//	Select_SortList(&seq);
	pos = BinarySearch(&seq,2);
	printf("%d\n",pos);
	PrintSeqList(&seq);
}
int main()
{

	//Test1(); 
	//Test2();
	//Test3();
	//Test4();
	Test5();
	return 0;
}
时间： 2024-11-12 08:19:30

动态顺序表的相关文章

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

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

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

静态顺序表和动态顺序表

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

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

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

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

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

C++实现动态顺序表

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

实现动态顺序表

SeqList.h #pragma once #include<stdio.h> #include<string.h> #include<assert.h> #include<malloc.h>   typedef int DataType; typedef struct SeqList { DataType* arry; size_t size; size_t capacity; }SeqList;   void check(SeqList*Seq);//

数据结构—动态顺序表的实现

前面我们实现了顺序表,但是我们应该会考虑到一个问题,顺序表一次性创建那么大空间造成的浪费很多,所以在这里,我们需要一个可以动态增长的顺序表来满足我们的需求! 实现中需要注意的是:在这里我们要注意的是首先你应该给顺序表一个容量,当每次满了的时候,进行扩容! 另外,在这里我分别使用了三种的排序算法:插入排序,选择排序,冒泡排序. dynamic_seqlist.h #define _CRT_SECURE_NO_WARNINGS 1 #ifndef __DYNAMIC_SEQLIST_H__ #inc

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