静态顺序链表的实现

静态顺序链表的头文件

这个静态链表的内部元素是由数组所构成的，所以其中有一部分的实现有所不同

#pragma once
#include <string.h>  
#include <assert.h>  
#include <stdio.h>  
#include<stdlib.h>  
#define N 100  
typedef int DataType;
typedef struct Seqlist{
	int arr[N];
	int size;
}SeqList;
void SeqListInit(SeqList*pSL)//初始化  
void SeqListPushBack(SeqList* pSL, DataType data)//尾插  
void SeqListPrint(SeqList*pSL)//打印函数  
void SeqlistPushFront(SeqList*pSL, DataType data)//头插  
void SeqListPopFront(SeqList *pSL)//头删  
void SeqListPopBack(SeqList *pSL)//尾删  
void SeqListInsert(SeqList *pSL, int pos, DataType data)//按下标删除  
void SeqListErase(SeqList *pSL, int pos)//按下标删除  
int SeqListFind(SeqList *pSL, DataType data)//按值查找  
void SeqListRemove(SeqList *pSL, DataType data)//按值删除，只删除遇到的第一个  
void SeqListRemoveAll(SeqList *pSL, DataType data)//按值删除，删除所有的   
void SeqListDestroy(SeqList *pSL)//销毁  
void SeqListClear(SeqList *pSL)//清空  
int SeqListSize(SeqList *pSL)//返回数量  
void SeqListEmpty(SeqList *pSL)//判断是否为空  
void SelectSortEvolved(SeqList *pSL)//排序

静态聊表的实现

void SeqListInit(SeqList*pSL)//初始化  
{
	memset(pSL->arr, 0, sizeof(DataType)* N);
	pSL->size = 0;
}
void SeqListPushBack(SeqList* pSL, DataType data)//尾插  
{
	assert(pSL != NULL);
	if (pSL->size >= N){
		printf("full\n");
		return;
	}
	pSL->arr[pSL->size] = data;
	pSL->size++;
}
void SeqListPrint(SeqList*pSL)//打印函数  
{
	int i = 0;
	for (i = 0; i < pSL->size; i++)
	{
		printf("%d", pSL->arr[i]);
	}
	printf("\n");
}
void SeqlistPushFront(SeqList*pSL, DataType data)//头插  
{
	assert(pSL != NULL);
	if (pSL->size >= N){
		printf("full\n");
		return;
	}
	int i;
	for (i = 0; i < pSL->size; i++)
	{
		pSL->arr[pSL->size - i] = pSL->arr[pSL->size - i - 1];
	}
	pSL->arr[0] = data;
	pSL->size++;
}
void SeqListPopFront(SeqList *pSL)//头删  
{
	assert(pSL);
	assert(pSL->size>0);
	int i;
	for (i = 1; i < pSL->size; i++)
	{
		pSL->arr[i - 1] = pSL->arr[i];
	}
	pSL->size--;
}
void SeqListPopBack(SeqList *pSL)//尾删  
{
	assert(pSL);
	assert(pSL->size>0);
	pSL->size--;
}
void SeqListInsert(SeqList *pSL, int pos, DataType data)
//按下标插入由于是由数组构成，而数祖是由0开始的所以应该减去1才能到所要插入的位置  
{
	assert(pSL);
	if (pSL->size >= N){
		printf("full\n");
		return;
	}
	assert(pos - 1 >= 0 && pos <= pSL->size);
	int i;
	for (i = pSL->size - 1; i >= pos - 1; i--)
	{
		pSL->arr[i] = pSL->arr[i - 1];
	}
	pSL->arr[pos - 1] = data;
	pSL->size++;
}
void SeqListErase(SeqList *pSL, int pos)//按下标删除  
{
	assert(pSL);
	assert(pSL->size > 0);
	assert(pos - 1 >= 0 && pos <= pSL->size);
	int i;
	for (i = pos - 1; i <= pSL->size; i++)
	{
		pSL->arr[i] = pSL->arr[i + 1];
	}
	pSL->size--;
}
int SeqListFind(SeqList *pSL, DataType data)
//按值查找，返回第一个找到的下标，如果没找到，返回 -1  
{
	assert(pSL);
	int i = 0;
	for (; i < pSL->size; i++){
		if (pSL->arr[i] == data){
			printf("%d\n", i);//打印的是这个数所在的位置所以不用加1  
			return i + 1;//由于由数组构成所以返回的地址应在原来的基础上加1  
		}
	}
	printf("%d\n", -1);
	return -1;
}
void SeqListRemove(SeqList *pSL, DataType data)//按值删除，只删除遇到的第一个  
{
	assert(pSL);
	int pos = SeqListFind(pSL, data);
	if (pos != -1){
		SeqListErase(pSL, pos);
	}
}
void SeqListRemoveAll(SeqList *pSL, DataType data)//按值删除，删除所有的   
{
	//#if 0  
	//  int pos;  
	//  
	//  // O(N^2)   O(1)  
	//  while ((pos = SeqListFind(pSL, data)) != -1) {  
	//      SeqListErase(pSL, pos);  
	//  }  
	//#endif  
	//  
	//#if 0  
	//  // 1. 重新申请个空间，遍历原来的数组，如果不是要删除的，就copy到新空间  
	//  // 2. 把新空间的数据copy回原来的数组  
	//  // 3. 要把copy数量就是新 size  
	//  // 4. free（新空间）  
	//#endif  
	//  
	//#if 1  
	//  // 1. 两个下标，空间下标，遍历下标  
	//  // 2. 奉要删的，跳过遍历下标，计数器++  
	//  // 3. 不是要删的，就把遍历对应的值copy到空间的  
	//  // 4. Until，遍历结束  
	//  // 5. size - 计数器  
	int spaceI = 0, i;
	int count = 0;
	for (i = 0; i < pSL->size; i++) {
		if (pSL->arr[i] == data) {
			count++;
		}
		else {
			pSL->arr[spaceI] = pSL->arr[i];
			spaceI++;
		}
	}
	pSL->size -= count;
}
void SeqListDestroy(SeqList *pSL)//销毁  
{
	pSL->size = 0;
}
void SeqListClear(SeqList *pSL)//清空  
{
	int i;
	for (i = 0; i < pSL->size; i++)
	{
		pSL->arr[i] = 0;
	}
}
int SeqListSize(SeqList *pSL)//返回数量  
{
	printf("%d\n", pSL->size);
	return pSL->size;
}
void SeqListEmpty(SeqList *pSL)//判断是否为空  
{
	pSL->size == 0 ? 1 : 0;
}
void Swap(DataType *a, DataType *b)
{
	DataType tmp;


	tmp = *a;
	*a = *b;
	*b = tmp;
}
void SelectSortEvolved(SeqList *pSL)//排序  
{
#if 0  
	/*
	宗旨思想：封神榜，诸神归位
	一次归俩神，大神，小神
	所有神所在的空间就不在人间
	[0] -> min   [size-1] -> max
	[1] -> min  [size-1-1] -> max
	i: [i] -> min [size-i-1] -> max
	j loop 从 i 到 size - i - 1
	找到最小的下标，最大的下标
	交换（特殊情况需要考虑）
	持续 size / 2
	*/
#endif  
	int i, j;
	int minPos, maxPos;
	for (i = 0; i < pSL->size / 2; i++) {
		minPos = maxPos = i;
		for (j = i; j < pSL->size - i; j++) {
			if (pSL->arr[j] < pSL->arr[minPos]) {
				minPos = j;
			}
			if (pSL->arr[j] > pSL->arr[maxPos]) {
				maxPos = j;
			}
		}
		Swap(pSL->arr + i, pSL->arr + minPos);
		if (i == maxPos) {
			maxPos = minPos;
		}
		Swap(pSL->arr + pSL->size - i - 1, pSL->arr + maxPos);
	}
}

