静态顺序表

顺序表是指用一段地址连续的存储单元依次存储数据元素的线性结构，在计算机中以数组的形式保存。

顺序表有静态存储和动态存储俩种方式。

//顺序表的静态存储

SeqList.h

#ifndef __SEQLIPST_H__
#define __SEQLIPST_H__

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
#pragma warning(disable:4996)

#define MAX_SIZE 100
typedef int DataType;

typedef struct SeqList  //顺序表
{
	DataType array[MAX_SIZE];
	size_t size;
}SeqList,*pSeqLipst;

void InitSeqList(pSeqLipst seq);//初始顺序表
void DestorySeqList(pSeqLipst seq);//销毁顺序表

void PushBack(pSeqLipst seq, DataType x);
void PopBack(pSeqLipst seq);
void PushFront(pSeqLipst seq, DataType x);
void PopFront(pSeqLipst seq);

void Insert(pSeqLipst seq, size_t pos, DataType x);//指定位置插入
int Find(pSeqLipst seq, DataType x);//寻找
void Erase(pSeqLipst seq, size_t pos);//删除指定位置
void Remove(pSeqLipst seq, DataType x);//删除x
void RemoveAll(pSeqLipst seq, DataType x);//删除所有x

void BuffleSort(pSeqLipst seq);//冒泡
int BinarySearch(pSeqLipst seq, DataType x);//二分查找
int BinarySearchD(pSeqLipst seq, size_t begin, size_t end, DataType x); // 二分查找 递归
void PrintSeqList(pSeqLipst seq);//输出顺序表

#endif __SEQLIPST_H__

函数实现

SeqList.c

#include"SeqList.h"
#pragma warning(disable:4996)

void PrintSeqList(pSeqLipst seq)//输出顺序表
{
	assert(seq);
	for (size_t i = 0; i < (seq->size); i++)
	{
		printf("%d",seq->array[i]);
	}
	printf("\n");
}

void InitSeqList(pSeqLipst seq)//初始顺序表
{
	assert(seq);
	memset(seq->array, 0, sizeof(DataType)*(MAX_SIZE));
	seq->size = 0;
}

void DestorySeqList(pSeqLipst seq)//销毁顺序表
{
	assert(seq);
	seq->size = 0;
}

void PushBack(pSeqLipst seq, DataType x)
{
	assert(seq);
	if (seq->size >= MAX_SIZE)
	{
		printf("The SeqList is full\n");
		return;
	}
	seq->array[seq->size] = x;
	seq->size++;
}

void PopBack(pSeqLipst seq)
{
	assert(seq);
	if (seq->size <= 0)
	{
		printf("The Seqlist is empty");
		return ;
	}

	seq->size--;
}

void PushFront(pSeqLipst seq, DataType x)
{
	assert(seq);
	if (seq->size >= MAX_SIZE)
	{
		printf("The SeqList is full\n");
		return;
	}
	int end = seq->size;
	while (end)
	{
		seq->array[end] = seq->array[end - 1];
		--end;
	}
	seq->size++;
	seq->array[0] = x;
}

void PopFront(pSeqLipst seq)
{
	assert(seq);
	if (seq->size <= 0)
	{
		printf("The Seqlist is empty");
		return;
	}
	for (size_t i = 0; i < seq->size - 1; i++)
	{
		seq->array[i] = seq->array[i + 1];
	}
	seq->size--;
}

void Insert(pSeqLipst seq, size_t pos, DataType x)//指定位置插入
{
	assert(seq);
	assert(pos>0);
	assert(pos <= seq->size);
	if (seq->size >= MAX_SIZE)
	{
		printf("The SeqList is full\n");
		return;
	}
	size_t end = seq->size;
	while (end >= pos)
	{
		seq->array[end] = seq->array[end - 1];
		--end;                                        
	}
	seq->size++;
	seq->array[pos-1] = x;
}

int Find(pSeqLipst seq, DataType x)//寻找
{
	assert(seq);
	for (size_t i = 0; i < seq->size; i++)
	{
		if (seq->array[i] == x)
		{
			printf("找到了\n");
			return i + 1;                                       
		}
	}
	printf("没找到");
	return -1;
}

