顺序表及其基本操作的实现

最新推荐文章于 2023-05-17 09:39:53 发布
最新推荐文章于 2023-05-17 09:39:53 发布
阅读量784 收藏 7
点赞数 1
文章标签： 线性表 数据 结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40953393/article/details/78935343
版权

/*①sqlist.h线性表的动态分配顺序存储结构*/

#define LIST_INIT_SIZE 100   //线性表存储空间的初始分配量

#define LISTINCREMENT 10     //线性表存储空间的分配增量

typedef struct

{

ElemType *elem;      //存储空间基址

int length;          //当前长度

int listsize;   //当前分配的存储空间容量（以sizeof(ElemType)为单位）

}SqList;

 

/*②顺序表基本操作接口定义*/

//操作结果：构造一个空的线性表

Status InitList_Sq(SqList &L);

 

//初始条件：线性表L已经存在

//操作结果：销毁一个线性表

Status DestroyList_Sq(SqList &L);

//初始条件：线性表L已经存在

//操作结果：将L重置为空表

Status ClearList_Sq(SqList &L);

 

//初始条件：线性表L已经存在

//操作结果：若L为空表，则返回TRUE,否则返回FALSE

Status ListEmpty_Sq(SqList L);

 

//初始条件：线性表L已经存在

//操作结果：返回线性表的长度

int ListLength_Sq(SqList L);

 

//初始条件：线性表L已经存在

//操作结果：在L的表尾加入新元素

Status AppendElem (SqList &L,ElemType e);

 

//初始条件：线性表L已经存在

//操作结果：用e返回线性表的第i个元素的值

Status GetElem_Sq(SqList L,int i, ElemType &e);

 

//初始条件：线性表L已经存在

//操作结果：用i返回线性表中值为e的元素的位置

Position LocateElem_Sq(SqList L, ElemType e,Status (*compare)(ElemType,ElemType));

 

//初始条件：线性表L已经存在

//操作结果：用pre_e返回线性表中值为cur_e的元素的前驱

Position PriorElem_Sq(SqList L,ElemType cur_e, ElemType &pre_e);

 

//初始条件：线性表L已经存在

//操作结果：用next_e返回线性表中值为cur_e的元素的后继

Position NextElem_Sq(SqList L,ElemType cur_e, ElemType &next_e);

 

//初始条件：线性表L已经存在

//操作结果：在L中第i个元素之前插入新的元素e,L的长度加1

Status ListInsert_Sq(SqList &L,int i, ElemType e);

 

//初始条件：线性表L已经存在

//操作结果：删除L的第i个元素，并用e返回其值，L的长度减1

Status ListDelete_Sq(SqList &L,int i, ElemType &e);

 

//初始条件：线性表L已经存在

//操作结果：依次对L的每个数据元素调用(*visit)()，一旦(*visit)()失败，则操作失败

Status ListTraverse_Sq(SqList L,Status (*visit)(ElemType));

 

//辅助函数

Status compare_sq(ElemType e1,ElemType e2);  //比较两个元素的值

Status visit_sp(ElemType e);                  //访问元素（将元素的值打印出来）


#include<stdio.h>
#include<stdlib.h>
#define TRUE   1
#define FALSE  0
#define OK     1
#define ERROR  0
#define OVERFLOW -2
typedef int Status ;
typedef int ElemType ;
#define LIST_INIT_SIZE 100   //线性表存储空间的初始分配量
#define LISTINCREMENT 10     //线性表存储空间的分配增量#pragma once
typedef struct
{
	ElemType *elem;      //存储空间基址
	int length;          //当前长度
	int listsize;   //当前分配的存储空间容量（以sizeof(ElemType)为单位）
}SqList;
//操作结果：构造一个空的线性表
Status InitList_Sq(SqList &L);

//初始条件：线性表L已经存在
//操作结果：销毁一个线性表
Status DestroyList_Sq(SqList &L);

//初始条件：线性表L已经存在
//操作结果：将L重置为空表
Status ClearList_Sq(SqList &L);

//初始条件：线性表L已经存在
//操作结果：若L为空表，则返回TRUE,否则返回FALSE
Status ListEmpty_Sq(SqList L);

//初始条件：线性表L已经存在
//操作结果：返回线性表的长度
int ListLength_Sq(SqList L);

