线性表的顺序表示和实现

最新推荐文章于 2023-04-01 15:59:42 发布

Mr.赵德柱

最新推荐文章于 2023-04-01 15:59:42 发布

阅读量168

点赞数 1

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

本文链接：https://blog.csdn.net/weixin_46059682/article/details/120182946

版权

数据结构专栏收录该内容

7 篇文章 0 订阅

订阅专栏

面向对象面向君，不负代码不负卿！

在这里插入图片描述

直接上代码！

相关头文件

#include "c1.h"

#pragma once
//c1.h程序名
#include <string.h>
#include <ctype.h>
#include <malloc.h>//malloc.h()等
#include <limits.h>//INT_MAX等
#include <stdio.h>//EOF(^Z或F6),NULL
#include <stdlib.h>//atoi()
#include <io.h>//eof()
#include <math.h>//floor().ceil(),abs()
#include <process.h>//exit()
#include <iostream>//cout,cin
using namespace std;

//函数结果状态代码

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
//#define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3，故去掉此行
typedef int Status;//Status是函数的类型，其值是函数结果状态代码，如OK等
typedef int Boolean;//Boolean是布尔类型，其值是TRUE或FALSE

#include "c2-1.h"

#pragma once

#define LIST_INIT_SIZE 10//线性表存储空间的初始分配量
#define LIST_INCREASEMENT 2//线性表存储空间的分配增量

typedef int ElemType;

typedef struct sqlist
{
	ElemType* elem;//存储空间地址
	int length;//当前长度
	int listsize;//当前分配的存储容量（以sizeof(ElemeType)为单位）
}Sqlist;

#include "bo2-1.cpp"

#include "c1.h"
#include "c2-1.h"

//bo2-1.cpp
//顺序表示的线性表（存储结构由c2-1.h定义）的基本操作（12个），包括算法2.3 2.4 2.5 2.6

inline void InitList(Sqlist& L)//算法2.3
{
	//操作结果：构造一个空的顺序线性表L
	L.elem = (ElemType*)malloc(LIST_INIT_SIZE * sizeof(ElemType));
	if (!L.elem)
		exit(OVERFLOW);//存储分配失败
	L.length = 0;//空表长度为0
	L.listsize = LIST_INIT_SIZE;//初始存储容量
}

inline void DestroyList(Sqlist& L)
{
	//初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L
	free(L.elem);
	L.elem = NULL;
	L.length = 0;
	L.listsize = 0;
}

inline void ClearList(Sqlist& L)
{
	//初始条件：顺序线性表L已存在。操作结果：将L重置为空表
	L.length = 0;
}

inline Status ListEmpty(Sqlist& L)
{
	//初始条件：顺序线性表已存在。操作结果：若L为空表，则返回TRUE,否则返回FALSE
	if (L.length == 0)
		return TRUE;
	else
		return FALSE;
}

inline int ListLength(Sqlist& L)
{
	//初始条件：顺序线性表已存在。操作结果：返回L中数据元素的个数
	return L.length;
}

inline Status GetElem(Sqlist L, int i, ElemType& e)
{
	//初始条件：顺序线性表已存在，1<=i<=ListLength(L)。操作结果：用e返回L中第i个数据元素的值
	if (i<1 || i>L.length)
		return ERROR;
	e = *(L.elem + i - 1);
	return OK;
}

inline int LocateElem(Sqlist L, ElemType e, Status(*compare)(ElemType, ElemType))
{
	//初始条件：顺序线性表L已存在，compare()是数据元素判定函数（满足为1，否则为0）
	//操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
	//        若这样的数据元素不存在，则返回值为0。算法 2.6
	ElemType* p;
	int i = 1;//i的初值为第1个元素的位序
	p = L.elem;//p的初值为第1个元素的存储位置
	while (i <= L.length && !compare(*p++, e))
		++i;
	if (i <= L.length)
		return i;
	else
		return 0;
}

inline Status PriorElem(Sqlist L, ElemType cur_e, ElemType& pre_e)
{
	//初始条件：顺序线性表L已存在
	//操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱；
	//        否则操作失败，pre_e无定义
	int i = 2;
	ElemType* p = L.elem + 1;
	while (i <= L.length && *p != cur_e)
	{
		p++;
		i++;
	}
	if (i > L.length)
		return INFEASIBLE;//操作失败
	else
	{
		pre_e = *--p;
		return OK;
	}
}

