动态顺序表的各个函数实现

//基本增删改查,查找,初始化,销毁,排序,查重

程序效果:

1.头文件部分

//头文件
#pragma once

typedef int SLDatatype;

typedef struct SeqList{
		SLDatatype* arr;		//指向动态开辟的数组
		size_t size;            //有效的数据个数
		size_t capicity;		//容量的大小
}SeqList;



//基本增删改查,查找,初始化,销毁.
void SeqListInit(SeqList* Psl,size_t capicity);		                                //初始化
void SeqListDestory (SeqList* psl);													//销毁数据
void SeqListpushBack(SeqList* Psl,SLDatatype data);									//从有效位置开始放元素,尾插
void SeqListpopBack(SeqList* Psl);												    //尾删
void CheckCapacity(SeqList* Psl);													//检测扩容
void SeqListPushFront(SeqList* Psl,SLDatatype data);								//头插元素
void SeqListpopFront (SeqList* Psl);												//头删
int SeqListFind (SeqList* Psl,SLDatatype data);										//查找数据  
void SeqListListInsert (SeqList* Psl,size_t pos,SLDatatype data);                  //任意位置的插入
void SeqListErase(SeqList* Psl,size_t pos);                                         //任意位置的删除
void SeqListRemove (SeqList* Psl,SLDatatype data);                                  //删除第一次出现时候的数据
void SeqListModify(SeqList* Psl,size_t pos,SLDatatype data);                        //修改元素
void SeqListPrint(SeqList* Psl);                                                     //打印函数
int SeqListSize(SeqList* Psl);                                                       //有效元素个数
int SeqListCapacity(SeqList* Psl);                                                   //容量多少
void SeqListBulesort(SeqList* Psl);                                                  //冒泡排序
int  SeqListBinary_Search(SeqList* Psl,SLDatatype search_data);                      //二分查找 
void SeqListRemoveAll(SeqList* Psl,SLDatatype data);                                 //查重
void SeqListCleardata(SeqList* psl);                                                 //清除数据

程序代码

#include <stdio.h>
#include "SeqList.h"
#include <assert.h>	
#include <stdlib.h>

//初始化数据
void SeqListInit(SeqList* Psl,size_t capicity) {
	Psl->capicity = capicity;
	Psl->size = 0;
	Psl->arr = (int*)malloc(sizeof(int)*capicity);
	//判空
	if(Psl->arr == NULL) {
		assert(0);
		return;
	}
}
//销毁数据
void SeqListDestory (SeqList* Psl) {
	assert(Psl);
	free(Psl->arr);
	Psl->arr = NULL;
}

//放置数据
void SeqListpushBack(SeqList* Psl,SLDatatype data){
	SLDatatype i = Psl->size;
	assert(Psl);
	*(Psl->arr+i) = data;
	Psl->size++;
	//检测容量
	CheckCapacity(Psl);
}
//尾删除
void SeqListpopBack(SeqList* Psl){
	assert(Psl);
	Psl->size--;
}
//检测扩容
void CheckCapacity(SeqList* Psl) {
	//定义一个新指针来存放新的地址
	SLDatatype* temp;
	size_t i;
	assert(Psl);
	if(Psl->size == Psl->capicity) {
		Psl->capicity+=10;
		temp = (SLDatatype*)malloc(sizeof(int)*Psl->capicity);
		if(Psl == NULL) {
			assert(0);
			return;
		}
		//把值赋值给新的地址上的元素
		for(i = 0;i<Psl->size;i++) {
			temp[i] = Psl->arr[i];
		}
		//释放
		free(Psl->arr);
		//将新地址赋给psl
		Psl->arr = temp;
	}
	else return ;
}
//头插元素
void SeqListPushFront(SeqList* Psl,SLDatatype data){
	size_t i;
	assert(Psl);
	for(i = Psl->size-1;i<=0;i--) {
		Psl->arr[i+1] = Psl->arr[i];
	}
	*Psl->arr = data;
	Psl->size++;
}
//头删元素
void SeqListpopFront (SeqList* Psl) {
	size_t i = Psl->size-1;
	assert(Psl);
	for(i=1;i<Psl->size;i++) {
		Psl->arr[i-1] = Psl->arr[i];
	}
	Psl->size--;
}
//查找元素
int SeqListFind (SeqList* Psl,SLDatatype data) {
	size_t i;
	for(i = 0;i<Psl->size;i++) {
		if(data == Psl->arr[i]) {
			return i;
		}
	}
	return -1;
}

//任意位置的插入
void SeqListListInsert (SeqList* Psl,size_t pos,SLDatatype data) {
	size_t i = Psl->size-1;
	assert(Psl);
	for(i;i>=pos;i--) {
		Psl->arr[i+1] = Psl->arr[i];
	}
	Psl->arr[pos] = data;
	Psl->size++;
}
//任意位置的删除
void SeqListErase(SeqList* Psl,size_t pos) {
	size_t i;
	for(i = pos;i<Psl->size;i++) {
		Psl->arr[i] = Psl->arr[i+1];
	}
	Psl->size--;
}