//初始条件：线性表L已经存在
//操作结果：在L的表尾加入新元素
Status AppendElem (SqList &L,ElemType e);

//初始条件：线性表L已经存在
//操作结果：用e返回线性表的第i个元素的值
Status GetElem_Sq(SqList L,int i, ElemType &e);

//初始条件：线性表L已经存在
//操作结果：用i返回线性表中值为e的元素的位置
Status LocateElem_Sq(SqList L, ElemType e,Status (*compare)(ElemType,ElemType));

//初始条件：线性表L已经存在
//操作结果：用pre_e返回线性表中值为cur_e的元素的前驱
Status PriorElem_Sq(SqList L,ElemType cur_e, ElemType &pre_e);

//初始条件：线性表L已经存在
//操作结果：用next_e返回线性表中值为cur_e的元素的后继
Status NextElem_Sq(SqList L,ElemType cur_e, ElemType &next_e);

//初始条件：线性表L已经存在
//操作结果：在L中第i个元素之前插入新的元素e,L的长度加1
Status ListInsert_Sq(SqList &L,int i, ElemType e);

//初始条件：线性表L已经存在
//操作结果：删除L的第i个元素，并用e返回其值，L的长度减1
Status ListDelete_Sq(SqList &L,int i, ElemType &e);

//初始条件：线性表L已经存在
//操作结果：依次对L的每个数据元素调用(*visit)()，一旦(*visit)()失败，则操作失败
Status ListTraverse_Sq(SqList L,Status (*visit)(ElemType));

//辅助函数
Status compare_sq(ElemType e1,ElemType e2);  //比较两个元素的值
Status visit_sp(ElemType e);                  //访问元素（将元素的值打印出来）
Status Listempty_Sq(SqList &L) ;//判断线性表是否为空
Status Display_Sq(SqList &L); //提取顺序表中的元素
void ListSort_Sq(SqList &L);//对线性表中的元素进行排序
void MergeList_Sq(SqList La,SqList Lb,SqList &Lc);//对已知线性表La和Lb的元素按值非递减排列
//操作结果：构造一个空的线性表
Status InitList_Sq(SqList &L)
{
	L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if(!L.elem) exit(OVERFLOW);
    L.listsize=LIST_INIT_SIZE;
    L.length=0;
    return OK;
}//InitList_Sq

//初始条件：线性表L已经存在
//操作结果：销毁一个线性表
Status DestroyList_Sq(SqList &L)
{
	free(L.elem);
	L.elem=NULL;
	return OK;
}

//初始条件：线性表L已经存在
//操作结果：将L重置为空表
Status ClearList_Sq(SqList &L)
{
   L.length=0;
   return OK; 
}

//初始条件：线性表L已经存在
//操作结果：若L为空表，则返回TRUE,否则返回FALSE
Status ListEmpty_Sq(SqList L)
{
   if(NULL==L.elem) return ERROR;
   if(0==L.length)  return TRUE;
   return FALSE;
}

//初始条件：线性表L已经存在
//操作结果：返回线性表的长度
int ListLength_Sq(SqList L)
{
	return L.length;
}

//初始条件：线性表L已经存在
//操作结果：用e返回线性表的第i个元素的值
Status GetElem_Sq(SqList L,int i, ElemType &e)
{
	if(i>L.length||i<1) return ERROR;
	e=L.elem[i-1];
	return OK;
}

//初始条件：线性表L已经存在
//操作结果：用i返回线性表中值为e的元素的位置
Status LocateElem_Sq(SqList L, ElemType e,Status (*compare)(ElemType,ElemType))
{
	int i=1;
/*	ElemType *p;
	p=L.elem;
	while(i<=L.length&&!(*compare)(*p++,e)) ++i;
	if(i<=L.length) return i;
	else return 0;*/
	while(i<=L.length)
	{
		if((*compare)(e,L.elem[i-1]))
		{
			return i;
		}
		i++;
	}
	return 0;

}

//初始条件：线性表L已经存在
//操作结果：用pre_e返回线性表中值为cur_e的元素的前驱
Status PriorElem_Sq(SqList L,ElemType cur_e, ElemType &pre_e)
{
	int i;
	if(i=LocateElem_Sq(L,cur_e,compare_sq))
		if(i>=2&&i<=L.length)
			pre_e=L.elem[i-2];
	return i-1;
}

