简单实现动态顺序表

SeqList.h

#pragma once

#include<stdio.h>

typedef int DataType;

typedef struct SeqList{
	DataType *arr;
	size_t size;
	size_t capicity;
}SeqList;

void InitSeqList(SeqList *seq);//初始化
void DestorySeqList(SeqList *seq);//清空顺序表
void CheckCapicity(SeqList *seq);//检测容量是否已满
void PushBack(SeqList *seq, DataType x);//尾插
void PrintSeqList(SeqList *seq);//输出
void PopBack(SeqList *seq);//尾删
void PrintSeqList(SeqList *seq);//输出
void PushFront(SeqList *seq, DataType x);//头插
void PopFront(SeqList *seq);//头删
void Insert(SeqList *seq, size_t pos, DataType x);//中间插
void Remove(SeqList *seq, DataType x);//指定数删
void Erase(SeqList *seq, size_t pos);//指定位置删
void RemoveAll(SeqList *seq, DataType x);//删除所有的x
int Find(SeqList *seq, DataType x);//找到指定数
void SelectSort(SeqList *seq);//选择排序(同时找到最大数和最小数）
int BinarySearch(SeqList *seq, DataType x);//二分查找
int BinarySearch1(SeqList *seq, DataType x, int begin, int end);//二分查找递归

test.cpp

#include"SeqList.h"
#include<Windows.h>

int main()
{
	SeqList s1;
	InitSeqList(&s1);
	PushBack(&s1, 0);
	PushBack(&s1, 1);
	PushBack(&s1, 2);
	PushBack(&s1, 3);

	PushFront(&s1, 0);
	PushFront(&s1, 1);
	PushFront(&s1, 2);
	PushFront(&s1, 2);
	PushFront(&s1, 4);
	PushFront(&s1, 2);

	Insert(&s1, 5, 11);

	Remove(&s1,5);
	Erase(&s1, 5);
	RemoveAll(&s1, 2);
	SelectSort(&s1);
	BinarySearch(&s1, 8);
	PrintSeqList(&s1);

	system("pause");
	return 0;
}

SeqList.cpp

#include"SeqList.h"
#include<assert.h>
#include<stdlib.h>
void InitSeqList(SeqList *seq)
{
	assert(seq);

	seq->arr = (DataType *)malloc(3 * sizeof(DataType));
	assert(seq->arr);
	seq->size = 0;
	seq->capicity = 3;
}

void DestorySeqList(SeqList *seq)
{
	assert(seq);
	if (seq->arr)
		free(seq->arr);
	seq->arr = NULL;
	seq->size = 0;
	seq->capicity = 0;
}

void CheckCapicity(SeqList *seq)
{
	assert(seq);

	if (seq->size >= seq->capicity)
	{
		seq->arr = (DataType*)realloc(seq->arr, sizeof(DataType)*seq->capicity * 2);
		assert(seq->arr);
		seq->capicity *= 2;
	}
}

void PrintSeqList(SeqList *seq)//输出
{
	size_t i = 0;
	for (i = 0; i < seq->size; i++)
	{
		printf("%d ", seq->arr[i]);
	}
	printf("\n");
}

void PushBack(SeqList *seq, DataType x)
{
	assert(seq);
	seq->arr[seq->size] = x;
	seq->size++;
	CheckCapicity(seq);
}

void PopBack(SeqList *seq)//尾删
{
	assert(seq);

	if (seq->size == 0)
	{
		printf("SeqList is null!\n");
		return;
	}
	seq->size--;
}

void PushFront(SeqList *seq, DataType x)//头插
{
	assert(seq);

	int end = seq->size;
	while (end > 0)
	{
		seq->arr[end] = seq->arr[end - 1];
		end--;
	}
	seq->arr[0] = x;
	seq->size++;
	CheckCapicity(seq);
}

void PopFront(SeqList *seq)//头删
{
	assert(seq);

	if (seq->size == 0)
	{
		printf("SeqList is null!\n");
		return;
	}

	size_t begin = 0;
	while (begin < seq->size)
	{
		seq->arr[begin] = seq->arr[begin + 1];
		begin++;
	}
	seq->size--;
}

void Insert(SeqList *seq, size_t pos, DataType x)//中间插
{
	assert(seq);

	size_t end = seq->size;
	while (end >= pos)
	{
		seq->arr[end] = seq->arr[end - 1];
		end--;
	}
	seq->arr[pos - 1] = x;
	seq->size++;
	CheckCapicity(seq);
}


int Find(SeqList *seq, DataType x)//找到指定数
{
	assert(seq);

	if (seq->size == 0)
	{
		printf("SeqList is null!\n");
		return -1;
	}

	for (size_t i = 0; i < seq->size; i++)
	{
		if (seq->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

void Remove(SeqList *seq, DataType x)//指定数删
{
	assert(seq);

	int ret = Find(seq, x);
	if (ret != -1)
	{
		while ((size_t)ret < seq->size)
		{
			seq->arr[ret] = seq->arr[ret + 1];
			ret++;
		}
		seq->size--;
	}
	else
	{
		printf("Not found!\n");
	}
}

void Erase(SeqList *seq, size_t pos)//指定位置删
{
	assert(seq);

	if (seq->size == 0)
	{
		printf("SeqList is null!\n");
		return;
	}
	//size_t end = pos;
	while (pos <= seq->size)
	{
		seq->arr[pos - 1] = seq->arr[pos];
		pos++;
	}
	seq->size--;
}

void RemoveAll(SeqList *seq, DataType x)//删除所有的x
{
	assert(seq);

	size_t i = 0;
	size_t j = 0;
	size_t count = 0;
	while (i < seq->size)
	{
		if (seq->arr[i] == x)
		{
			i++;
			count++;
		}
		else
		{
			seq->arr[j] = seq->arr[i];
			i++;
			j++;
		}
	}
	seq->size -= count;
}

void swap(int* x, int * y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

void SelectSort(SeqList *seq)//选择排序（优化：同时找两个）
{
	assert(seq);

	int maxdex = 0;
	int mindex = 0;
	size_t begin = 0;
	size_t end = seq->size - 1;
	size_t i = 0;
	for (i = begin; i < end; i++)
	{
		maxdex = i;
		mindex = i;
		int j = 0;
		for (j = i + 1; j <= end; j++)
		{
			if (seq->arr[j] < seq->arr[mindex])
				mindex = j;
		}
		for (j = j + 1; j <= end; j++)
		{
			if (seq->arr[j] > seq->arr[maxdex])
				maxdex = j;
		}
		swap(&seq->arr[i], &seq->arr[maxdex]);
		if (maxdex == begin)
		{
			maxdex = mindex;
		}
		swap(&seq->arr[i], &seq->arr[mindex]);
	}
}

int BinarySearch(SeqList *seq, DataType x)//二分查找非递归
{
	assert(seq);

	SelectSort(seq);

	int begin = 0;
	int end = seq->size - 1;
	while (begin <= end)
	{
		int mid = begin + ((end - begin) >> 1);
		if (seq->arr[mid] < x)
		{
			begin = mid + 1;
		}
		else if (seq->arr[mid]>x)
		{
			end = mid - 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}

int BinarySearch1(SeqList *seq, DataType x, int begin, int end)//二分查找递归
{
	assert(seq);
	SelectSort(seq);

	int mid = begin + ((end - begin) >> 1);
	if (seq->arr[mid] < x)return BinarySearch1(seq, x, mid + 1, end);
	else if (seq->arr[mid]>x)return BinarySearch1(seq, x, begin, mid - 1);
	else return mid;
}