2-1-2顺序表的源码

最新推荐文章于 2023-02-25 23:42:06 发布
最新推荐文章于 2023-02-25 23:42:06 发布
阅读量195 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/i_am_kiki/article/details/81814663
版权

2-1-2顺序表的源码

c1.h

// c1.h (程序名)
#pragma once

#ifndef __C1_H__
#define __C1_H__
#include<string.h>
#include<ctype.h>
#include<malloc.h> // malloc()等
#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 SUCCEEDED 1
#define ERROR 0
#define FAILED 0
#define INFEASIBLE -1
#define EQUAL 1
#define UNEQUAL 0
// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如SUCCEEDED等
typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE

#endif

Compare.cpp

// Compare.cpp 几个常用的函数
#include "Compare.h"
#include "SqListType.h"
#include <stdio.h>

Status equal(ElemType c1,ElemType c2)
{ // 判断是否相等的函数
	if(c1==c2)
		return EQUAL;
	else
		return UNEQUAL;
}

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

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

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

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

Compare.h

#pragma once

#ifndef	__COMPARE_H__
#define __COMPARE_H__

#include "c1.h"
#include "SqListType.h"

// 判断是否相等的函数
Status equal(ElemType c1,ElemType c2);

// 根据 a<、 =或 >b，分别返回 -1、 0或 1
int unequal(ElemType a,ElemType b);

void Dprint(ElemType c);

void Cprint(ElemType c);

void CitePrint(ElemType &c);


#endif

SqListBasicOperation.cpp

// bo2-1.cpp 顺序表示的线性表(存储结构由c2-1.h定义)的基本操作(12个),包括算法2.3,2.4,2.5,2.6
#include "c1.h"
#include "SqListType.h"
#include "SqListBasicOperation.h"

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

}

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

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

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

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

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

int LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))
{ // 初始条件：顺序线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0)
	// 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
	//           若这样的数据元素不存在，则返回值为0。算法2.6
	ElemType *p;
	int pos=1; // i的初值为第1个元素的位序
	p=L.elem; // p的初值为第1个元素的存储位置
//	printf("p=L.elem地址是%x\n",p);
//	printf("原始pos=%d\n",pos);
//	printf("*****************\n");
	while(pos<=L.length){
		  if (compare(*p,e)==UNEQUAL){
			  p++;
			  pos++;
//			  printf("地址=%x\n",p);
//			  printf("++pos=%d\n",pos);
		  }else{
			  break;
		  }
	}
	if(pos<=L.length)
		return pos;
	else
		return FAILED;
}

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

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

Status ListInsert(SqList &L,int pos,ElemType e) // 算法2.4
{ // 初始条件：顺序线性表L已存在，1≤pos≤ListLength(L)+1
	// 操作结果：在L中第pos个位置之前插入新的数据元素e，L的长度加1
	ElemType *newbase,*insert,*an;
	if(pos<1||pos>L.length+1) {
		return ERROR;//pos值不合法
	}else{
		if(L.length>=L.listsize) // 当前存储空间已满,增加分配
		{	
			newbase=(ElemType *)realloc(L.elem,(L.listsize+LIST_INCREMENT)*sizeof(ElemType));
//			printf("旧的L.elem=%x\n",L.elem);
//			printf("新的newbase=%x\n",newbase);
//			printf("L的长度=%d",sizeof(L));
			if(newbase==NULL)
				exit(OVERFLOW); // 存储分配失败
			L.elem=newbase; // 新基址
//			printf("新的L.elem=%x\n",L.elem);
			L.listsize+=LIST_INCREMENT; // 增加存储容量
		}
		insert=L.elem+pos-1; // insert为插入位置
		for(an=L.elem+L.length-1;an>=insert;--an) // 插入位置及之后的元素右移
			*(an+1)=*an;
		*insert=e; // 插入e
		++L.length; // 表长增1
		return SUCCEEDED;
	}

}

Status ListDelete(SqList &L,int pos,ElemType &e) // 算法2.5
{ // 初始条件：顺序线性表L已存在，1≤pos≤ListLength(L)
	// 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
	ElemType *delP,*an,*mov;
	if(pos<1||pos>L.length){		// pos值不合法
		return ERROR;
	}else{
		delP=L.elem+pos-1; // delP为被删除元素的位置
		e=*delP; // 被删除元素的值赋给e
		an=L.elem+L.length-1; // 表尾元素的位置
		mov=++delP;//pos位置上的指针向后移动一位,为移动pos后面的元素做准备
		while(mov<=an){
			*(mov-1)=*mov;
			++mov;// 被删除元素之后的元素左移
		}

		L.length--; // 表长减1
		return SUCCEEDED;
	}
}

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

SqListBasicOperation.h

#pragma	once

#ifndef _SQLISTBASICOPERATION_H__
#define _SQLISTBASICOPERATION_H__

