顺序表的静态存储

顺序表：用一段地址连续的存储单元依次存储数据元素的线性结构。

test.h

#pragma once 
#include <stdio.h>
#include <string.h>
#include <assert.h>

#define MAX_SIZE 10
typedef int DataType;

typedef struct Seqlist
{
	DataType array[MAX_SIZE]; //存储数据的数组
	size_t size;             //存储数据的个数
}SeqList;

void Init(SeqList *seq);
void Destory(SeqList *seq);
void Print(SeqList *seq); //效率
//增删查改
void PushBack(SeqList *seq, DataType x);
void PopBack(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);
int Find(SeqList *seq, DataType x);  //查找数据对应的下标
void RemoveAll(SeqList *seq, DataType x);
//排序算法
void BubbleSort(SeqList *seq);
void SelectSort(SeqList *seq);
void InsertSort(SeqList *seq);
size_t BinarySearch(SeqList *seq, DataType x);

test.cpp

#include "test.h"


void Init(SeqList *seq)
{
	assert(seq);
	memset(seq->array,0,sizeof(DataType)*MAX_SIZE);
	seq->size = 0;
}

void Destory(SeqList *seq)
{
	assert(seq);
	memset(seq->array, 0, sizeof(DataType)*MAX_SIZE);
	seq->size = 0;
}

void PushBack(SeqList *seq, DataType x)
{
	assert(seq);
	if (seq->size >= MAX_SIZE) //size是下一个元素待插入的下标，也是数组内含元素个数  
	{
		printf("list is full\n");
		return;
	}
	seq->array[seq->size] = x;
	seq->size++;
}

void PopBack(SeqList *seq)
{
	assert(seq);
	if (seq->size == 0)
	{
		printf("list is empty\n");
		return;
	}
	seq->size--;
}

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

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


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

void Insert(SeqList *seq, size_t pos, DataType x)
{
	assert(seq);
	if (seq->size >= MAX_SIZE)
	{
		printf("list is full\n");
		return;
	}
	if (pos < 0 || pos >seq->size)
	{
		printf("pos illegal input\n");
		return;
	}
	seq->size++;      //得画图
	for (size_t i = seq->size; i > pos; i--)
	{
		seq->array[i] = seq->array[i - 1];
	}
	seq->array[pos] = x;
}

void Remove(SeqList *seq, DataType x)
{
	assert(seq);
	if (seq->size == 0)
	{
		printf("list is empty\n");
		return;
	}
	int i = Find(seq, x);
	if (x, -1)
	{
		Erase(seq, i);
	}
	
}

void Erase(SeqList *seq, size_t pos)
{
	assert(seq);
	if (pos < 0 || pos >seq->size)
	{
		printf("illegal input\n");
		return;
	}
	for (size_t i = pos; i < seq->size; i++)
	{
		seq->array[i] = seq->array[i + 1];
	}
	--seq->size;
}

int Find(SeqList *seq, DataType x)
{
	assert(seq); //assert不能输入什么
	for (size_t i = 0; i <= seq->size; i++)
	{
		if (seq->array[i] == x)
		{
			return i;
		}
	}
	return -1;
}

//void RemoveAll(SeqList *seq, DataType x)
//{
//	int del = Find(seq, x);
//	while (del != -1)
//	{
//		Erase(seq, del);
//		del = Find(seq, x);
//	}
//	return;
//}

void RemoveAll(SeqList *seq, DataType x)
{
	assert(seq);
	size_t i = 0, j = 0;
	for (; i <= seq->size; i++)
	{
		if (seq->array[i] != x)
		{
			seq->array[j] = seq->array[i];
			j++;
		}
	}
	seq->size -= i - j;
}

void swap(int *a, int *b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}


void BubbleSort(SeqList *seq)   //原理
{
	for (unsigned i = 0; i < seq->size; i++)
	{
		for (unsigned j = 0; j < (seq->size - i -1); j++)  
		{
			if (seq->array[j] >= seq->array[j + 1])
			{
				swap(&seq->array[j], &seq->array[j + 1]);
			}
		}
	}
}

void SelectSort(SeqList *seq)  //一次选 最大 最小
{
	assert(seq);
	size_t begin = 0, end = seq->size-1;   //size->6
	size_t min_index, max_index;
	while (begin < end)
	{
		min_index = max_index = begin;
		for (size_t i = begin; i <= end; ++i)
		{
			if (seq->array[i] >seq->array[max_index])
				max_index = i;
			if (seq->array[i] <seq->array[min_index])
				min_index = i;
		}
		swap(&seq->array[begin], &seq->array[min_index]);
		if (begin == max_index)     
		{
			max_index = min_index;
		}
		begin++;
		swap(&seq->array[end], &seq->array[max_index]);
		end--;
	}
}
void InsertSort(SeqList *seq)
{
	for (size_t i = 1; i < seq->size; ++i)
	{
		for (int j = i; j > 0; j--)
		{
			if (seq->array[j] < seq->array[j-1])
			{
				swap(&seq->array[j], &seq->array[j - 1]);
			}
		}
	}
}
size_t BinarySearch(SeqList *seq,DataType x)
{
	int start = 0;
	int end = seq->size - 1;
	int mid;
	while (start < end)
	{
		mid = (start + end) / 2;
		if (seq->array[mid] < x)
		{
			start = mid+1;
		}
		else if(seq->array[mid] > x)
		{
			end = mid-1;
		}
		else
			return mid;
	}
	return -1;
}

main.cpp

#include "test.h"


void Test1()
{
	SeqList s;
	Init(&s);
	PushFront(&s, 8);
	//PushFront(&s, 5);
	//PushFront(&s, 4);
	//PushFront(&s, 7);
	//PushFront(&s, 2);
	//PushFront(&s, 8);

	Print(&s);
	Insert(&s, 0, 10);
	Print(&s);
	//PushFront(&s, 10);
	//PopFront(&s);
	//Insert(&s, 2, 10);
	//Insert(&s, 6, 20);
	//Erase(&s, 3);
    //RemoveAll(&s, 2);
	//SelectSort(&s);
	//InsertSort(&s);
	//BubbleSort(&s);
	//Print(&s);
	//printf("%d\n", BinarySearch(&s, 5));
	//printf("%d\n", BinarySearch(&s, 8));
	//printf("%d\n", BinarySearch(&s, 8));

	//Destory(&s);
}


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

//void Test2()
//{
//	FILE *fp1 = fopen("aaa.txt", "r");
//	FILE *fp2 = fopen("bbb.txt", "w");
//	char c = getc(fp1);
//	while (fp1 != EOF)
//}