C语言实现顺序表

SeqList.h

#pragma once

typedef int DataType;
#define N 10
typedef struct SeqList
{
	DataType _a[N];
	size_t _size;
}SeqList;

void SeqListInit(SeqList* pSeq);//初始化
void SeqListPushBack(SeqList* pSeq, DataType x);//尾插
void SeqListPushFront(SeqList* pSeq, DataType x);//头插
void SeqListPopBack(SeqList* pSeq);//尾删
void SeqListPopFront(SeqList* pSeq);//头删
void SeqListInsert(SeqList* pSeq, size_t pos, DataType x);//任意位置插入一个元素
void SeqListErase(SeqList* pSeq, size_t pos);//任意位置删除一个元素
int SeqListFind(SeqList* pSeq, DataType x);//查找一个元素
void SeqListModify(SeqList* pSeq, size_t pos, DataType x);//修改某个位置的元素
void SeqListRemove(SeqList* pSeq, DataType x);//删除第一个遇到的x
void SeqListRemoveAll(SeqList* pSeq, DataType x);//删除所有的x
void SeqListBubbleSort(SeqList* pSeq);//冒泡排序
void SeqListSelectSort(SeqList* pSeq);//选择排序
int SeqListBinarySearch(SeqList* pSeq, DataType key);//二分查找
void Swap(DataType* x, DataType* y);//交换两个数


void SeqListInit(SeqList* pSeq)
{
	memset(pSeq->_a, 0, sizeof(DataType)*N);
	pSeq->_size = 0;
}


void SeqListPrint(SeqList* pSeq)
{
	size_t i = 0;
	for (; i < pSeq->_size; i++)
	{
		printf("%d ", pSeq->_a[i]);
	}
	printf("\n");
}

void SeqListPushBack(SeqList* pSeq, DataType x)
{
	assert(pSeq);
	if (pSeq->_size >= N)
	{
		printf("SeqList is full\n");
		return;
	}
	else
	{
		pSeq->_a[pSeq->_size] = x;
		pSeq->_size++;
	}
}

void SeqListPushFront(SeqList* pSeq, DataType x)
{
	assert(pSeq);
	if ((pSeq->_size) >= N)
	{
		printf("SeqList is full\n");
	}
	else
	{
		size_t end = pSeq->_size - 1;
		while (end >= 0)
		{
			pSeq->_a[end + 1] = pSeq->_a[end];
			end--;
		}
		pSeq->_a[0] = x;
		pSeq->_size++;
	}
}

void SeqListPopBack(SeqList* pSeq)
{
	assert(pSeq);
	if ((pSeq->_size) == 0)
	{
		printf("SeqList is empty\n");
		return;
	}
	else
	{
		//pSeq->_a[pSeq->_size - 1] = 0;
		pSeq->_size--;
	}
}

void SeqListPopFront(SeqList* pSeq)
{
	assert(pSeq);
	if (pSeq->_size == 0)
	{
		printf("SeqList is empty\n");
		return;
	}
	else
	{
		size_t i = 0;
		for ( ; i < pSeq->_size - 1; i++)
		{
			pSeq->_a[i] = pSeq->_a[i + 1];
		}
		pSeq->_size--;
	}
}

void SeqListInsert(SeqList* pSeq, size_t pos, DataType x)
{
	assert(pSeq);
	if (pSeq->_size >= N)
	{
		printf("SeqList is full\n");
	}
	else
	{
		size_t end = pSeq->_size - 1;
		for ( ; end >= pos;)
		{
			pSeq->_a[end + 1] = pSeq->_a[end];
			end--;
		}
		pSeq->_a[pos] = x;
		pSeq->_size++;
	}
}

void SeqListErase(SeqList* pSeq, size_t pos)
{
	assert(pSeq && pSeq->_size);
	if (pSeq->_size == 0)
	{
		printf("SeqList is empty\n");
		return;
	}
	else
	{
		size_t i = pos;
		while (i < pSeq->_size - 1)
		{
			pSeq->_a[i] = pSeq->_a[i + 1];
			i++;
		}
		pSeq->_size--;
	}
}