#include "c1.h"
#include "SqListType.h"
void InitList(SqList &L);
void DestroyList(SqList &L);
void ClearList(SqList &L);
Status ListEmpty(SqList L);
int ListLength(SqList L);
Status GetElem(SqList L,int pos,ElemType &e);
int LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType));
Status PriorElem(SqList L,ElemType cur_e,ElemType &pre_e);
Status NextElem(SqList L,ElemType cur_e,ElemType &next_e);
Status ListInsert(SqList &L,int pos,ElemType e);
Status ListDelete(SqList &L,int pos,ElemType &e);
void ListTraverse(SqList L,void(*vi)(ElemType&));
#endif

SqListTestMain.cpp

// SqListTestMain.cpp 检验SqListBasicOperation.cpp的主程序
#include"c1.h"
#include"SqListType.h"
#include"Compare.h" // 包括equal()、comp()、Dprint()、Cprint()和CitePrint()函数
#include"SqListBasicOperation.h"
// 数据元素判定函数 (平方关系 ) ， LocateElem() 调用的函数
Status sq(ElemType c1, ElemType c2);


// ListTraverse() 调用的另一函数 (元素值加倍 )
void ElemDouble(ElemType &Citec);
void main()
{
	SqList L;
	ElemType e,e0;
	Status i;
	int j,k;
	InitList(L);
	printf("初始化L后：L.elem=%u L.length=%d L.listsize=%d\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("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",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",i);
	for(j=1;j<=10;j++)
		ListInsert(L,j,j);
	printf("在L的表尾依次插入1～10后：*L.elem=");
	for(j=1;j<=10;j++)
		cout<<*(L.elem+j-1)<<' ';
	cout<<endl;
	printf("L.elem=%u L.length=%d L.listsize=%d\n",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("L.elem=%u(有可能改变) L.length=%d(改变) L.listsize=%d(改变)\n",L.elem,L.length,L.listsize);
	GetElem(L,5,e);
	printf("第5个元素的值为：%d\n",e);
	for(j=10;j<=11;j++)
	{
		k=LocateElem(L,j,equal);
		if(k) // k不为0，表明有符合条件的元素，且其位序为k
			printf("第%d个元素的值为%d\n",k,j);
		else
			printf("没有值为%d的元素\n",j);
	}
	for(j=3;j<=4;j++)
	{
		k=LocateElem(L,j,sq);
		if(k) // k不为0，表明有符合条件的元素，且其位序为k
			printf("第%d个元素的值为%d的平方\n",k,j);
		else
			printf("没有值为%d的平方的元素\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",e0);
		else
			printf("元素%d的前驱为：%d\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",e0);
		else
			printf("元素%d的后继为：%d\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",j);
		else
			printf("删除第%d个元素成功，其值为：%d\n",j,e);
	}
	printf("依次输出L的元素：");
	ListTraverse(L,CitePrint); // 依次对元素调用CitePrint()，输出元素的值
	printf("L的元素值加倍后：");
	ListTraverse(L,ElemDouble); // 依次对元素调用ElemDouble()，元素值乘2
	ListTraverse(L,CitePrint);
	DestroyList(L);
	printf("销毁L后：L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);
	getchar();
}
Status sq(ElemType c1,ElemType c2)
{ // 数据元素判定函数(平方关系)，LocateElem()调用的函数
	if(c1==c2*c2)
		return TRUE;
	else
		return FALSE;
}

void ElemDouble(ElemType &c)
{ // ListTraverse()调用的另一函数(元素值加倍)
	c*=2;
}

SqListType.h

#pragma once
#ifndef _SQLISTTYPE_H_
#define _SQLISTTYPE_H_

#define LIST_INIT_SIZE 10/*1*/
#define LIST_INCREMENT 2/*2*/
typedef int ElemType;
struct SqList{
	ElemType *elem;/*3*/
	int length;/*4*/
	int listsize;/*5*/
};
#endif

 

i_am_kiki
关注
数据结构 2-2 线性表的顺序表实现
博客标题不能为空我也没办法
05-30 214
一、概率 线性表有两种实现方式，顺序表和链表，顺序表作为较简单的实现方式，可以借用数组来实现。顺序表和链表各有各自的优缺点，这是由其性质所决定的，在选择时要根据题目要求，灵活进行选择。 二、定义 以C代码为例，需要定义一个结构体，结构体中包括一个数组、一个变量代表线性表的最大长度，一个变量代表线性表的当前已使用长度。这里需要注意，数组作为存储线性表数据的载体，具有两种分配方式。 王道数据结构上将分配分为动态和静态，所谓静态是指在定义时直接指定确定长度的数组 int data[100]; 像这种形式就属于静
数据结构基本操作源代码
狒狒也是程序猿的专栏
04-10 3761
//三元组 #include #include #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int Status; typedef int ElemType; typedef ElemType *Triplet; #include "h2.h" Status InitTriplet(Triplet&T,ElemType v1
数据结构---顺序表实现(源码)
ZORO的学习笔记
10-22 1565
复习一下数据结构，希望以后每周能坚持发一章。第一章   顺序表/*****************************SqList**********************************Date:2008.10.22Author:ZOROWebSite:http://blog.csdn.net/sevenhu===================
课本19页源程序
mute_sparkle的博客
12-23 235
顺序表的源代码
Enumeration类的nextElement()
balei2634的博客
01-08 3475
Enumeration遍历方法： Enumeration attributes = application.getAttributeNames();//这里是application对象，也可以是其他的对象，不同对象的取值方式可能不同 while(attributes.hasMoreElements()) { ou...
【程序源码 3-1】顺序表实现线性表的基本功能（DEV C版）.rar
10-05
在这个“【程序源码 3-1】顺序表实现线性表的基本功能（DEV C版）”中，我们可以看到一个使用C语言在DEV C++环境下实现的线性表操作的示例。DEV C++是一款轻量级的C/C++集成开发环境，它为编程提供了方便的编辑、...
算法-理论基础- 线性表- 顺序表（包含源程序）.rar
09-16
1. 插入操作：在顺序表的某个位置插入一个元素，通常需要将该位置之后的所有元素都向后移动一位。如果数组已满，需要考虑动态扩容。 2. 删除操作：删除某个位置的元素，同样需要将之后的所有元素向前移动一位来填补...
商业编程-源码-家家留言本 v1.0.zip
06-23
1. **系统架构** 家家留言本 v1.0 可能采用传统的客户端-服务器（Client-Server）架构，用户通过浏览器发起请求，服务器处理请求并返回响应。这种架构模式在早期Web应用中非常常见，易于理解和部署。 2. **前端...
商业编程-源码-GIF文件解码器类原代码.zip
06-21
总之，"商业编程-源码-GIF文件解码器类原代码.zip"提供了对GIF解码流程的直接洞察，有助于提升开发者在图像处理领域的专业能力。通过对源码的分析和学习，我们可以更好地应对复杂的图像处理任务，甚至扩展到其他类似...
商业编程-源码-木目子留言本程序(PHP).zip
06-23
《商业编程-源码-木目子留言本程序(PHP).zip》是一个包含PHP源代码的压缩包，专门针对创建和管理在线留言本的应用程序。这个程序可能是为了帮助网站所有者与访客进行互动，收集反馈，提升用户体验而设计的。在深入...
线性表（数据结构）
最新发布
qq_52318243的博客
02-25 368
顺序表的定位(就是输入一个元素，返回他在顺序表中的位序，若不在返回0)
malloc函数碎碎记
惟愿一生无悔也无憾
10-02 813
一、 数据结构的时候，动态分配内存 用到了 这句话 L.elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType)); 解释： //用malloc分配一段这么LIST_INIT_SIZEsizeof(ElemType)多个字节的内存段 //Elemtype这个结构体的LIST_INIT_SIZE的乘积这么大 //它返回一个指向该内存段首字节的指针变量(viod)，然后把这个指针变量强制转换为ElemType*类型 //再把这个经转换的指针变量赋
线性表的相关操作
叫我_C同学
11-22 223
顺序表的创建Status InitList(SqList &L) { L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType)); if(!L.elem) exit(OVERFLOW); L.length = 0; L.listsize = LIST_INIT_SIZE; retur
数据结构算法-1
lvmengmeng
02-10 1056
Void  union(List &La,List Lb) //将所有在线性表Lb中但不在La中的数据元素插入到La中      {          La_len = ListLength(La);Lb_len =ListLength(Lb);//求线性表的长度      For(i= 1;i           {                      GetElem(Lb,i
关于malloc和sizeof的用法
weixin_30667649的博客
05-12 4101
问题1： 1.L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));2.newbase = (ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType)); 其中L是已经定义的线性表，LIST_INIT_SIZE是线性表存储空间的初始分配...
数据结构—顺序表的初始化
qq_39830449的博客
08-18 7331
#include &amp;lt;stdio.h&amp;gt; ...
数据结构C语言实现——顺序线性表SqList
热门推荐
小刘同学_iOS的专栏
08-12 1万+
数据结构与算法是语言学习中的重点与难点。之前没学好，现在特地将严蔚敏的《数据结构》C语言版中的伪代码，予以实现，算作是自己再学习一次。同时希望能帮助到那些刚接触数据结构，对书中内容还不甚理解不知如何动手实现的童鞋。本篇是实现简单的顺序线性表，实现书中算法2.1和算法2.6。
malloc是什么（数据结构）
lorenzoln的专栏
04-08 1万+
（ElemType*）malloc（Lc.listsize*sizeof(ElemType)）谁能帮忙解释一下？ 在数据结构书上抄的，看不懂 尤其是ElemType*那个星号在后面，是什么意思
顺序表源码详解及C语言实现技巧
以上是对文件标题、描述、标签以及文件名列表中提供的顺序表源码的知识点总结。顺序表作为一种基础的数据结构，在计算机科学中占据着重要的地位，不仅在理论学习上有其不可替代的价值，在实际开发中也广泛应用。通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值