静态顺序表

Seqlist.h

#pragma once
#include <stdio.h>
#define MAX_SIZE 100
typedef int DataType;
typedef struct Seqlist
{
	DataType _arr[MAX_SIZE];
	int _size;
}Seqlist;

void SeqlistInit(Seqlist *ps);//初始化链表
void SeqlistPushBack(Seqlist *ps, int data);//尾插
void SeqlistPushFront(Seqlist *ps, int data);//头插
void SeqlistInsert(Seqlist *ps,int pos, int data);//任意位置插
// 尾部删除 
void SeqListPopBack(Seqlist *ps);
// 头部删除 
void SeqListPopFront(Seqlist *ps);
// 按下标删除，pos 的范围是 [0, size) 
void SeqListErase(Seqlist *ps, int pos);
// 按值删除，只删遇到的第一个 
void SeqListRemove(Seqlist *ps, DataType data);
// 按值查找，返回第一个找到的下标，如果没找到，返回 -1 
int SeqListFind(Seqlist *ps, DataType data);
//打印
void SeqListPrint(Seqlist *ps);
// 按值删除，删除所有的 
void SeqListRemoveAll(Seqlist *ps, DataType data);
// 清空 
void SeqListClear(Seqlist *ps);
// 返回数量 
int SeqListSize(Seqlist *ps);
// 判断是否为空，1 表示空， 0 表示不空 
int SeqListEmpty(Seqlist *ps);
//选择排序
void SelectSort(Seqlist *ps);
//冒泡排序
void BubbleSort(Seqlist *ps);

Seqlist.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "seqlist.h"
#include <assert.h>
#include <memory.h>
void SeqlistInit(Seqlist *ps)//传进来的链表首先要初始化
{
	if (NULL == ps)
	{
		return;//链表为空
	}
	ps->_size = 0;
}

void SeqListPrint(Seqlist *ps)
{
	assert(ps != NULL);
	int i = 0;
	for (i = 0; i < ps->_size; i++)
	{
		printf("%d->", ps->_arr[i]);
	}
	printf("\n");
}

void SeqlistPushBack(Seqlist *ps, int data)
{
	if (NULL == ps)
	{
		return;//链表为空
	}
	if (ps->_size == MAX_SIZE)
	{
		printf("链表已满\n");
		return;
	}
	ps->_arr[ps->_size] = data;
	ps->_size++;
}

void SeqlistPushFront(Seqlist *ps, int data)//头插
{
	if (NULL == ps)
	{
		return;
	}
	if (ps->_size == MAX_SIZE)
	{
		printf("链表已满\n");
		return;
	}
	int i;
	for (i = ps->_size; i > 0; i--)
	{
		ps->_arr[i] = ps->_arr[i - 1];
	}
	ps->_arr[0] = data;
	ps->_size++;
}

void SeqlistInsert(Seqlist *ps,int pos, int data)
{
	assert(ps != NULL);
	assert(pos > 0 && pos < ps->_size);
	int i = 0;
	for (i = 0; i < ps->_size - pos; i++)
	{
		ps->_arr[ps->_size - i] = ps->_arr[ps->_size - 1 - i];
	}
	ps->_arr[pos] = data;
	ps->_size++;
}

void SeqListPopBack(Seqlist *ps)
{
	assert(ps != NULL);
	ps->_size--;
}


void SeqListPopFront(Seqlist *ps)
{
	assert(ps != NULL);
	int i;
	for (i = 0; i < ps->_size; i++)
	{
		ps->_arr[i] = ps->_arr[i + 1];	
	}
	ps->_size--;
}

// 按下标删除，pos 的范围是 [0, size) 
void SeqListErase(Seqlist *ps, int pos)
{
	assert(ps != NULL);
	assert(pos > 0 && pos < ps->_size);
	int i;
	for (i = pos; i < ps->_size; i++)
	{
		ps->_arr[i] = ps->_arr[i + 1];
	}
	ps->_size--;
}