测试函数

void TestSeqList()
{

	SeqList sl;

	SeqListInit(&sl);
	SeqListPushBack(&sl, 1);
	SeqListPushBack(&sl, 2);
	SeqListPushBack(&sl, 3);
	SeqListPushBack(&sl, 4);
	SeqListPrint(&sl);

	SeqlistPushFront(&sl, 4);
	SeqlistPushFront(&sl, 3);
	SeqlistPushFront(&sl, 2);
	SeqlistPushFront(&sl, 1);
	SeqListPrint(&sl);

	//SeqListPopFront(&sl);
	//SeqListPopFront(&sl);
	//SeqListPrint(&sl);

	//SeqListPopBack(&sl);
	//SeqListPrint(&sl);

	//SeqListInsert(&sl, 3,5);
	//SeqListInsert(&sl, 5, 6);
	//SeqListPrint(&sl);

	/*SeqListFind(&sl, 3);*/

	//SeqListErase(&sl, 3);
	//SeqListErase(&sl, 5);
	//SeqListPrint(&sl);

	//SeqListRemove(&sl, 3);
	//SeqListPrint(&sl);

	//SeqListRemoveAll(&sl, 3);
	//SeqListPrint(&sl);

	//SeqListSize(&sl);

	//SelectSortEvolved(&sl);
	//SeqListPrint(&sl);

	//SeqListClear(&sl);
	//SeqListPrint(&sl);

	SeqListDestroy(&sl);
	SeqListPrint(&sl);
}

顺序表的主函数

#define _CRT_SECURE_NO_WARNINGS 1
#include"test.h"
int main()
{
	TestSeqList();
	system("pause");
	return 0;
}