//初始条件：线性表L已经存在
//操作结果：用next_e返回线性表中值为cur_e的元素的后继
Status NextElem_Sq(SqList L,ElemType cur_e, ElemType &next_e)
{
	int i;
	if(i=LocateElem_Sq(L,cur_e,compare_sq))
		if(i>=1&&i<L.length)
			next_e=L.elem[i];
	return i+1;
}

//初始条件：线性表L已经存在
//操作结果：在L中第i个元素之前插入新的元素e,L的长度加1
// 在顺序线性表L的第i个元素之前插入新的元素e，
// i的合法值为1≤i≤ListLength_Sq(L)+1
Status ListInsert_Sq(SqList &L,int i, ElemType e)
{
    ElemType *newbase,*p,*q;
	if(i<1||i>L.length+1) return ERROR;
	if(L.length >=L.listsize)
	{
		newbase = (ElemType *)realloc(L.elem,
                  (L.listsize+LISTINCREMENT)*sizeof (ElemType));
		if (!newbase) return ERROR;   // 存储分配失败
        L.elem = newbase;             // 新基址
        L.listsize += LISTINCREMENT;  // 增加存储容量
	}
	q=&(L.elem[i-1]);
	for(p=&(L.elem[L.length -1]);p>=q;--p) *(p+1)=*p;
	*q=e;
	++L.length;
	return OK;
}//ListInsert_Sq

//初始条件：线性表L已经存在
//操作结果：在L的表尾加入新元素
Status AppendElem(SqList &L,ElemType e)
{
  if (L.length >= L.listsize) {   // 当前存储空间已满，增加容量
    ElemType *newbase = (ElemType *)realloc(L.elem,
                  (L.listsize+LISTINCREMENT)*sizeof (ElemType));
    if (!newbase) return ERROR;   // 存储分配失败
    L.elem = newbase;             // 新基址
    L.listsize += LISTINCREMENT;  // 增加存储容量
  }
  L.elem[L.length] = e;       // 加入e到表尾
  ++L.length;   // 表长增1
  return OK;
}

//初始条件：线性表L已经存在
//操作结果：删除L的第i个元素，并用e返回其值，L的长度减1
Status ListDelete_Sq(SqList &L,int i, ElemType &e)
{
	ElemType *p,*q;
	if(i<1||i>L.length+1) return ERROR;
	p=&(L.elem[i-1]);
	e=*p;
	q=L.elem +L.length -1;
	for(++p;p<=q;++p) *(p-1)=*p;
	--L.length;
	return OK;
} // ListDelete_Sq

//初始条件：线性表L已经存在
//操作结果：依次对L的每个数据元素调用(*visit)()，一旦(*visit)()失败，则操作失败
Status ListTraverse_Sq(SqList L,Status (*visit)(ElemType))
{
	int i;
	for(i=1;i<=L.length;i++)
		visit(L.elem[i-1]);
	printf("\n");
	return OK;
}

/*辅助函数的实现*/
//比较两个元素，如果相等返回TRUE，否则返回FALSE
Status compare_sq(ElemType e1,ElemType e2)
{
	if(e1==e2) return TRUE;
	else return FALSE;
}

//将元素e的值打印出来
Status visit_sp(ElemType e)
{
	printf("%d",e);
	return OK;
}

Status Listempty_Sq(SqList &L)  
{  
    if(L.length == 0)  
        return TRUE;  
    else  
        return FALSE;  
}  

Status Display_Sq(SqList &L)
{
	int i;
	printf("顺序表中储存的元素为:");
	for(i=0;i<L.length;i++)	printf("%d  ",L.elem[i] );
	printf("\n");
	return TRUE;
}

void ListSort_Sq(SqList &L)  
{  
    int i, j, tmp, max;  
    for(i = 0; i < L.length - 1; i++)  
    {  
        max = i;  
        for(j = i; j < L.length; j++)  
        {  
            if(L.elem[max] > L.elem[j])  
                max = j;  
        }  
        tmp = L.elem[i];  
        L.elem[i] = L.elem[max];  
        L.elem[max] = tmp;  
    }  
}       /*选择排序法*/  