// 按值查找，返回第一个找到的下标，如果没找到，返回 -1 
int SeqListFind(Seqlist *ps, DataType data)
{
	assert(ps != NULL);
	int i;
	for (i = 0; i < ps->_size; i++)
	{
		if (ps->_arr[i] == data)
			return i;
	}
		return -1;
}
// 按值删除，只删遇到的第一个 
void SeqListRemove(Seqlist *ps, DataType data)
{
	assert(ps != NULL);
	int i = SeqListFind(ps, data);
	if (i != -1)
	{
		SeqListErase(ps, i);
	}
	return;
}

// 按值删除，删除所有的 
void SeqListRemoveAll(Seqlist *ps, DataType data)
{
	assert(ps != NULL);
	int i; int count = 0;
	for (i = 0; i < ps->_size; i++)
	{
		if (ps->_arr[i] == data)
			count++;
		else 
			ps->_arr[i - count] = ps->_arr[i];
	}
	ps->_size -= count;
	return; 
}

// 清空 
void SeqListClear(Seqlist *ps)
{
	memset(ps, 0, ps->_size);
}

int SeqListSize(Seqlist *ps)
{
	assert(ps != NULL);
	printf("ps->_size = %d\n", ps->_size);
	return 0;
}

//判断是否为空
int SeqListEmpty(Seqlist *ps)
{
	assert(ps != NULL);
	if (ps->_size == 0)
		return 1;
	else
		return-1;
}

// 使用冒泡排序对顺序表中的元素进行排序   
void BubbleSort(Seqlist *ps)
{
	if (NULL == ps)
	{
		return;
	}
	int i = 0, j = 0, count = 0;
	for (i = 0; i < ps->_size - 1; i++)
	{
		count = 0;
		for (j = 0; j < ps->_size - 1 - i; j++)
		{
			if (ps->_arr[j]>ps->_arr[j + 1])
			{
				ps->_arr[j] ^= ps->_arr[j + 1];
				ps->_arr[j + 1] ^= ps->_arr[j];
				ps->_arr[j] ^= ps->_arr[j + 1];
				count = 1;
			}
		}
		if (count == 0)
			return;
	}
}

// 使用选择排序堆顺序表中的元素进行排序  
void SelectSort(Seqlist *ps)
{
	if (NULL == ps)
	{
		return;
	}
	int i = 0, j = 0, count = 0;
	for (i = 0; i < ps->_size - 1; i++)
	{
		count = i;
		for (j = i + 1; j < ps->_size; j++)
		{
			if (ps->_arr[count]>ps->_arr[j])
				count = j;
		}
		if (count != i)
		{
			ps->_arr[i] ^= ps->_arr[count];
			ps->_arr[count] ^= ps->_arr[i];
			ps->_arr[i] ^= ps->_arr[count];
		}
	}
}

test.c

#include"seqlist.h"
#include<Windows.h>
#define _CRT_SECURE_NO_WARNINGS 1
int main()
{
	Seqlist S;
	SeqlistInit(&S);
	SeqlistPushBack(&S, 8);
	SeqlistPushBack(&S, 4);
	SeqlistPushBack(&S, 8);
	SeqlistPushBack(&S, 8);
	SeqlistPushBack(&S, 5);
	SeqlistPushBack(&S, 8);
	SeqlistPushFront(&S, 2);
	SeqlistPushFront(&S, 1);
	SeqListPrint(&S);
	SeqListSize(&S);
	BubbleSort(&S);
	SeqListPrint(&S);
	SeqListSize(&S);
	SelectSort(&S);
	SeqListPrint(&S);
	SeqListSize(&S);
	//SeqlistInsert(&S, 4, 4);
	/*SeqlistInsert(&S, 2, 4);
	SeqListPopFront(&S);
	SeqListPopBack(&S)*/
	SeqListErase(&S, 4);
	SeqListRemove(&S, 8);
	SeqListRemove(&S, 5);
	SeqListPrint(&S);
	SeqListSize(&S);
	SeqListRemoveAll(&S,8);
	SeqListPrint(&S);
	SeqListSize(&S);

	system("pause");
	return 0;
}

测试：