线性表的顺序存储实现

最新推荐文章于 2022-10-03 21:48:36 发布
最新推荐文章于 2022-10-03 21:48:36 发布
阅读量133 收藏 1
点赞数
文章标签： python
原文链接：https://my.oschina.net/niithub/blog/3015738
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

1. 基础操作

/**
 * 初始化顺序表
 */
void initList(SqList *L) {
	L->length=0;
}

/**
 * 销毁顺序表
 */
void destroyList(SqList *L) {
	L->length = -1;
}

/**
 * 置空顺序表
 */
void clearList(SqList *L) {
	L->length = 0;
}

/**
 * 如果顺序表为空表，则返回真，否则返回假
 */
int emptyList(SqList *L) {
	if (0 == L->length) {
		return OK;
	} else {
		return FALSE;
	}
}

/**
 * L存在，且i值合法，即1 <= i <= length, 则返回第i个元素的值
 */
int getList(SqList *L, int i)  {
	if (L->length <= 0 || i > L->length) {
		return FALSE;
	}
	return L->r[i];
}

2. 插入操作

        线性表的插入运算是指在表的第i个位置，插入一个新元素e，使长度为n的线性表变成长度为n + 1的线性表。

/**
 * 表L存在，e为合法元素值，且1 <= i <= length + 1
 * 在表L中第i个位置插入新的元素e，L的长度加1
 * 注意：本例子中，默认从下标1开始，如顺序表[0,1]的长度为1
 */
int insList(SqList *L, int i, int e) {
	int j;
	if (L->length == MAXSIZE) {
		return FALSE;
	}
	if (i <= 0 || i > L->length + 1) {
		return FALSE;
	}
	if (i <= L->length) {
		for (j = L->length + 1; j >= i ; j--) {
			L->r[j + 1] = L->r[j];
		}
	}
	L->r[i] = e;
	L->length++;
	return OK;
}

3. 删除操作

        线性表的删除操作时指将表的第i个元素删去，使长度为n的线性表变成长度为n-1的线性表。

/**
 * 表L存在且非空，1 <= i <= length
 * 删除L的第i个数据元素，并用e返回其值，L的长度减1
 */
void delList(SqList *L, int i, int *e) {
	int j;
	*e = L->r[i];
	if (i < L->length) {
		for (j = i; j <= L->length; j++) {
			L->r[j] = L->r[j + 1];
		}
	}
	L->length--;
}

4. 合并操作

  两个有序线性表，使新线性表也有序

    方法一：从线性表尾开始比较，指到其中一个线性表的表长为0，然后将另一线性表的剩余元素移动到新线性表上

/**
 * 合并LA、LB两个顺序表
 */
int unionList(SqList *L, SqList *LA, SqList *LB) {
	if (LA->length + LB->length > MAXSIZE) {
		return FALSE;
	}
	L->length =  LA->length + LB->length;
	int i;
	for (i = LA->length + LB->length; LA->length > 0 && LB->length > 0; i--) {
		if (LA->r[LA->length] >= LB->r[LB->length]) {
			L->r[i] = LA->r[LA->length];
			LA->length--;
		} else {
			L->r[i] = LB->r[LB->length];
			LB->length--;
		}
	}
	if (LA->length > 0) {
		for (i; i > 0; i--) {
			L->r[i] = LA->r[LA->length];
			LA->length--;
		}
	} else {
		for (i; i > 0; i--) {
			L->r[i] = LB->r[LB->length];
			LB->length--;
		}
	}
	return OK;
}

    方法二：设两个指针i,j,k分别指向待合并的线性表LA、LB、新线性表，如果LA->r[i] >= LB->r[j]，则将LA->r[i]插入到新线性表中，i++,k++；否则反之,j++,k++。

/**
 * 合并LA、LB两个顺序表
 */
int unionList2(SqList *L, SqList *LA, SqList *LB) {
	if (LA->length + LB->length > MAXSIZE) {
		return FALSE;
	}
	int i = 1, j = 1, k = 1, n;
	L->length =  LA->length + LB->length;
	while (i <= LA->length && j <= LB->length) {
		if (LA->r[i] >= LB->r[j]) {
			L->r[k] = LA->r[i];
			i++;
			k++;
		} else {
			L->r[k] = LB->r[j];
			j++;
			k++;
		}
	}
	while (i <= LA->length) {
		L->r[k] = LA->r[i];
		i++;
		k++;
	}
	while (i <= LB->length) {
		L->r[k] = LB->r[j];
		j++;
		k++;
	}
	return OK;
}

