静态顺序表的实现（C语言）

最新推荐文章于 2022-06-17 17:39:24 发布

douguailove

最新推荐文章于 2022-06-17 17:39:24 发布

阅读量573

点赞数 2

分类专栏： C语言

本文链接：https://blog.csdn.net/guaiguaihenguai/article/details/76154968

版权

C语言专栏收录该内容

13 篇文章 2 订阅

订阅专栏

先来了解一下什么是顺序表。

顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

来看一下什么是连续存储

像a b c d 这样就是连续存储的。

代码

头文件SeqList.h部分

#ifndef __SEQLIST_H__
#define __SEQLIST_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>

#define MAX 10//数组元素个数

typedef int DataType;//数组元素类型重命名

typedef struct SeqList
{
	DataType data[MAX];//创建一个数组
	int sz;     //用于记住元素的个数
}SeqList,*pSeqList;

void InitSeqlist(pSeqList ps);//初始化函数
void PushBack(pSeqList ps, DataType x);//从后边添加的函数
void PrintSeqlist(const pSeqList ps);//打印数组的函数
void PopBack(pSeqList ps);//从后往前删除的函数
void PushFront(pSeqList ps, DataType x);//从前边添加的函数
void PopFront(pSeqList ps);//从前往后删除的函数
void Insert(pSeqList ps, int pos, DataType x);//指定位置添加的函数
int Find(pSeqList ps, DataType x);//查找函数
void Remove(pSeqList ps, DataType x); //删除指定某个数的函数
void RemoveAll(pSeqList ps, DataType x);//删除所有的指定的某个值的函数
void ReverseList(pSeqList ps);//逆序函数
void SortList(pSeqList ps);//排序函数
int BinarySearch(pSeqList ps, DataType x);//二分查找函数

#endif

说明：typedef int DataType是为了将数组元素的类型int重命名，为什么要重命名呢？

因为数组有可能是int类型，也有可能是float类型，double类型等等，加入我们就将数组定义为int类型，当我们需要其他类型的时候就要去整个代码中找出所有用到类型的地方逐一改正，这是很麻烦的。当我们将类型重命名后，只需要在这个地方将int改为其他所需要的类型就OK了。

各个函数的实现SeqList.c部分

#define _CRT_SECURE_NO_WARNINGS
#include "SeqList.h"

void InitSeqlist(pSeqList ps)
{
	ps->sz = 0;
	memset(ps->data, 0, MAX*sizeof(DataType));
}

