动态顺序表的实现

最新推荐文章于 2022-03-28 13:33:05 发布

L_XRUI

最新推荐文章于 2022-03-28 13:33:05 发布

阅读量1.1k

点赞数

分类专栏： c语言 C语言学习

本文链接：https://blog.csdn.net/L_XRUI/article/details/53940767

版权

C语言学习同时被 2 个专栏收录

17 篇文章 0 订阅

订阅专栏

c语言

15 篇文章 0 订阅

订阅专栏

对顺序表的动态开辟空间实现，并对顺序表进行操作，实现增删查改排序等一系列操作。

代码实现：

头文件SeqList.h：

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

typedef int DataType;
#define MAX_SIZE 3     //初始顺序表大小
#define INC_SZ 3       //每次增容大小
typedef struct SeqList
{
	DataType *array;
	int size;       //顺序表当前有效元素个数
	int capacity;   //顺序表容量大小
}SeqList,*pSeqList;

void InitSeqList(pSeqList pSeq);  //初始化顺序表
void CheakCapacity(pSeqList pSeq);  //检查当前开辟空间
void PushBack(pSeqList pSeq,DataType data);   //尾插
void PopBack(pSeqList pSeq);        //尾删
void PushFront(pSeqList pSeq,DataType data);  //头插
void PopFront(pSeqList pSeq);      //头删
void Print(pSeqList pSeq);        //打印顺序表
void Insert(pSeqList pSeq,int pos,DataType data);   //在指定位置插入
void Erase(pSeqList pSeq,int pos);           //在指定位置上删除
void Remove(pSeqList pSeq,DataType data);   //删除指定元素
int Find(pSeqList pSeq,DataType data);       //查找指定元素
void RemoveAll(pSeqList pSeq,DataType data);   //删除顺序表中所有指定元素
void BubbleSort(pSeqList pSeq);               //冒泡排序
void SelectSort(pSeqList pSeq);               //选择排序
int BinarySerch(pSeqList pSeq,DataType data);  //二分查找
int BinarySerch_p(pSeqList pSeq,int left,int right,DataType data);//递归实现二分查找
int Size(pSeqList pSeq);        //查找表中有效元素个数
void Clear(pSeqList pSeq);      //清空表中元素
void DestroyCapacity(pSeqList pSeq);   //释放动态开辟内存

#endif __SeqList_H__

实现文件SeqList.c:

//功能实现
#include "SeqList.h"
void InitSeqList(pSeqList pSeq)  //初始化顺序表
{
	pSeq->array=(DataType *)malloc(MAX_SIZE*sizeof(DataType));
	if(pSeq->array==NULL)
	{
		printf("out of memory\n");
		exit(EXIT_FAILURE);
	}
	memset(pSeq->array,0,MAX_SIZE*sizeof(DataType));
	pSeq->size=0;
	pSeq->capacity=MAX_SIZE;
}

void CheakCapacity(pSeqList pSeq)  //检查当前开辟空间
{
	assert(pSeq);
	if(pSeq->size== pSeq->capacity)
	{
		 DataType *ptr=(DataType *)realloc(pSeq->array,(pSeq->size+INC_SZ)*sizeof(DataType));
		 if(ptr==NULL)
		 {
			 printf("out of memory\n");
			 exit(EXIT_FAILURE);
		 }
		 pSeq->array=ptr;
		 pSeq->capacity+=INC_SZ;
	}
}

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

void PopBack(pSeqList pSeq)        //尾删
{
	assert(pSeq);
	if(pSeq->size<1)
	{
		printf("表为空\n");
		return;
	}
	pSeq->size--;
}

void PushFront(pSeqList pSeq,DataType data)  //头插
{
	int i=0;
	assert(pSeq);
	CheakCapacity(pSeq);
	for(i=pSeq->size-1;i>=0;i--)
	{
		pSeq->array[i+1]=pSeq->array[i];
	}
	pSeq->array[0]=data;
	pSeq->size++;
}

void PopFront(pSeqList pSeq)      //头删
{
	int i=0;
	assert(pSeq);
	if(pSeq->size<1)
	{
		printf("表为空\n");
		return;
	}
	for(i=0;i<pSeq->size-1;i++)
	{
		pSeq->array[i]=pSeq->array[i+1];
	}
	pSeq->size--;
}

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

void Insert(pSeqList pSeq,int pos,DataType data)   //在指定位置插入
{
	int i=0;
	assert(pSeq||(pos>=0&&pos<=pSeq->size));
	CheakCapacity(pSeq);
	for(i=pSeq->size-1;i>=pos;i--)
	{
		pSeq->array[i+1]=pSeq->array[i];
	}
	pSeq->array[pos]=data;
	pSeq->size++;
}

void Erase(pSeqList pSeq,int pos)           //在指定位置上删除
{
	int i=0;
	assert(pSeq||(pos>=0&&pos<=pSeq->size-1));
	for(i=pos;i<pSeq->size-1;i++)
	{
		pSeq->array[i]=pSeq->array[i+1];
	}
	pSeq->size--;
}

void Remove(pSeqList pSeq,DataType data)   //删除指定元素
{
	int ret=Find(pSeq,data);
	assert(pSeq);
	if(ret!=-1)
	{
		Erase(pSeq,ret);
	}
}

int Find(pSeqList pSeq,DataType data)       //查找指定元素
{
	int i=0;
	assert(pSeq);
	for(i=0;i<pSeq->size;i++)
	{
		if(data==pSeq->array[i])
		{
			return i;
		}
	}
	return -1;
}