完整实例：

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

#define MAXSIZE 101
#define OK 1
#define FALSE 0
typedef struct {
	int r[MAXSIZE];
	int length;
} SqList;

void print(SqList L);
void initList(SqList *L);
void destroyList(SqList *L);
void clearList(SqList *L);
int emptyList(SqList *L);
int locateList(SqList *L, int e);
int getList(SqList *L, int e);
int insList(SqList *L, int i, int e);
void delList(SqList *L, int i, int *e);
int unionList(SqList *L, SqList *LA, SqList *LB);
int unionList2(SqList *L, SqList *LA, SqList *LB);
int main(int argc, char *argv[]) {
	SqList list, list1, list2;
	int result, deleteNum;
	printf("初始化顺序表:\n");
	initList(&list);
	initList(&list1);
	printf("长度为：%d\n", list.length);
	for (int i = 1; i <= 6; i++) {
		list.r[i] = i * 3;
		list.length++;
	}
	for (int i = 1; i <= 4; i++) {
		list1.r[i] = i * 2;
		list1.length++;
	}
	printf("顺序表的内容:\n");
	print(list);
	if (insList(&list, 6, 2)) {
		printf("插入成功\n");
		printf("插入元素后的顺序表的内容:\n");
		print(list);
	} else {
		printf("插入失败\n");
	}
	delList(&list, 6, &deleteNum);
	printf("删除的数字是:%d\n", deleteNum);
	printf("删除后的顺序表的内容:\n");
	print(list);
	printf("顺序表LB的内容:\n");
	print(list1);
	printf("顺序表合并后的内容:\n");
	unionList(&list2, &list, &list1);
	print(list2);
	destroyList(&list);
	return 0;
}

/**
 * 打印函数
 */
void print(SqList L) {
	for (int i = 1; i <= L.length; i++) {
		printf("%d\t", L.r[i]);
	}
	printf("\n");
}

/**
 * 初始化顺序表
 */
void initList(SqList *L) {
	L->length=0;
}

/**
 * 销毁顺序表
 */
void destroyList(SqList *L) {
	L->length = -1;
}

/**
 * 置空顺序表
 */
void clearList(SqList *L) {
	L->length = 0;
}

/**
 * 如果顺序表为空表，则返回真，否则返回假
 */
int emptyList(SqList *L) {
	if (0 == L->length) {
		return OK;
	} else {
		return FALSE;
	}
}

/**
 * L存在，且i值合法，即1 <= i <= length, 则返回第i个元素的值
 */
int getList(SqList *L, int i)  {
	if (L->length <= 0 || i > L->length) {
		return FALSE;
	}
	return L->r[i];
}

/**
 * 表L存在，e为合法元素值，且1 <= i <= length + 1
 * 在表L中第i个位置插入新的元素e，L的长度加1
 * 注意：本例子中，默认从下标1开始，如顺序表[0,1]的长度为1
 */
int insList(SqList *L, int i, int e) {
	int j;
	if (L->length == MAXSIZE) {
		return FALSE;
	}
	if (i <= 0 || i > L->length + 1) {
		return FALSE;
	}
	if (i <= L->length) {
		for (j = L->length + 1; j >= i ; j--) {
			L->r[j + 1] = L->r[j];
		}
	}
	L->r[i] = e;
	L->length++;
	return OK;
}

/**
 * 表L存在且非空，1 <= i <= length
 * 删除L的第i个数据元素，并用e返回其值，L的长度减1
 */
void delList(SqList *L, int i, int *e) {
	int j;
	*e = L->r[i];
	if (i < L->length) {
		for (j = i; j <= L->length; j++) {
			L->r[j] = L->r[j + 1];
		}
	}
	L->length--;
}

/**
 * 合并LA、LB两个顺序表
 */
int unionList(SqList *L, SqList *LA, SqList *LB) {
	if (LA->length + LB->length > MAXSIZE) {
		return FALSE;
	}
	L->length =  LA->length + LB->length;
	int i;
	for (i = LA->length + LB->length; LA->length > 0 && LB->length > 0; i--) {
		if (LA->r[LA->length] >= LB->r[LB->length]) {
			L->r[i] = LA->r[LA->length];
			LA->length--;
		} else {
			L->r[i] = LB->r[LB->length];
			LB->length--;
		}
	}
	if (LA->length > 0) {
		for (i; i > 0; i--) {
			L->r[i] = LA->r[LA->length];
			LA->length--;
		}
	} else {
		for (i; i > 0; i--) {
			L->r[i] = LB->r[LB->length];
			LB->length--;
		}
	}
	return OK;
}

