C语言实现顺序表

C代码实现顺序表

打开VS2017，新建一个空的c项目，再创建如下头文件和c文件，



该顺序表分为两种存储形式，一种是动态存储，一种是静态存储。静态存储一次性申请所需空间，而动态存储可以进行灵活申请存储空间，二者差别不大，动态存储无非是多了申请内存空间这个步骤，算法思想都差不多。以下是代码：

静态分配的头文件代码：

#pragma once
#include<stdio.h>
#include<stdlib.h>
///静态分配头文件
#define MAXSIZE 1000
typedef int EleType;//数据类型
typedef struct//结构体
{
	EleType Selem[MAXSIZE];//申请MAXSIZE个数据元素存储的空间
	unsigned length;//顺序表当前长度0--MAXSIZE-1
}Slist;
///定义线性表的操作函数

Slist* Init_Slist();//初始化线性表
void InsertSlist(Slist* L, unsigned i, EleType e);//在L线性表的第i个元素(逻辑位置)前插入一个元素
unsigned GetSlistLength(Slist L);//获取线性表长度
EleType GetSElem(Slist L, unsigned i);//获取第i个位置的元素（逻辑位置）
unsigned LocateSElem(Slist L, EleType e);//确定e在线性表的第几个位置
void SListDelete(Slist* L, int i, EleType* e);//删除第几个元素
void PrintSlist(Slist L);//遍历线性表
int EmptySlist(Slist L);//线性表判空
void DestroySlist(Slist* L);//释放线性表内存

静态分配.c：函数实现代码：

#include"静态分配.h"
///静态分配的函数实现代码
///定义线性表的操作函数
//初始化线性表
Slist* Init_Slist()
{
	Slist* L = (Slist*)malloc(sizeof(Slist));
	L->Selem[MAXSIZE] = (EleType*)malloc(MAXSIZE * sizeof(EleType));
	L->length = 0;
	return L;
}

//在L线性表的第i个元素(逻辑位置)前插入一个元素,注意这里使用的是逻辑位置
void InsertSlist(Slist* L, unsigned i, EleType e)
{
	printf("当前长度为：%d\n", L->length);
	if (L->length >= MAXSIZE)
	{
		printf("内存溢出!!!\n");
	
	}
	if (i<1 || i>=MAXSIZE)
	{
		printf("非法逻辑位置！！！\n");
		
	}
	//if (L->length == 0)
	//{
	//	printf("线性表长度为0,静态分配失败");
	//	exit(0);
	//}
	if (L->length == 0)
	{
		L->Selem[L->length] = e;
		L->length++;
		printf("length=0插入元素：%d\n", L->Selem[0]);
	
	}
	else
	{
		for (unsigned j = L->length; j >= i - 1; j--)
		{
			if (j <= 0)
			{
				break;
			}
			printf("L.selem[%d]:%d\n",j-1,L->Selem[j-1]);
		
			L->Selem[j] = L->Selem[j - 1];
		}
		L->Selem[i - 1] = e;
		L->length++;
		printf("插入成功！！！\n");
	}

	return;
}
//获取线性表长度
unsigned GetSlistLength(Slist L)
{
	return L.length;
}
//获取第i个位置的元素（逻辑位置）
EleType GetSElem(Slist L, unsigned i)
{
	if (i<1 || i>L.length)
	{
		printf("非法逻辑位置！！！\n");
		exit(0);
	}
	return L.Selem[i-1];

}
//确定e在线性表的第几个位置(返回逻辑位置)
unsigned LocateSElem(Slist L, EleType e)
{
	int flag=-1;
	for (int i = 0; i < L.length-1; i++)
	{
		if (L.Selem[i] == e)
		{
			flag = i;
			break;

		}
	}
	if (flag == -1)
	{
		printf("未找到该元素位置\n");
		return flag;
	}
	return flag + 1;
}
//删除第i个元素(逻辑位置),并且把元素放在e上
void SListDelete(Slist* L, unsigned i, EleType* e)
{
	if (L->length == 0)
	{
		printf("空表不能进行删除！！！");
		exit(0);
	}
	if (i<1 || i>L->length)
	{
		printf("非法逻辑位置");
		exit("非法逻辑位置");
	}
	*e = L->Selem[i - 1];
	/*for (EleType *p = L->Selem[i]; p >=L->Selem[L->length-1]; p++)
	{
		*(p - 1) = *p;
	}*/
	
	for (int j = i; j < L->length; j++)
	{
		L->Selem[j - 1] = L->Selem[j];
	}
	L->length--;
	printf("成功删除！！！\n");
}
//遍历线性表
void PrintSlist(Slist L)
{
	for (int i = 0; i < L.length; i++)
	{
		printf("%d ", L.Selem[i]);
	}
	printf("\n");
}
//线性表判空
int EmptySlist(Slist L)
{
	if (L.length == 0)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}
//释放线性表内存
void DestroySlist(Slist *L)
{
	if (!L->Selem)
		exit(0);
	free(L->Selem);
	L->length = 0;
	printf("释放内存成功\n");
}

动态分配的头文件代码