void RemoveAll(pSeqList pSeq,DataType data)   //删除顺序表中所有指定元素
{
	int icount=0;
	int i=0;
	assert(pSeq);
	if(pSeq->size<1)
	{
		printf("表为空\n");
		return;
	}
	for(i=0;i<pSeq->size;i++)
	{
		if(data==pSeq->array[i])
		{
			icount++;
		}
		else
		{
			pSeq->array[i-icount]=pSeq->array[i];
		}
	}
	pSeq->size-=icount;
}

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

void BubbleSort(pSeqList pSeq)               //冒泡排序2
{
	int i=0;
	int flag=1;
	int input=0;
	assert(pSeq);
	printf("请输入选择（1.升序***2.降序）：");
	scanf("%d",&input);
	for(i=0;i<pSeq->size-1;i++)
	{
		int j=0;
		flag=1;
	    for(j=0;j<pSeq->size-1-i;j++)
		{
			if(input==1)
			{
				if(pSeq->array[j]>pSeq->array[j+1])
				{
					DataType tmp=pSeq->array[j+1];
				    pSeq->array[j+1]=pSeq->array[j];
				    pSeq->array[j]=tmp;
				    flag=0;
			    }
			}
			else
			{
				if(pSeq->array[j]<pSeq->array[j+1])
				{
					DataType tmp=pSeq->array[j+1];
				    pSeq->array[j+1]=pSeq->array[j];
				    pSeq->array[j]=tmp;
				    flag=0;
				}
			}
			
		}
	    if(flag==1)
		{
			return;
		}	
	}
}
		


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

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

int BinarySerch_p(pSeqList pSeq,int left,int right,DataType data)//递归实现
{
	int mid=left+((right-left)>>1);
	if(left>right)
	{
		return -1;
	}
	if(pSeq->array[mid]==data)
	{
		return mid;
	}
	else if(pSeq->array[mid]>data)
	{
		return BinarySerch_p(pSeq,left,mid-1,data);
	}
	else
	{
		return BinarySerch_p(pSeq,mid+1,right,data);
	}
}
int Size(pSeqList pSeq)        //查找表中有效元素个数
{
	assert(pSeq);
	return pSeq->size;
}
void Clear(pSeqList pSeq)      //清空表中元素
{
	assert(pSeq);
	pSeq->size=0;
}

void DestroyCapacity(pSeqList pSeq)   //释放动态开辟内存
{
	if(pSeq->array!=NULL)
	{
		free(pSeq->array);
		pSeq->array=NULL;
	}

}

测试文件test.c:

#include "SeqList.h"
void test1()
{
	SeqList Seq;
	InitSeqList(&Seq);
	PushBack(&Seq,1);
	PushBack(&Seq,2);
	PushBack(&Seq,3);
	PushBack(&Seq,4);
	PushBack(&Seq,5);
	PushBack(&Seq,6);
	PushBack(&Seq,7);
	PushBack(&Seq,8);
	Print(&Seq);
    PopBack(&Seq);  
	PopBack(&Seq);
	PopBack(&Seq);
	Print(&Seq);
	DestroyCapacity(&Seq);
}
void test2()
{
	SeqList Seq;
	InitSeqList(&Seq);
	PushBack(&Seq,1);
	PushBack(&Seq,2);
	PushBack(&Seq,3);
	Print(&Seq);
	PushFront(&Seq,4);
	PushFront(&Seq,5);
	PushFront(&Seq,6);
	Print(&Seq);
    PopFront(&Seq);  
	PopFront(&Seq);
	Print(&Seq);
	PopBack(&Seq);
	Print(&Seq);
	DestroyCapacity(&Seq);
}
void test3()
{
	SeqList Seq;
	InitSeqList(&Seq);
	PushBack(&Seq,2);
	PushBack(&Seq,2);
	PushBack(&Seq,3);
	Print(&Seq);
    Insert(&Seq,1,1); 
	Insert(&Seq,4,4);
	Print(&Seq);
	Erase(&Seq,1);
	Print(&Seq);
	Remove(&Seq,4);
	Print(&Seq);
	PushBack(&Seq,4);
	PushBack(&Seq,5);
	PushBack(&Seq,2);
	PushBack(&Seq,2);
	PushBack(&Seq,4);
	PushBack(&Seq,2);
	Print(&Seq);
	RemoveAll(&Seq,2);
	Print(&Seq);
	DestroyCapacity(&Seq);
}
void test4()
{
	SeqList Seq;
	int ret=0;
	int ret1=0;
	int sz=0;
	InitSeqList(&Seq);
	PushBack(&Seq,6);
	PushBack(&Seq,1);
	PushBack(&Seq,5);
	PushBack(&Seq,7);
	PushBack(&Seq,3);
	PushBack(&Seq,4);
	PushBack(&Seq,8);
	PushBack(&Seq,2);
	Print(&Seq);
	SelectSort(&Seq);
	//BubbleSort(&Seq);
	Print(&Seq);
	ret=BinarySerch(&Seq,1);
	printf("ret=%d\n",ret);
	sz=Size(&Seq);
	ret1=BinarySerch_p(&Seq,0,sz-1,8);
	printf("ret1=%d\n",ret1);
	DestroyCapacity(&Seq);
}
int main()
{
	printf("test1:\n");
	test1();
	printf("\ntest2:\n");
	test2();
	printf("\ntest3:\n");
	test3();
	printf("\ntest4:\n");
	test4();
	system("pause");
	return 0;
}

L_XRUI

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
动态顺序表的实现

对顺序表的动态开辟空间实现，并对顺序表进行操作，实现增删查改排序等一系列操作。代码实现：头文件SeqList.h：#include #include #include #include typedef int DataType;#define MAX_SIZE 3 //初始顺序表大小#define INC_SZ 3 //每次增容大小typedef s
复制链接

扫一扫