void PushBack(pSeqList ps, DataType x)
{
	assert(ps != NULL);
	if (ps->sz == MAX)
	{
		return;
	}
	ps->data[ps->sz] = x;
	ps->sz++;
}
void PrintSeqlist(const pSeqList ps)
{
	assert(ps != NULL);
	int i = 0;
	if (ps->sz == 0)
	{
		return;
	}
	for (i = 0; i < ps->sz; i++)
	{
		printf("%d ", ps->data[i]);
	}
	printf("\n");
}
void PopBack(pSeqList ps)
{
	assert(ps != NULL);
	if (ps->sz == 0)
	{
		return;
	}
	ps->sz--;
}
void PushFront(pSeqList ps, DataType x)
{
	assert(ps != NULL);
	if (ps->sz == MAX)
	{
		return;
	}
	memmove(ps->data+1, ps->data, (ps->sz)*sizeof(DataType));
	ps->data[0] = x;
	ps->sz++;
}
void PopFront(pSeqList ps)
{
	assert(ps != NULL);
	if (ps->sz == 0)
	{
		return;
	}
	memmove(ps->data, ps->data + 1, (ps->sz - 1)*sizeof(DataType));
	ps->sz--;
}
void Insert(pSeqList ps, int pos, DataType x)
{
	assert(ps != NULL);
	if (ps->sz == MAX)
	{
		return;
	}
	memmove(ps->data+pos+1, ps->data + pos, (ps->sz -pos)*sizeof(DataType));
	ps->data[pos] = x;
	ps->sz++;
}
int Find(pSeqList ps, DataType x)
{
	int i = 0;
	assert(ps != NULL);
	if (ps->sz == 0)
	{
		return -1;
	}
	for (i = 0; i < ps->sz; i++)
	{
		if (ps->data[i] == x)
		{
			return i;
		}
	}
	return -1;
}
void Remove(pSeqList ps, DataType x)//指定删除
{
	int ret = -1;
	assert(ps != NULL);
	if (ps->sz == 0)
	{
		return;
	}
	ret = Find((pSeqList)ps->data, x);
	if (ret != -1)
	{
		memmove(ps->data + ret, ps->data + ret + 1, (ps->sz - ret)*sizeof(DataType));
		ps->sz--;
	}
}
void RemoveAll(pSeqList ps, DataType x)
{
	int i = 0;
	assert(ps != NULL);
	if (ps->sz == 0)
	{
		return;
	}
	for (i = 0; i < ps->sz; i++)
	{
		if (x == ps->data[i])
		{
			memmove(ps->data + i, ps->data + i + 1, (ps->sz - i)*sizeof(DataType));
			ps->sz--;
		}
	}
}
void ReverseList(pSeqList ps)
{
	int left = 0;
	int right = ps->sz-1;
	assert(ps != NULL);
	if (ps->sz == 0)
	{
		return;
	}
	while (left < right)
	{
		int tmp = ps->data[left];
		ps->data[left] = ps->data[right];
		ps->data[right] = tmp;
		left++;
		right--;
	}

}
void SortList(pSeqList ps)
{
	int i = 0;
	int j = 0;
	assert(ps != NULL);
	if (ps->sz == 0)
	{
		return;
	}
	for (i = 0; i < ps->sz-1; i++)
	{
		for (j = 0; j < ps->sz - i - 1; j++)
		{
			if (ps->data[j]>ps->data[j + 1])
			{
				int tmp = ps->data[j];
				ps->data[j] = ps->data[j+1];
				ps->data[j+1] = tmp;
			}
		}
	}
}
int BinarySearch(pSeqList ps, DataType x)
{
	int left = 0;
	int right = ps->sz - 1;
	int mid = 0;
	assert(ps != NULL);
	if (ps->sz == 0)
	{
		return -1;
	}
	while (left < right)
	{
		mid = left + (right - left)/2;
		if (ps->data[mid] > x)
		{
			right = mid - 1;
		}
		else if (ps->data[mid] < x)
		{
			left = mid + 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;
}

说明：一定要记得进入函数第一件事就是检查指针是否为空指针，因为后边要对该指针进行引用，对空指针引用会导致程序崩溃的。所以assert断言是非常重要的。

测试函数test.c部分

#define _CRT_SECURE_NO_WARNINGS
#include "SeqList.h"
void test1()
{
	struct SeqList plist;
	InitSeqlist(&plist);
	PushBack(&plist, 1);
	PushBack(&plist, 2);
	PushBack(&plist, 3);
	PushBack(&plist, 4);
	PrintSeqlist(&plist);
	PopBack(&plist);
	PrintSeqlist(&plist);
	PopBack(&plist);
	PrintSeqlist(&plist);
	PopBack(&plist);
	PrintSeqlist(&plist);
	PopBack(&plist);
	PrintSeqlist(&plist);
	PopBack(&plist);
	PrintSeqlist(&plist);
}
void test2()
{
	struct SeqList plist;
	InitSeqlist(&plist);
	PushFront(&plist, 1);
	PushFront(&plist, 2);
	PushFront(&plist, 3);
	PushFront(&plist, 4);
	PrintSeqlist(&plist);
	PopFront(&plist);
	PrintSeqlist(&plist);
	PopFront(&plist);
	PrintSeqlist(&plist);
	PopFront(&plist);
	PrintSeqlist(&plist);
	PopFront(&plist);
	PrintSeqlist(&plist);
	PopFront(&plist);
	PrintSeqlist(&plist);
	}
void test3()
{
	struct SeqList plist;
	InitSeqlist(&plist);
	PushBack(&plist, 1);
	PushBack(&plist, 2);
	PushBack(&plist, 3);
	PushBack(&plist, 4);
	PrintSeqlist(&plist);
	Insert(&plist, 2, 6);
	PrintSeqlist(&plist);
}
void test4()
{
	struct SeqList plist;
	InitSeqlist(&plist);
	PushBack(&plist, 1);
	PushBack(&plist, 2);
	PushBack(&plist, 3);
	PushBack(&plist, 4);
	PrintSeqlist(&plist);
	int ret=Find(&plist, 3);
	//int ret = Find(&plist, 5);
	printf("%d\n", ret);
	Remove(&plist, 3);
	PrintSeqlist(&plist);
	/*Remove(&plist, 6);
	PrintSeqlist(&plist);*/
}
void test5()
{
	struct SeqList plist;
	InitSeqlist(&plist);
	PushBack(&plist, 1);
	PushBack(&plist, 2);
	PushBack(&plist, 3);
	PushBack(&plist, 2);
	PushBack(&plist, 4);
	PushBack(&plist, 6);
	PushBack(&plist, 2);
	PrintSeqlist(&plist);
	RemoveAll(&plist, 2);
	PrintSeqlist(&plist);
}
void test6()
{
	struct SeqList plist;
	InitSeqlist(&plist);
	PushBack(&plist, 1);
	PushBack(&plist, 2);
	PushBack(&plist, 3);
	PushBack(&plist, 4);
	PrintSeqlist(&plist);
	ReverseList(&plist);
	PrintSeqlist(&plist);
}
void test7()
{
	struct SeqList plist;
	InitSeqlist(&plist);
	PushFront(&plist, 1);
	PushFront(&plist, 2);
	PushFront(&plist, 3);
	PushFront(&plist, 4);
	PrintSeqlist(&plist);
	SortList(&plist);
	PrintSeqlist(&plist);
}
void test8()
{
	struct SeqList plist;
	InitSeqlist(&plist);
	PushBack(&plist, 1);
	PushBack(&plist, 2);
	PushBack(&plist, 3);
	PushBack(&plist, 4);
	PushBack(&plist, 5);
	PushBack(&plist, 6);
	PrintSeqlist(&plist);
	int ret=BinarySearch(&plist,5);
	printf("%d\n", ret);
}
int main()
{
	//test1();
	//test2();
	//test3();
	//test4();
	//test5();
	//test6();
	//test7();
	test8();

	return 0;
}

说明：想要测试那个函数的功能只需将对应的已被注释掉的测试函数放开就行了