#pragma once
///动态分配的头文件
#include<stdio.h>
#include<stdlib.h>
typedef int Eletype;
#define initSize 1000
#define incSize 500
typedef struct
{
	Eletype* Delem;
	unsigned length;
	
}Dlist;
//初始化线性表
Dlist* InitDlist();
//插入元素
void InsertDlist(Dlist* L, unsigned i, Eletype e);
//求线性表长度
unsigned DlistLength(Dlist L);
//根据位置获取线性表第i个元素，i为逻辑位置
Eletype getDelemByPos(Dlist L, unsigned i);
//确定e是线性表第几个元素
unsigned LocateDElem(Dlist L, Eletype e);
//删除第i个元素,i为逻辑位置
void ListDeleteDelem(Dlist* L, unsigned i);
//遍历打印线性表
void PrintDlist(Dlist L);
//线性表判空
int EmptyDlist(Dlist L);
//销毁线性表
void DestroyDlist(Dlist* L);

动态分配.c：函数实现

#include"动态分配.h"
///动态分配的函数实现
//初始化线性表
Dlist* InitDlist()
{
	Dlist* list = (Dlist*)malloc(sizeof(Dlist));
	list->Delem = (Eletype*)malloc(initSize * sizeof(Eletype));
	list->length = 0;
	return list;
}
//插入元素
void InsertDlist(Dlist* L, int i, Eletype e)
{
	if (L->length == initSize)
	{
		Eletype *p;
		p = (Eletype*)realloc(L->Delem, (initSize + incSize) * sizeof(Eletype));
		if (!p)
		{
			printf("内存分配失败！！！\n");
			exit(0);
		}
		L->Delem = p;
	
	}
	if (L->length == 0)//如果线性表没有元素，则直接给第一个地址赋值
	{
		L->Delem[0] = e;
		printf("元素%d插入成功 \n", e);
		L->length ++;
		
	}
	else
	{
		if (i<1 || i>L->length)
		{
			printf("插入位置有误!!!");
			exit(0);
		}
	
		for (int j = L->length - 1; j >= i - 1; j--)
		{
			if (j < 0)
			{
				printf(" %d小于0 ",j);
				break;
			}
			
			L->Delem[j + 1] = L->Delem[j];
		}
		L->Delem[i - 1] = e;
		printf("元素%d插入成功\n", e);
		L->length++;
	}
	

}
//求线性表长度
unsigned DlistLength(Dlist L)
{
	return L.length;
}
//根据位置获取线性表第i个元素，i为逻辑位置
Eletype getDelemByPos(Dlist L, unsigned i)
{
	if (&L == NULL) return NULL;
	if (i<1 || i>L.length)
	{
		printf("查找位置出错!!!");
		exit(0);
	}
	return L.Delem[i - 1];
}
//确定e是线性表第几个元素,逻辑位置
unsigned LocateDElem(Dlist L, Eletype e)
{
	int i;
	for (i = 0; i < L.length; i++)
	{
		if (e == L.Delem[i])
		{
			break;
		}
	}
	if (i == L.length)
	{
		return -1;
	}
	else
	{
		return i + 1;
	}
}
//删除第i个元素,i为逻辑位置
void ListDeleteDelem(Dlist* L, unsigned i)
{
	if (L->length == 0) exit(0);
	if (i<1 || i>L->length)
	{
		exit(0);
	}
	for (int j = i; j < L->length; j++)
	{
		L->Delem[j - 1] = L->Delem[j];
	}
	L->length--;

}
//遍历打印线性表
void PrintDlist(Dlist L)
{
	
	for (int i = 0; i <L.length; i++)
	{
		printf("打印元素：%d", L.Delem[i]);
	}
	printf("\n");
}
//线性表判空
int EmptyDlist(Dlist L)
{
	if (L.length == 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}
	
}
//销毁线性表
void DestroyDlist(Dlist* L)
{
	if (!L->Delem) { exit(0); }
	free(L->Delem);
	L->length = 0;
}

测试文件头文件

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

void TestSlistTest();//静态分配测试
void TestDlistTest();//动态分配的测试

测试文件.c函数实现

#include"测试文件.h"
#include"静态分配.h"
#include"动态分配.h"

void TestSlistTest()//静态分配测试
{
	printf("------------------------静态分配的测试--------------------\n");
	Slist* SL = Init_Slist();
	InsertSlist(SL, 1, 10);
	InsertSlist(SL, 1, 20);
	InsertSlist(SL, 1, 30);
	InsertSlist(SL, 1, 40);
	InsertSlist(SL, 1, 50);
	InsertSlist(SL, 1, 60);
	PrintSlist(*SL);
	EleType e = GetSElem(*SL, 2);
	printf("e:%d\n", e);
	unsigned pos = LocateSElem(*SL, 50);
	printf("pos:%d\n", pos);
	EleType* del = (EleType*)malloc(sizeof(EleType));
	SListDelete(SL, 2, del);
	PrintSlist(*SL);
	DestroySlist(SL);
	printf("------------------------静态分配的测试--------------------\n");
}
void TestDlistTest()//动态分配的测试
{
	printf("------------------------动态分配的测试--------------------\n");
	Dlist* DL = InitDlist();
	printf("%d\n",EmptyDlist(*DL));//判断是否为空
	InsertDlist(DL, 1, 20);
	InsertDlist(DL, 1, 30);
	InsertDlist(DL, 1, 40);
	InsertDlist(DL, 1, 50);
	InsertDlist(DL, 1, 90);
	PrintDlist(*DL);
	InsertDlist(DL, 2, 99);
	PrintDlist(*DL);
	DestroyDlist(DL);
	printf("------------------------动态分配的测试--------------------\n");
}

最后的顺序表.c文件：

#include"测试文件.h"



int main()
{
	TestSlistTest();//静态分配的测试
	TestDlistTest();//动态分配的测试
	system("pause");
}

#以上就是实现顺序表的操作，如有问题，欢迎指正。