void Erase(pSeqLipst seq, size_t pos)
{
	assert(seq);
	assert(pos>0);
	assert(pos <= seq->size);
	if (seq->size <= 0)
	{
	printf("The Seqlist is empty");
	return;
	}

	for (size_t i = pos; i < seq->size - 1; i++)
	{
	   seq->array[i] = seq->array[i+1];
	}
	seq->size--;
}

void Remove(pSeqLipst seq, DataType x)//删除x
{
	assert(seq);
	if (seq->size <= 0)
	{
		printf("The Seqlist is empty");
		return;
	}
	for (size_t i = 0; i < seq->size; i++)
	{
		if (seq->array[i] == x)
		{
			for (size_t j = i; j < seq->size; j++)
			{
				seq->array[j] = seq->array[j + 1];
			}
		}
	}
	seq->size--;
}
void RemoveAll(pSeqLipst seq, DataType x)//删除所有x     
{
	assert(seq);
	if (seq->size <= 0)
	{
		printf("The Seqlist is empty");
		return;
	}
	int i = 0;
	size_t j = 0;
	int count = 0;
	for (i = 0; j <= seq->size - 1; i++)
	{
		if (seq->array[i] == x)
		{
			count++;
		}
		else
		{
			seq->array[j] = seq->array[i];
			j++;
		}
	}
	seq->size -= count;
}

void BuffleSort(pSeqLipst seq)//冒泡
{
	assert(seq);
	if (seq->size <= 0)
	{
		printf("The Seqlist is empty");
		return;
	}
	for (size_t i = 0; i < seq->size - 1; i++)
	{
		for (size_t j = 0; j <seq->size-1-i; j++)
		{
			if (seq->array[j] > seq->array[j + 1])
			{
				int tmp = seq->array[j];
				seq->array[j] = seq->array[j + 1];
				seq->array[j + 1] = tmp;
			}
		}

	}
}

int BinarySearch(pSeqLipst seq, DataType x)//二分查找
{
	assert(seq);
	if (seq->size <= 0)
	{
		printf("The Seqlist is empty");
		return -1;
	}
	int begin = 0;
	int end = seq->size - 1;
	while (begin <= end)
	{
		int mid = begin + (end - begin) / 2;
		if (x > seq->array[mid])
		{
			begin = mid + 1;
		}
		else if (x < seq->array[mid])
		{
			end = mid - 1;
		}
		else
		{
			return mid + 1;
		} //?????????????????
	}
	return -1;
}

int BinarySearchD(pSeqLipst seq, size_t begin, size_t end, DataType x)//二分查找 递归
{
	assert(seq);
	if (seq->size <= 0)
	{
		printf("The Seqlist is empty");
		return -1;
	}
	int mid = begin + (end - begin) / 2;
	if (seq->array[mid] == x)
	{
		return mid + 1;
	}
	else if (x < seq->array[mid])
	{
		return BinarySearchD(seq, begin, mid - 1, x);
	}
	else if (x>seq->array[mid])
	{
		return BinarySearchD(seq, mid + 1, end, x);
	}
	else
		return -1;
}

测试部分

text.c

#include"SeqList.h"
#pragma warning(disable:4996)
int main()
{
	SeqList seq;
	InitSeqList(&seq);
	PushBack(&seq, 1);
	PushBack(&seq, 2);
	PushBack(&seq, 3);
	PrintSeqList(&seq);
	PopBack(&seq);
	PrintSeqList(&seq);
	PushFront(&seq, 3);
	PushFront(&seq, 4);
	PrintSeqList(&seq);
	PopFront(&seq);
	PrintSeqList(&seq);
	//Remove(&seq, 3);
	//RemoveAll(&seq, 3);
	//PrintSeqList(&seq);
	BuffleSort(&seq);
	PrintSeqList(&seq);
	Erase(&seq, 1);
	PrintSeqList(&seq);
	system("pause\n");
	return 0;
}