//对已知线性表La和Lb的元素按值非递减排列
void MergeList_Sq(SqList La,SqList Lb,SqList &Lc)  
{  
    if(Lc.listsize  <La.length+Lb.length)   
    {  
        ElemType *newbase;   
        newbase=(int *)realloc(Lc.elem,(La.length+Lb.length+LISTINCREMENT)*sizeof(int));  
        if(newbase==NULL)  
        {  
            printf("内存分配失败!\n");  
            exit(-1) ;  
        }   
        Lc.elem=newbase;      
    }  
    int i;  
    Lc.elem=La.elem;  
    Lc.length=La.length;  
    for(i=0;i<Lb.length;++i)  
    {  
        Lc.elem[La.length+i]=Lb.elem[i];  
        Lc.length++;  
    }   
}  
void main()
{
	int n1,n2,i;
	SqList L,L1,L2;
    InitList_Sq(L);InitList_Sq(L1);InitList_Sq(L2);
	printf("请输入想往La顺序表中存储的元素的个数:");
	scanf("%d",&n1);
	printf("请依次输入La顺序表中要储存的元素:");
	for(i = 1; i <=n1; i++) 
	{
			scanf("%d",&L1.elem[i]);
            ListInsert_Sq(L1,i,L1.elem[i]);
	}
	printf("请输入想往Lb顺序表中存储的元素的个数:");
	scanf("%d",&n2);
	printf("请依次输入Lb顺序表中要储存的元素:");
	for(i = 1; i <=n2; i++) 
	{
			scanf("%d",&L2.elem[i]);
            ListInsert_Sq(L2,i,L2.elem[i]);
	}
	printf("\n\t\t\tLa顺序表");
	printf("\nLa顺序表的长度为:%d\n", L1.length);
	printf("\t排序前\n"); 
	Display_Sq(L1);   
    printf("\tLa顺序表中元素从小到大排序后\n");  
    ListSort_Sq(L1);
	Display_Sq(L1);
	printf("\n\t\t\tLb顺序表");
	printf("\nLb顺序表的长度为:%d\n", L2.length);
	printf("\t排序前\n"); 
	Display_Sq(L2);   
    printf("\tLb顺序表中元素从小到大排序后\n");  
    ListSort_Sq(L2);
	Display_Sq(L2);
	MergeList_Sq(L1,L2,L);
	printf("\n\t\t\tLa和Lb合并后");
	printf("\nL顺序表的长度为:%d\n", L.length);
	Display_Sq(L);
	system("pause");
}