//删除第一次出现的数据
void SeqListRemove (SeqList* Psl,SLDatatype data){
	size_t i;
	assert(Psl);
	for(i = 0;i<Psl->size;i++) {
		if(Psl->arr[i] == data) {
			break;
		}
	}
	for(;i<Psl->size;i++) {
		Psl->arr[i] = Psl->arr[i+1];
	}
	Psl->size--;
}

//修改元素
void SeqListModify(SeqList* Psl,size_t pos,SLDatatype data) {
	assert(Psl);
	Psl->arr[pos] = data;
}

//打印函数
void SeqListPrint(SeqList* Psl) {
	size_t i;
	if(Psl->arr == NULL) {
		assert(0);
		return ;
	}
	for( i = 0;i<Psl->size;i++) {
		printf("%d ",Psl->arr[i]);
	}
	printf("\n");

}
//有效元素
int SeqListSize(SeqList* Psl){
	return Psl->size;
}
//返回容量
int SeqListCapacity(SeqList* Psl){
	return Psl->capicity;
}
//冒泡排序
void Swap(SLDatatype* a,SLDatatype* b) {
	SLDatatype temp;
	temp = *a;
	*a = *b;
	*b = temp;
}
void SeqListBulesort(SeqList* Psl) {
	int exchage = 0;
	size_t i;
	size_t j;
	for(i = 0;i<Psl->size-2;i++) {
		exchage = 0;
		for(j = i;j<Psl->size-1;j++) {
			if(Psl->arr[j]>Psl->arr[j+1]) {
				Swap(&Psl->arr[j],&Psl->arr[j+1]);
				exchage = 1;
			}
		}
		if(exchage == 0) {
			break;
		}
	}
}  

//二分查找
int  SeqListBinary_Search(SeqList* Psl,SLDatatype search_data){
	int left = 0;
	int right = Psl->size-1;
	int mid;
	assert(Psl);
	while(left<=right) {
		mid = left+((right-left)>>2);
		if(Psl->arr[mid]<search_data) {
			left = mid + 1;
		}
		else  if(Psl->arr[mid]>search_data) {
			right = mid -1;
		}
		else 
			return mid;
	}
	return -1;
}

//查重,并移除
void SeqListRemoveAll(SeqList* Psl,SLDatatype data) {
	size_t i;
	size_t k = 0;
	for(i = 0;i<Psl->size;i++) {
		if(Psl->arr[i] != data) {
			Psl->arr[k++] = Psl->arr[i];
		}
	}
	Psl->size = k;
}   

void SeqListclear (SeqList* Psl){
	assert(Psl);
	Psl->size = 0;
}	
//测试函数
void TestSeqlist () {
	SeqList s;
	//验证初始化 + 插入元素
	printf("验证初始化+插入元素:\n");
	SeqListInit (&s,10);
	SeqListpushBack (&s,0);
	SeqListpushBack (&s,1);
	SeqListpushBack (&s,2);
	SeqListpushBack (&s,3);
	SeqListpushBack (&s,4);
	SeqListpushBack (&s,5);
	SeqListPrint(&s);

	//验证尾删
	printf("验证尾删:\n");
	SeqListpopBack(&s);
	SeqListPrint(&s);

	//验证头插
	printf("验证头插:\n");
	SeqListPushFront(&s,11);
	SeqListPrint(&s);

	//验证头删
	printf("验证头删:\n");
	SeqListpopFront(&s);
	SeqListPrint(&s);
	
	//查找下标
	printf("查找下标:\n");
	printf("%d是下标为[%d]的元素\n",5,SeqListFind(&s,5));


	//任意位置的插入验证
	printf("任意位置的插入验证 :\n");
	SeqListListInsert(&s,1,6);
	SeqListPrint(&s);

	//任意位置的删除
	printf("任意位置的删除 :\n");
	SeqListErase(&s,1);
	SeqListPrint(&s);

	//删除第一次出现的数据
	printf("删除第一次出现为2的数:\n");
	SeqListRemove(&s,2);
	SeqListPrint(&s);

	//修改数据
	printf("修改数据:");
	SeqListModify(&s,2,6);
	SeqListPrint(&s);

	printf("添加数据验证扩容:\n");
	SeqListpushBack (&s,7);
	SeqListpushBack (&s,6);
	SeqListpushBack (&s,9);
	SeqListpushBack (&s,10);
	SeqListpushBack (&s,12);
	SeqListpushBack (&s,44);
	SeqListpushBack (&s,20);
	SeqListPrint(&s);

	//冒泡
	printf("冒泡排序:");
	SeqListBulesort(&s);
	SeqListPrint(&s);
	

	//二分查找
	printf("二分查找:");
	printf("3的下标为 %d\n",SeqListBinary_Search(&s,3));

	//查重,删除
	printf("查重,删除:");
	SeqListRemoveAll(&s,6);
	SeqListPrint(&s);

	//清空数据
	printf("清空数据:\n");
	SeqListclear(&s);
	SeqListPrint(&s);

	//销毁数据
	/*SeqListDestory(&s);
	SeqListPrint(&s);*/

}
int main () {
	TestSeqlist ();
	return 0;
}