inline Status NextElem(Sqlist L, ElemType cur_e, ElemType& next_e)
{
	//初始条件：顺序线性表L已存在
	//操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继；
	//        否则操作失败，next_e无定义
	int i = 1;
	ElemType* p = L.elem;
	while (i < L.length && *p != cur_e)
	{
		i++;
		p++;
	}
	if (i == L.length)
		return INFEASIBLE;//操作失败
	else
	{
		next_e = *++p;
		return OK;
	}
}

inline Status ListInsert(Sqlist& L, int i, ElemType e)//算法2.4
{
	//初始条件：顺序线性表L已存在，1<=i<=L.length(L)+1
	//操作结果：在L中第i个位置之前插入新的元素e，L的长度加1
	
	ElemType* newbase, * q, * p;
	if (i < 1 || i > L.length + 1)//i值不合法
		return ERROR;
	if (L.length >= L.listsize)//当前存储空间已满，增加分配
	{
		if (!(newbase = (ElemType*)realloc(L.elem, (L.listsize + LIST_INCREASEMENT) * sizeof(ElemType))))
			exit(OVERFLOW);//存储分配失败
		L.elem = newbase;//新基址
		L.listsize += LIST_INCREASEMENT;//增加存储容量
	}
	q = L.elem + i - 1;//q为插入位置
	for (p = L.elem + L.length - 1; p >= q; --p)//插入位置及之后的元素右移
		*(p + 1) = *p;
	*q = e;//插入e
	++L.length;//表长增1
	return OK;
}

inline Status ListDelete(Sqlist& L, int i, ElemType& e)//算法2.5
{
	//初始条件：顺序线性表L已存在，1<=i<=L.length(L)
	//操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
	ElemType* p, * q;
	if (i<1 || i>L.length)
		return ERROR;
	p = L.elem + i - 1;//p为被删除元素的位置
	e = *p;//被删除元素的值赋给e
	q = L.elem + L.length - 1;//表尾元素的位置
	for (++p; p <=q; ++p)
		*(p - 1) = *p;
	L.length--;//表长减1
	return OK;
}

inline void ListTraverse(Sqlist L, void(*vi)(ElemType&))
{
	//初始条件：顺序线性表L已存在
	//操作结果：依次对L的每个数据元素调用函数vi()
	//        vi()的形参加'&'，表明可通过调用vi()改变元素的值
	ElemType *p;
	int i;
	p = L.elem;
	for (i = 1; i <= L.length; i++)
		vi(*p++);
	printf("\n");
}

基本操作，函数实现，基操勿6！！！

#include "func2-3.cpp"

//func2-3.cpp 几个常用的函数
#include "c1.h"
#include "c2-1.h"
inline Status equal(ElemType c1, ElemType c2)
{
	//判断是否相等的函数
	if (c1 == c2)
		return TRUE;
	else
		return FALSE;
}

inline int comp(ElemType a, ElemType b)
{
	//根据a<、=或>b,分别返回-1、0或1
	if (a == b)
		return 0;
	else
		return (a - b) / abs(a + b);
}

inline void print(ElemType c)
{
	printf("%d ", c);
}

inline void print2(ElemType c)
{
	printf("%c ", c);
}

inline void print1(ElemType& c)
{
	printf("%d ", c);
}

主函数-程序的入口！

#include "1.Main.cpp"

#include "c1.h"
#include "c2-1.h"
#include "func2-3.cpp"
#include "bo2-1.cpp"


Status sq(ElemType c1, ElemType c2)
{
	//数据元素判定函数（平方关系），LocateElem()调用函数
	if (c1 == c2 * c2)
		return TRUE;
	else
		return FALSE;
}
void dbl(ElemType& c)
{
	//ListTraverse()调用的另一函数（元素值加倍）
	c *= 2;
}