int SeqListFind(SeqList* pSeq, DataType x)
{
	assert(pSeq);
	size_t i = 0;
	for (; i < pSeq->_size - 1; i++)
	{
		if (pSeq->_a[i] == x)
		{
			return i;
		}
		return -1;
	}
}

void SeqListModify(SeqList* pSeq, size_t pos, DataType x)
{
	assert(pSeq && pos < pSeq->_size);
	pSeq->_a[pos] = x;
}

void SeqListRemove(SeqList* pSeq, DataType x)
{
	assert(pSeq);
	size_t tmp = 0;
	if (pSeq->_size == 0)
	{
		printf("SeqList is empty\n");
		return;
	}
	else
	{
		tmp = SeqListFind(pSeq, x);//找到第一个元素的位置
		SeqListErase(pSeq, tmp);//删除这个位置的元素
	}
}

void SeqListRemoveAll(SeqList* pSeq, DataType x)
{
	size_t start = 0;
	assert(pSeq);
	for (; start < pSeq->_size; start++)
	{
		if (x == pSeq->_a[start])
		{
			SeqListErase(pSeq, start);
		}
	}
}

//void SeqListRemoveAll(SeqList* pSeq, DataType x)
//{
//	size_t index = 0, i = 0;
//	int count = 0;
//	for (; i < pSeq->_size - 1; i++)
//	{
//		if (pSeq->_a[i] == x)
//		{
//			pSeq->_a[index] = pSeq->_a[x];
//			count++;
//		}
//		pSeq->_size -= count;
//	}
//}

void Swap(DataType* left, DataType* right)
{
	DataType tmp = *left;
	*left = *right;
	*right = tmp;
}

void SeqListBubbleSort(SeqList* pSeq)
{
	size_t i = 0;
	size_t j = 0;
	for (; i < pSeq->_size; i++)
	{
		for (; i < pSeq->_size - 1 - i; j++)
		{
			if (pSeq->_a[j]>pSeq->_a[j + 1])
			{
				Swap(&pSeq->_a[j], &pSeq->_a[j + 1]);
			}
		}
	}
}

void SeqListSelectSort(SeqList* pSeq)
{
	int left = 0; int right = pSeq->_size - 1;
	while (left < right)
	{
		int max = left, min = left;
		int i = left;
		while (i <= right)
		{
			if (pSeq->_a[i] > pSeq->_a[max])
				max = i;
			if (pSeq->_a[i] > pSeq->_a[min])
				min = i;
			i++;
		}
		Swap(&pSeq->_a[left], &pSeq->_a[min]);
		Swap(&pSeq->_a[right], &pSeq->_a[max]);
	}
}


int SeqListBinarySearch(SeqList* pSeq, DataType key)
{
	size_t left = 0;
	size_t right = 0;
	int mid =( left + (right - left)) >>1;
	while (left < right)
	{
		if (pSeq->_a[mid] = key)
			return mid;
		if (pSeq->_a[mid] < key)
		{
			left = mid + 1;
		}
		else
		{
			right = mid - 1;
		}
	}
}

void test()
{
	SeqList s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPushBack(&s, 2);
	SeqListPrint(&s);

	//SeqListPushFront(&s, 4);
	//SeqListPushFront(&s, 3);
	//SeqListPushFront(&s, 2);
	//SeqListPushFront(&s, 1);
	//SeqListPrint(&s);

	SeqListPopBack(&s);
	SeqListPopBack(&s);
	SeqListPrint(&s);

	SeqListPopFront(&s);
	SeqListPrint(&s);

	SeqListInsert(&s, 2, 5);
	SeqListPrint(&s);

	SeqListErase(&s, 2);
	SeqListPrint(&s);

	SeqListRemove(&s, 2);
	SeqListRemoveAll(&s, 2);
	SeqListPrint(&s);
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
#include"SeqList.h"

int main()
{
	test();
	system("pause");
	return 0;
}