数据结构之顺序表

最新推荐文章于 2024-07-18 17:57:16 发布

zk_lar

最新推荐文章于 2024-07-18 17:57:16 发布

阅读量80

点赞数

分类专栏：数据结构文章标签：数据结构算法

本文链接：https://blog.csdn.net/zk_lar/article/details/125580957

版权

数据结构专栏收录该内容

3 篇文章 1 订阅

订阅专栏

SqList.h

#pragma once

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

#define MAX_SIZE 3

// 预定义函数返回结果
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define INCREMENT 2  

typedef int Status;

typedef struct Book
{
	int bid;			// 图书id
	char bname[30];		// 图书名称
	double bprice;		// 图书价格
}Element;

typedef struct SqList
{
	Element* elem;	// 顺序表的基地址
	int length;		// 有效元素个数
	int capacity;	// 实际空间大小
}SqList;


// 初始化顺序表
Status SqListInit(SqList* ps);

// 销毁线性表
void SqListDestory(SqList* ps);

// 清空顺序表 
void SqListClear(SqList* ps);

// 求顺序表的长度
int SqListGetLength(SqList* ps);

// 顺序表是否为空
int SqListIsEmpty(SqList* ps);

// 顺序表打印
void SqListPrint(SqList* ps);

// 顺序表取值（根据pos位置获取相应位置数据元素的内容）
int SqListGetElem(SqList* ps, int pos, Element* e);

// 顺序表扩容
void SqListCheckCapacity(SqList* ps);

// 顺序表插入（在指定位置插入）
Status SqListInsert(SqList* ps, int pos, Element* e);

// 尾部插入
Status SqListPushBack(SqList* ps, Element* e);

// 头部插入
Status SqListPushFront(SqList* ps, Element* e);

// 顺序表删除（删除指定位置的元素） 
Status SqListDelete(SqList* ps, int pos);

//尾部删除
Status SqListPopBack(SqList* ps);

//头部删除
Status SqListPopFront(SqList* ps);

// 顺序表的查找，在线性表中查找与指定值e相同的数据元素的位置，找到返回该元素的位置序号，未找到返回0
// 根据书号进行查找
int SqListFind(SqList* ps, int bid);

SqList.c

#include "SqList.h"

// 顺序表初始化
Status SqListInit(SqList* ps)
{
	ps->elem = (Element*)malloc(sizeof(Element) * MAX_SIZE);

	if (NULL == ps->elem)
	{
		printf("malloc fail\n");
		return OVERFLOW;
	}

	ps->length = 0;
	ps->capacity = MAX_SIZE;

	return OK;
}

// 销毁顺序表
void SqListDestory(SqList* ps)
{
	if (ps != NULL)
	{
		free(ps->elem);
		ps->elem = NULL;
		ps->capacity = ps->length = 0;
	}
}


// 清空顺序表 
void SqListClear(SqList* ps)
{
	ps->length = 0; // 将顺序表的长度置为0
}

// 求顺序表的长度
int SqListGetLength(SqList* ps)
{
	return ps->length;
}