/**
 * 合并LA、LB两个顺序表
 */
int unionList2(SqList *L, SqList *LA, SqList *LB) {
	if (LA->length + LB->length > MAXSIZE) {
		return FALSE;
	}
	int i = 1, j = 1, k = 1, n;
	L->length =  LA->length + LB->length;
	while (i <= LA->length && j <= LB->length) {
		if (LA->r[i] >= LB->r[j]) {
			L->r[k] = LA->r[i];
			i++;
			k++;
		} else {
			L->r[k] = LB->r[j];
			j++;
			k++;
		}
	}
	while (i <= LA->length) {
		L->r[k] = LA->r[i];
		i++;
		k++;
	}
	while (i <= LB->length) {
		L->r[k] = LB->r[j];
		j++;
		k++;
	}
	return OK;
}

转载于:https://my.oschina.net/niithub/blog/3015738

weixin_33834910
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
20、LeetCode 2021/1/31 27. 移除元素
qq_42847094的博客
01-31 593
20、LeetCode 2021/1/31 27. 移除元素 27. 移除元素 难度简单758 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。 示例 1： 输入：nums = [3,2,2,3], val = 3 输出：2, nums = [2,2] 解释：函数应该返回新的长度 2, 并且 nu
顺序表的初始化，增加，删除，摧毁
m0_46376834的博客
03-23 330
#include<stdlib.h> #include <iostream> using namespace std; #define MAX_SIZE 100 typedef struct { int* elems;//顺序表地址 int length;//顺序表长度 int size;//顺序表的空间 }SqList; bool InitList(SqList& L);//顺序表的初始化 bool listAppend(SqList& L, int e
【数据结构】线性表的顺序存储结构及实现——C语言版
热门推荐
Anya-.-的博客
10-03 2万+
线性表的顺序存储结构（顺序表）及实现——C语言版
线性表顺序存储实现
04-07
线性表顺序存储实现，学习数据结构的链表中较为基础的顺序链表存储，实现对应的。h文件的函数实现
顺序存储的线性表基本算法实现
07-04
构造一个空的顺序表InitList_Sq； 初始化一个顺序表，将顺序表所有元素置为0 SetList_Sq 建立顺序表，给表中各元素赋值SetList_Sq 销毁一个已存在的顺序表, 回收所分配的空间DestroyList_Sq 将已存在的顺序表重置为空表ClearList_Sq； 判断表是否为空ListEmpty_Sq； 求顺序表中当前元素个数ListLength_Sq； 返回给定元素e的前驱priorElem_Sq； 返回给定元素e的后继NextElem_Sq 查找某个给定元素e出现的第一个位置LocateElem_Sq 查找给定位置i的元素GetElem_Sq 在第i个位置前插入新元素ListInsert_Sq； 删除给定位置i的元素（位置删除）ListDelete_Sq 删除顺序表中所有值为给定值的元素（值删除）ListDeleteElem_Sq 输出顺序表的内容ListPrint_Sq； 合并两个顺序表，即将一个顺序表接在另一个顺序表之后Append_Sq
php线性表顺序存储实现代码(增删查改)
10-28
PHP线性表顺序存储实现代码（增删查改） PHP实现线性表顺序存储的代码，需要的朋友可以参考下。线性表是一种基本的数据结构，它可以用来存储和操作一组数据。顺序存储是指将数据存储在一块连续的内存空间中，每个...
线性表的顺序存储与实现
07-29
线性表是计算机科学中一种基础的数据结构，它是由n（n≥0）个相同...提供的文件"02-线性表的顺序存储与实现"很可能是关于如何在具体编程语言中实现这些操作的示例代码，可以作为学习和理解线性表顺序存储的参考资料。
线性表顺序存储运算的算法实现
09-03
本话题将深入探讨线性表的顺序存储结构及其在C语言中的算法实现，包括线性表的输入输出、插入、删除以及长度和置空操作。 1. **线性表的顺序存储结构** 在顺序存储结构中，线性表的元素在内存中以数组的形式存储，...
Python 数据结构 之 线性表 的顺序存储结构
PyTi
11-06 2925
本文所采用的数据结构模板为 《数据结构教程》C语言版，
顺序队列的初始化，建立，插入，查找，删除。
weixin_30430169的博客
10-10 252
代码 ////////////////////////////////////////////////顺序队列的初始化，建立，插入，查找，删除。////Author:Wang Yong // //Date: 2010.8.19 ////////////////...
线性表的顺序存储结构实现.
02-01
线性表的顺序存储结构实现
2.2线性表的顺序存储与基本操作
WithoutEndFree的博客
05-23 830
2.2线性表的顺序存储与基本操作 线性表是一对一的逻辑关系，要存放在计算机中，可采用顺序、链式两种存储结构。 一、顺序表的类型定义 线性表的顺序存储简称为顺序表：用一组地址连续的存储单元依次存储线性表中的各个元素。逻辑上相邻的数据元素在物理上也相邻。 因此：将顺序表归纳为：关系线性化，结点顺序存。 给出线性表存储的线性公式： 假设线性表中有 n 个元素，每个元素占 k 个单元，第一个元素的地址为...
线性表的顺序存储结构（java版）
rongtuteng的专栏
09-04 443
http://hjj20040849.iteye.com/blog/1816838 在说线性表的顺序存储结构之前，首先要讲一下必要的定义。 线性表的定义 ：零个或多个数据元素的有限序列 线性表的顺序存储结构 ：用一段地址连续的存储单元依次存储线性表的数据元素。   在了解这两个必要的定义之后，我们就来看一下他的代码实现吧，在本文中，由于我个人比较熟悉Java，所以
python实现线性表顺序存储的插入操作
随手关灯的博客
02-24 1016
def insert_list(L,i,element): L_lenght = len(L) if iL_lenght: return false if i<L_lenght: for k in range(i-1,L_lenght)[::-1]: #循环，将指定位置后面的元素向后移一位，从后往前移 L[k+1:K+2]=[L[K]] L[i-1] = element
2.2线性表的顺序存储
Zzc_IT_log的博客
08-17 550
2.2.1 线性表的顺序存储 线性表的顺序存储指的是将线性表的数据元素按其逻辑次序依次存入一组地址连续的存储单元里，用这种方法存储的线性表称为顺序表。 顺序存储结构的特点：元素在表中的相邻关系，在计算机内存中存在着相邻关系。 线性表的第一个元素a1的存储位置通常称为基地址。只要知道基地址和每个元素占用的单元数（元素的大小），就可求出任意一个元素的存储地址。因此只要确定了线性表存储的起始位置，线性表中的任意一个元素都可以随机存取，所以顺序表示一种随机存储结构。 在高级程序语言中通常用数组来描述顺序表。 2.2
Python实现--线性表-顺序存储结构--的基本运算
嗨皮lemon的博客
05-09 1341
class SequenceList(): def __init__(self): self.SeqList = [] def createSequenceList(self): element = input('please input a numer and enter # ensure:') while element != '#': self.SeqList.appe...
线性表的顺序储存结构 初始化、查找、删除、插入
上下求索
08-10 1770
数据结构线性表顺序储存结构
python线性表顺序链式存储实现_线性表的链式存储(C代码实现)
weixin_42548888的博客
02-10 501
线性表的链式存储结构线性表的实现分顺序存储结构和链式存储结构。上一节我们学学习了线性表的实现分顺序存储结构，并实现解顺序存储的基本操作。这一节我们来学习线性表链式存储结构，那我们再想象一下我为什么我们要引入链式存储结构，万物存在必有其道理主要还是因为线性存储结构存在着这样一个问题：当我们需要插入和删除元素时，就必须挪动大量与之无关的元素，因为线性存储结构结点与节点之间的关系是相邻关系，一个节点挨着...
《大话数据结构》-3-一文学会数据结构中的线性表+顺序存储结构（概念，实例，代码）
weixin_45594172的博客
03-15 809
《大话数据结构》-3-一文学会数据结构中的线性表+顺序存储结构（概念，实例，代码）
线性表顺序存储代码实现
最新发布
09-27
下面是一段简单的代码实现线性表顺序存储： ``` typedef struct { ElemType data[MaxSize]; // 存放顺序表元素 int length; // 存放顺序表的长度 } SqList; void InitList(SqList *&L) { L = (SqList *)malloc...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值