void main()
{
	Sqlist L;
	ElemType e=0, e0=0;
	Status i=0;
	int j=0, k=0;

	InitList(L);

	printf("初始化后：L.elem=%u L.length=%d L.listsize=%d\n\n", L.elem, L.length, L.listsize);

	for (j = 1; j <= 5; j++)
		i = ListInsert(L, 1, j);
	printf("在L的表头依次插入1~5后：*L.elem=");
	for (j = 1; j <= 5; j++)
		cout << *(L.elem + j - 1) << ' ';
	cout << endl;
	printf("\n");
	printf("L.elem=%u L.length=%d L.listsize=%d ", L.elem, L.length, L.listsize);

	i = ListEmpty(L);
	printf("L是否空：i=%d(1:是 0：否)\n\n", i);

	ClearList(L);
	printf("清空L后：L.elem=%u L.length=%d L.listsize=%d ", L.elem, L.length, L.listsize);

	i = ListEmpty(L);
	printf("L是否空： i=%d(1:是 0：否)\n\n", i);
	for (j = 1; j <= 10; j++)
		ListInsert(L, j, j);
	printf("L.elem=%u L.length=%d L.listsize=%d ", L.elem, L.length, L.listsize);

	ListInsert(L, 1, 0);
	printf("在L的表头插入0后：*L.elem=");
	for (j = 1; j <= ListLength(L); j++)//ListLength(L)为元素个数
		cout << *(L.elem + j - 1) << ' ';
	cout << endl;
	printf("\n");
	printf("L.elem=%u(有可能改变) L.length=%d(改变) L.listsize=%d(改变)\n\n", L.elem, L.length, L.listsize);
	GetElem(L,5, e);
	printf("第5个元素的值为%d\n\n", e);
	for (j = 10; j <= 11; j++)
	{
		k = LocateElem(L, j, equal);
		if (k)//k不为0，表明有符合条件的元素，且其位序为k
			printf("第%d个元素的值为%d\n\n", k, j);
		else
			printf("没有值为%d的元素\n\n", j);
	}
	for (j = 3; j <= 4; j++)
	{
		k = LocateElem(L, j, sq);
		if (k)//k不为0，表明有符合条件的元素，且其位序为k
			printf("第%d个元素的值为%d的平方\n\n", k, j);
		else
			printf("没有值为%d的平方的元素\n\n", j);
	}
	for (j = 1; j <= 2; j++)//测试头两个数据
	{
		GetElem(L, j, e0);//把第j个数据赋给e0
		i = PriorElem(L, e0, e);//求e0的前驱
		if (i == INFEASIBLE)
			printf("元素%d无前驱\n\n", e0);
		else
			printf("元素%d的前驱为%d\n\n", e0, e);
	}
	for (j = ListLength(L) - 1; j <=  ListLength(L); j++)//最后两个数据
	{
		GetElem(L, j, e0);//把第j个数据赋给e0
		i = NextElem(L, e0, e);//求e0的后继
		if (i == INFEASIBLE)
			printf("元素%d无后继\n\n", e0);
		else
			printf("元素%d的后继为%d\n\n", e0, e);
	}
	k = ListLength(L);//k为表长
	for (j = k + 1; j >= k; j--)
	{
		i = ListDelete(L, j, e);//删除第j个数据
		if (i == ERROR)
			printf("删除第%d个元素失败\n\n", j);
		else
			printf("删除第%d个元素成功，其值为%d\n\n", j, e);
	}
	printf("依次输出L的元素：");
	ListTraverse(L, print1);//依次对元素调用print1(),输出元素值
	printf("\n\n");
	printf("L的元素值加倍后：");
	ListTraverse(L, dbl);//依次对元素调用dbl(),元素值乘2
	ListTraverse(L, print1);
	printf("\n\n");
	DestroyList(L);
	printf("销毁L后：L.elem=%u L.length=%d L.listsize=%d \n", L.elem, L.length, L.listsize);
}

程序运行结果：

在这里插入图片描述

面向对象面向君，不负代码不负卿！

Mr.赵德柱

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
线性表的顺序表示和实现

#include "c1.h"#pragma once//c1.h程序名#include <string.h>#include <ctype.h>#include <malloc.h>#include <limits.h>#include <stdio.h>#include <stdlib.h>#include <io.h>#include <math.h>#include <pr.
复制链接

扫一扫