// 顺序表是否为空
int SqListIsEmpty(SqList* ps)
{
	if (ps->length == 0)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

// 顺序表取值（根据pos位置获取相应位置数据元素的内容）
int SqListGetElem(SqList* ps, int pos, Element* e)
{
	// 判断pos是否合理，不合理返回0
	if (pos < 1 || pos > ps->length)
	{
		return ERROR;
	}
	*e = ps->elem[pos - 1];

	return OK;
}

// 顺序表打印
void SqListPrint(SqList* ps)
{
	int i = 0;
	for (i = 0; i < ps->length; i++)
	{
		printf("%d\t%s\t%lf\n", ps->elem[i].bid, ps->elem[i].bname, ps->elem[i].bprice);
	}
}

// 顺序表扩容
void SqListCheckCapacity(SqList* ps)
{
	if (ps->length == ps->capacity)
	{
		int newcapacity = ps->length * INCREMENT;	// 容量进行倍增
		Element* tmp = (Element*)realloc(ps->elem, sizeof(Element) * newcapacity);

		// 空间扩容失败
		if (NULL == tmp)
		{
			printf("realloc fail\n");
			exit(OVERFLOW);
		}

		// 扩容成功
		ps->elem = tmp;
		ps->capacity = newcapacity;
	}
}

// 顺序表插入（在指定位置插入）
Status SqListInsert(SqList* ps, int pos, Element* e)
{
	if (pos < 1 || pos > ps->length + 1)
	{
		return ERROR;	// pos值不合法,插入位置不合法
	}

	// 检查空间是否需要扩容
	SqListCheckCapacity(ps);

	// 挪动数据
	int i = 0;
	for (i = ps->length - 1; i >= pos - 1; i--)
	{
		ps->elem[i + 1] = ps->elem[i];
	}

	// 进行插入
	ps->elem[pos - 1] = *e;
	ps->length++;

	return OK;

}

// 尾部插入
Status SqListPushBack(SqList* ps, Element* e)
{

	//SqListCheckCapacity(ps);
	 空间足够，尾部插入
	//ps->elem[ps->length].bid = e->bid;
	//strcpy(ps->elem[ps->length].bname, e->bname);
	//ps->elem[ps->length].bprice = e->bprice;
	//ps->length++;
	//return OK;

	// 尾部插入可以进行复用SqListInsert函数
	return SqListInsert(ps, ps->length + 1, e);

}

// 头部插入
Status SqListPushFront(SqList* ps, Element* e)
{
	// 头部插入也可以复用SqListInsert函数
	return SqListInsert(ps, 1, e);
}

// 顺序表删除（删除指定位置的元素） 
Status SqListDelete(SqList* ps, int pos)
{
	if (pos < 1 || pos > ps->length)
	{
		return ERROR;		// pos值不合法,插入位置不合法
	}
	int i = 0;
	for (i = pos - 1; i < ps->length - 1; i++)
	{
		ps->elem[i] = ps->elem[i+1];
	}

	ps->length--;

	return OK;
}

//尾部删除
Status SqListPopBack(SqList* ps)
{
	// 复用SqListDelete函数
	return SqListDelete(ps, ps->length);
}

//头部删除
Status SqListPopFront(SqList* ps)
{
	// 复用SqListDelete函数
	return SqListDelete(ps, 1);
}

// 顺序表的查找，在线性表中查找与指定值e相同的数据元素的位置，找到返回该元素的位置序号，未找到返回0
// 根据书号进行查找
int SqListFind(SqList* ps, int bid)
{
	int i = 0;
	for (i = 0; i < ps->length; i++)
	{
		if (ps->elem[i].bid == bid)
		{
			return i + 1;   // 找到返回位置序号
		}
	}

	// 查找失败，返回0
	return 0;
}

test.c

#include "SqList.h"

void TestSqList1()
{
	SqList sl;
	// 初始化顺序表
	SqListInit(&sl);

	Element e1 = { 1000, "C语言程序设计", 79.9 };
	SqListPushBack(&sl, &e1);

	Element e2 = { 1001, "数据结构", 65.9 };
	SqListPushBack(&sl, &e2);

	Element e3 = { 1002, "java语言设计", 52.5 };
	SqListPushBack(&sl, &e3);

	Element e4 = { 1003, "计算机网络", 75.9 };
	SqListPushBack(&sl, &e4);

	Element e5 = { 1004, "操作系统", 85.0 };
	SqListPushBack(&sl, &e5);

	// 打印顺序表中的元素
	SqListPrint(&sl);
	

	// 根据位置获取相应位置数据元素的内容
	Element e;
	int ret = SqListGetElem(&sl, 3, &e);
	if (ret)
	{
		printf("%d %s %lf\n", e.bid, e.bname, e.bprice);
	}
	else
	{
		printf("要获取的元素位置不合理!\n");
	}




	// 销毁顺序表
	SqListDestory(&sl);
}

// 测试顺序表插入（在指定位置插入）
void TestSqList2()
{
	SqList sl;
	// 初始化顺序表
	SqListInit(&sl);

	Element e1 = { 1000, "C语言程序设计", 79.9 };
	Element e2 = { 1001, "数据结构", 65.9 };
	Element e3 = { 1002, "java语言设计", 52.5 };
	Element e4 = { 1003, "计算机网络", 75.9 };
	SqListInsert(&sl, 1, &e1);
	SqListInsert(&sl, 2, &e2);
	SqListInsert(&sl, 3, &e3);
	SqListInsert(&sl, 5, &e3);	// 插入位置不合法，插入失败
	// 打印顺序表中的元素
	SqListPrint(&sl);

	// 销毁顺序表
	SqListDestory(&sl);
}

// 测试尾插和头插
void TestSqList3()
{
	SqList sl;
	// 初始化顺序表
	SqListInit(&sl);

	Element e1 = { 1000, "C语言程序设计", 79.9 };
	Element e2 = { 1001, "数据结构", 65.9 };
	Element e3 = { 1002, "java语言设计", 52.5 };
	Element e4 = { 1003, "计算机网络", 75.9 };
	
	// 尾插
	SqListPushBack(&sl, &e1);
	SqListPushBack(&sl, &e2);
	
	// 头插
	SqListPushFront(&sl, &e3);
	SqListPushFront(&sl, &e4);

	// 打印顺序表中的元素
	SqListPrint(&sl);
	printf("=============================================\n");

	// 顺序表删除（删除指定位置的元素） 
	SqListDelete(&sl, 3); 
	SqListDelete(&sl, 3);
	SqListDelete(&sl, 3);
	SqListPrint(&sl);

	// 销毁顺序表
	SqListDestory(&sl);
}

// 测试尾部删除和头部删除
void TestSqList4()
{
	SqList sl;
	// 初始化顺序表
	SqListInit(&sl);

	Element e1 = { 1000, "C语言程序设计", 79.9 };
	Element e2 = { 1001, "数据结构", 65.9 };
	Element e3 = { 1002, "java语言设计", 52.5 };
	Element e4 = { 1003, "计算机网络", 75.9 };
	SqListInsert(&sl, 1, &e1);
	SqListInsert(&sl, 2, &e2);
	SqListInsert(&sl, 3, &e3);
	SqListInsert(&sl, 4, &e4);	
	// 打印顺序表中的元素
	SqListPrint(&sl);

	printf("=============================================\n");
	// 头部删除
	SqListPopFront(&sl);
	SqListPrint(&sl);
	printf("=============================================\n");
	// 尾部删除
	SqListPopBack(&sl);
	SqListPrint(&sl);

	// 销毁顺序表
	SqListDestory(&sl);
}

// 测试查找
void TestSqList5()
{
	SqList sl;
	// 初始化顺序表
	SqListInit(&sl);

	Element e1 = { 1000, "C语言程序设计", 79.9 };
	Element e2 = { 1001, "数据结构", 65.9 };
	Element e3 = { 1002, "java语言设计", 52.5 };
	Element e4 = { 1003, "计算机网络", 75.9 };
	SqListInsert(&sl, 1, &e1);
	SqListInsert(&sl, 2, &e2);
	SqListInsert(&sl, 3, &e3);
	SqListInsert(&sl, 4, &e4);
	// 打印顺序表中的元素
	SqListPrint(&sl);

	printf("=============================================\n");
	int ret = SqListFind(&sl, 1002);
	if (ret)
	{
		printf("查找的元素位置：%d\n", ret);
	}
	else
	{
		printf("未找到该元素\n");
	}

	// 销毁顺序表
	SqListDestory(&sl);
}

int main()
{
	//TestSqList2();

	//TestSqList3();

	//TestSqList4();

	TestSqList5();

	return 0;
}