DXnima
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
顺序表上基本操作的实现
qq_45919952的博客
03-05 475
线性表在采用不同的存储结构时，他的描述方法是不同的，那么它的基本操作方法的实现也有不同，下面是顺序表的插入操作的基本代码实现。 插入操作 在一段已经排列好的顺序表中突然要插入一个新的元素，就要求所要插入位置之后的每一项都往后移动一个位置，这样就空出了一个位置，要插入的元素就可以插入进去了。这样就完成了一个类似顺序表插入的过程。 代码实现 在一个顺序表中，数据元素是连续存放的，存放该数据表的数组下标...
顺序表中基本操作的实现
phytn的专栏
07-27 1063
#include typedef int A; const int LIST_INIT_SIZE=100; const int LISTINCREMENT=10; typedef struct { A *elem; int length; int listsize; int incrementsize; }Sqlist; //初始化操作 void InitList_
顺序表的基本操作实现
LinYang_code的博客
04-06 215
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组存储。 动态顺序表：使用动态开辟的数组存储。 以下是我对顺序表的实现（采用动态存储结构） 头文件： #pragma once #include<stdio.h> #include<Windows.h> #i...
顺序表的基本操作与实现
Vagrant_pursue的博客
10-19 600
前言 顺序表存储结构容易实现随机存取线性表的第i个数据元素的操作，但在插入或删除操作时要移动大量的数据元素，适合数据相对稳定的线性表。 提示：以下是顺序表的基本操作和实现代码，下面案例可供参考 1.头文件 代码如下（示例）： #include<stdio.h> #include<stdlib.h> #include<math.h> #define FALSE 0 #define TRUE 1 #define ERROR 0 #define OK 1 //线性表的存储
C语言实现顺序表基本操作汇总
01-20
本篇文章将介绍如何使用C语言实现顺序表的基本操作，包括初始化、建立、输出、删除、逆置、排序和插入等。以下是这些操作的详细说明： 1. **初始化顺序表**： `InitList` 函数用于初始化顺序表 `SqList` 结构体。...
顺序表的基本操作.zip
最新发布
03-16
让我们深入探讨一下顺序表及其基本操作。 顺序表，顾名思义，是元素在内存中按线性顺序排列的数组。它的优点是访问速度快，因为数组的每个元素都可以通过索引直接访问，时间复杂度为O(1)。然而，插入和删除元素时...
C++顺序表的基本操作（使用模版类）
08-19
以下是关于C++顺序表及其基本操作的详细说明： 1. **模板类**： - C++中的模板是一种泛型编程工具，允许创建可以处理不同数据类型的通用类或函数。在这个例子中，`SeqList` 是一个模板类，`template <class T>` ...
顺序表的基本操作及其测试程序
11-07
##### 3.2 基本操作实现 ###### 3.2.1 初始化顺序表 ```c Status InitList(SqList &L) { L.elem = (ElemType*)malloc(sizeof(ElemType) * LIST_INIT_SIZE); if (!L.elem) return ERROR; // 内存分配失败 L....
顺序表的基本操作的实现
10-25
Page83页作业题： 1，利用顺序表的操作实现以下函数： （1）从顺序表中删除具有最小值的元素，并由函数返回被删除元素的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息，并退出运行。 （2）在顺序表的第i个位置之后插入一个数据元素x。若i不合理，则显示出错信息，并退出运行。 （3）从顺序表中删除具有给定值x的所有元素。 （4）在一个顺序表中，如果一个数据值重复出现，则留下第一个数据值，并删除其它所有重复的元素，使表中所有元素的值均不相同。 分析：定义操作，使用成员函数的操作实现（1）、（2）、（3）、（4）。
顺序表的基本操作及实现
11-22
顺序表的基本操作及实现顺序表的基本操作及实现顺序表的基本操作及实现
顺序表基本操作的实现
qq_57867712的博客
11-07 2187
一、顺序表的初始化 算法步骤： （1）为顺序表L动态分配一个预定大小的数组空间，使elem指向这段空间的基地址。 （2）将表的当前长度设为0。 typedef int ElemType; typedef struct { ElemType *elem; int length; } SqList; //顺序表的初始化 void InitList(SqList &L) { L.elem=new ElemType[MAXSIZE]; if(!L.elem)
顺序表基本操作实现（详细）
身在边城 心在编程
04-12 2435
顺序表分为1.静态顺序表 2.动态顺序表 顺序表的目录1.顺序表的概念2. 熟悉顺序表的分类？3.熟悉顺序表的优缺点4.动态顺序表的基本操作4.0包含头文件和结构体4.1初始化，销毁，扩容4.2尾插，尾删，头插，头删4.3任意位置的插入和删除4.4移除指定值的元素4.5其它简单操作5.测试函数 1.顺序表的概念 （1）顺序结构-----------将表中元素一个一个的存入一组连续的存储单元中 （2...
【数据结构】顺序表的基本操作的实现
Y0704__00的博客
10-31 326
用静态分配的一维数组和动态分配的一维数组来完成实验题目
数据结构——顺序表中基本操作的实现
Xiao_Ya__的博客
05-17 572
数据结构——顺序表中基本操作的实现
顺序表的基本操作代码实现
1+1=王的博客
04-28 2504
顺序的基本操作代码实现（初始化、插入、删除、销毁等等） 1.标头.h #pragma once #include<stdio.h> #include<stdlib.h> /* @author:W.yu @Data:2020-04-27 */ #define INITSIZE 10 //定义顺序表的初始最大长度 typedef struct { int* data...
顺序表的一些基本操作的实现
QWQ___qwq的博客
01-09 266
#include <stdio.h> #include <conio.h> #include <stdlib.h> #define MAXSIZE 100 #define TURE 1 #define FALSE0 #define OVERFLOW -2 #define INFEASIBLE -1 #define OK 1 #define ERROR 0 typedef struct { int* elem; int length; }SqList; int Init
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

DXnima

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值