Ten days - 压缩数组

最新推荐文章于 2024-02-12 23:14:29 发布
最新推荐文章于 2024-02-12 23:14:29 发布
阅读量815 收藏
点赞数 2
文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60459642/article/details/124889133
版权

目录

压缩数组的理解：

压缩数组的实现：

代码定义：

初始化：

普通数组转化成压缩：

压缩转化为普通数组：

 压缩数组的转置：

路思：

总代码：

---这次是压缩数组，其中有数组压缩、压缩数组还原、以及压缩数组的转置。

压缩数组的理解：

为什么需要压缩数组呢？为了节省空间如图：

就是利用数组存储，有效数据所在位置

压缩数组的实现：

代码定义：

typedef struct Triple {//用与记录 
	int i;
	int j;
	elem e; 
}Triple, *TriplePtr;

typedef struct CompressedMatrix {//压缩数组
	int rows, columns, numElements;
	Triple* elements;
}CompressedMatrix, *CompressedMatrixPtr;

这里利用的是struct嵌套实现-有名称意义二维数组（numElements * 3）， 内嵌的struct便是有类别3个元素 ，分别是行、列、数据。

初始化：

CompressedMatrixPtr initCompressedMatrix(int paraRows, int paraColumns, int paraElements, int** paraData) {
	CompressedMatrixPtr resultPtr = (CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
	resultPtr->columns = paraColumns;
	resultPtr->rows = paraRows;
	resultPtr->numElements = paraElements;
	resultPtr->elements = (TriplePtr)malloc(paraElements * sizeof(struct Triple));
	
	for (int i  = 0; i < paraElements; i++) {
		resultPtr->elements[i].i = paraData[i][0];
		resultPtr->elements[i].j = paraData[i][1];
		resultPtr->elements[i].e = paraData[i][2];
	}//Of for i.
	
	return resultPtr;
}

普通数组转化成压缩：

int** exchangeCompressed(TwoDArrayPtr paraPtr) {
	int** resultArray;

	resultArray = (int**)malloc(countValuableElement(paraPtr) * sizeof(int*));
	for (int i = 0; i < countValuableElement(paraPtr); i++) {
		resultArray[i] = (int*)malloc(3 * sizeof(int));
	}
	
	int k = 0;
	for (int i = 0; i < paraPtr->rows; i++) {
		for (int j = 0; j < paraPtr->columns; j++) {
			if (paraPtr->elements[i][j] != 0) {
				resultArray[k][0] = i;
				resultArray[k][1] = j;
				resultArray[k][2] = paraPtr->elements[i][j];
				k++;
			}
		}
	}
	return resultArray;	
}

其中的的 countValuableElement()数有效数据的个数：

int countValuableElement(TwoDArrayPtr paraPtr) {
	int cnt = 0;
	for (int i = 0; i < paraPtr->rows; i++) {
		for (int j = 0; j < paraPtr->columns; j++) {
			if (paraPtr->elements[i][j] != 0) {
				cnt++;
			}
		}
	}
	return cnt;
}

压缩转化为普通数组：

TwoDArrayPtr returnCompressed(CompressedMatrixPtr paraPtr) {
	TwoDArrayPtr resultArray = initTwoDArray(paraPtr->rows, paraPtr->columns);
	
	int k = 0;
	for (int i = 0; i < paraPtr->rows; i++) {
		for (int j = 0; j < paraPtr->columns; j++) {
			if (paraPtr->elements[k].i == i && paraPtr->elements[k].j == j) {
				resultArray->elements[i][j] = paraPtr->elements[k].e;
				k++;
			} else {
				resultArray->elements[i][j] = 0;
			}
			
		}
	}
	return resultArray;
}

 压缩数组的转置：

CompressedMatrixPtr transposeCompressedMatrix(CompressedMatrixPtr paraPtr) {
	//Step 1. 建立记录数组
	int *tempColumnCounts = (int*)malloc(paraPtr->columns * sizeof(int));//记录每一列所拥有的数据个数。 
	int *tempOffsets = (int*)malloc(paraPtr->columns * sizeof(int));//记录列交换后新二维数组的位置 
	//初始化
	for (int i = 0; i < paraPtr->columns; i++) {
		tempColumnCounts[i] = 0;//一开始全为 0 
	}
	
	//初始化新数组
	CompressedMatrixPtr resultPtr = (CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
	resultPtr->rows = paraPtr->columns;
	resultPtr->columns = paraPtr->rows;
	resultPtr->numElements = paraPtr->numElements;
	resultPtr->elements = (TriplePtr)malloc(paraPtr->numElements * sizeof(struct Triple));
	
	//Step 2.扫描数组
	for (int i = 0; i < paraPtr->numElements; i++) {
		tempColumnCounts[paraPtr->elements[i].j]++;
	} 
	
	//Step 3.初始化offset 
	tempOffsets[0] = 0;
	for(int i = 1; i < paraPtr->columns; i++) {
		tempOffsets[i] = tempOffsets[i - 1] + tempColumnCounts[i - 1];
	}
	
	//Step 4.填入
	int tempPosition, tempColumn;
	for (int i = 0; i < paraPtr->numElements; i++) {
		tempColumn = paraPtr->elements[i].j;
		tempPosition = tempOffsets[tempColumn];//给转前的列数，转化为其在之后的行的数列 
		//交换
		resultPtr->elements[tempPosition].i = paraPtr->elements[i].j;
		resultPtr->elements[tempPosition].j = paraPtr->elements[i].i;
		resultPtr->elements[tempPosition].e = paraPtr->elements[i].e;
		 
		tempOffsets[tempColumn]++;
	} //Of for i;
	
	return resultPtr; 
}

路思：

主要思路就是需要记录转置之前每列的数据个数-tempColumnCounts，然后记录转置之后之前的列在现在行的位置-tempOffsets（随填入而更新的），然后再俩点保障数据再正确位置，另外直接交换压缩数组的行列即可。

总代码：

#include <stdio.h> 
#include <malloc.h>

typedef int elem;//

/*
 * A trile for row index, colum index, and data.
 */
 
typedef struct Triple {//用与记录 
	int i;
	int j;
	elem e; 
}Triple, *TriplePtr;

/**
 * A triple for row index, colum index, and data.
 */

typedef struct CompressedMatrix {
	int rows, columns, numElements;
	Triple* elements;
}CompressedMatrix, *CompressedMatrixPtr;

//稀疏数组 
typedef struct TwoDArray{
	int rows;
	int columns;
	int** elements;
}TwoDArray, *TwoDArrayPtr;

TwoDArrayPtr initTwoDArray(int paraRows, int paraColumns){
	int i;
	TwoDArrayPtr resultPtr = (TwoDArrayPtr)malloc(sizeof(TwoDArray));
	resultPtr->columns = paraColumns;
	resultPtr->rows = paraRows;
	resultPtr->elements = (int**)malloc(sizeof(int*) * paraRows);
	for (i = 0; i < paraRows; i++) {
	resultPtr->elements[i] = (int*)malloc(sizeof(int) * paraColumns);
	}//Of for(i)
	
	return resultPtr;
}

void printTwoDArray(TwoDArrayPtr paraPtr) {
	for (int i = 0; i < paraPtr->rows; i++) {
		for (int j = 0; j < paraPtr->columns; j++) {
			printf("%d ", paraPtr->elements[i][j]);
		}//Of for i
		printf("\r\n");
	}//Of for j
}



/**
 * Initialize a compressed matrix.
 */
CompressedMatrixPtr initCompressedMatrix(int paraRows, int paraColumns, int paraElements, int** paraData) {
	CompressedMatrixPtr resultPtr = (CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
	resultPtr->columns = paraColumns;
	resultPtr->rows = paraRows;
	resultPtr->numElements = paraElements;
	resultPtr->elements = (TriplePtr)malloc(paraElements * sizeof(struct Triple));
	
	for (int i  = 0; i < paraElements; i++) {
		resultPtr->elements[i].i = paraData[i][0];
		resultPtr->elements[i].j = paraData[i][1];
		resultPtr->elements[i].e = paraData[i][2];
	}//Of for i.
	
	return resultPtr;
} 

/**
 * Print the compressed matrix.
 */
void printCompressedMatrix(CompressedMatrixPtr paraPtr) {
	for (int i = 0; i < paraPtr->numElements; i++) {
		printf("(%d, %d): %d\n", paraPtr->elements[i].i, paraPtr->elements[i].j, paraPtr->elements[i].e);
	}//Of for i
}

/**
 * Transpose a compressed matrix.
 */
 
CompressedMatrixPtr transposeCompressedMatrix(CompressedMatrixPtr paraPtr) {
	//Step 1. 建立记录数组
	int *tempColumnCounts = (int*)malloc(paraPtr->columns * sizeof(int));//记录每一列所拥有的数据个数。 
	int *tempOffsets = (int*)malloc(paraPtr->columns * sizeof(int));//记录列交换后新二维数组的位置 
	//初始化
	for (int i = 0; i < paraPtr->columns; i++) {
		tempColumnCounts[i] = 0;//一开始全为 0 
	}
	
	//初始化新数组
	CompressedMatrixPtr resultPtr = (CompressedMatrixPtr)malloc(sizeof(struct CompressedMatrix));
	resultPtr->rows = paraPtr->columns;
	resultPtr->columns = paraPtr->rows;
	resultPtr->numElements = paraPtr->numElements;
	resultPtr->elements = (TriplePtr)malloc(paraPtr->numElements * sizeof(struct Triple));
	
	//Step 2.扫描数组
	for (int i = 0; i < paraPtr->numElements; i++) {
		tempColumnCounts[paraPtr->elements[i].j]++;
	} 
	
	//Step 3.初始化offset 
	tempOffsets[0] = 0;
	for(int i = 1; i < paraPtr->columns; i++) {
		tempOffsets[i] = tempOffsets[i - 1] + tempColumnCounts[i - 1];
	}
	
	//Step 4.填入
	int tempPosition, tempColumn;
	for (int i = 0; i < paraPtr->numElements; i++) {
		tempColumn = paraPtr->elements[i].j;
		tempPosition = tempOffsets[tempColumn];//给转前的列数，转化为其在之后的行的数列 
		//交换
		resultPtr->elements[tempPosition].i = paraPtr->elements[i].j;
		resultPtr->elements[tempPosition].j = paraPtr->elements[i].i;
		resultPtr->elements[tempPosition].e = paraPtr->elements[i].e;
		 
		tempOffsets[tempColumn]++;
	} //Of for i;
	
	return resultPtr; 
}

/*
 ** test
 */
 
void compressedMatrixTest(){
	printf("--- compressedMatrixTest begins ----\n");
	CompressedMatrixPtr tempPtr1, tempPtr2;
	int tempElements;
	
	//建立二维数组-动态.
	tempElements = 4;
	int** tempMatrix1 = (int**)malloc(tempElements * sizeof(int*));
	for (int i = 0; i < tempElements; i++) {
		tempMatrix1[i] = (int*)malloc(3 * sizeof(int));
	}
	
	//初始化
	int tempMatrix2[4][3] = {{0, 0, 2}, {0, 2, 3}, {2, 0, 5}, {2, 1, 6}};
	//给动态数组赋值 
	for (int i = 0; i < tempElements; i++) {
		for (int j = 0; j < 3; j++) {
			tempMatrix1[i][j] = tempMatrix2[i][j]; 
		}
	}
	tempPtr1 = initCompressedMatrix(2, 3, 4, tempMatrix1); 
	printf("After initialization \n");
	printCompressedMatrix(tempPtr1);
	
	tempPtr2 = transposeCompressedMatrix(tempPtr1);
	printf("After traspose. \n");
	printCompressedMatrix(tempPtr2);
	
	printf("--- compressedMatrixTest ends ----\n");
}

int countValuableElement(TwoDArrayPtr paraPtr) {
	int cnt = 0;
	for (int i = 0; i < paraPtr->rows; i++) {
		for (int j = 0; j < paraPtr->columns; j++) {
			if (paraPtr->elements[i][j] != 0) {
				cnt++;
			}
		}
	}
	return cnt;
}
 
int** exchangeCompressed(TwoDArrayPtr paraPtr) {
	int** resultArray;

	resultArray = (int**)malloc(countValuableElement(paraPtr) * sizeof(int*));
	for (int i = 0; i < countValuableElement(paraPtr); i++) {
		resultArray[i] = (int*)malloc(3 * sizeof(int));
	}
	
	int k = 0;
	for (int i = 0; i < paraPtr->rows; i++) {
		for (int j = 0; j < paraPtr->columns; j++) {
			if (paraPtr->elements[i][j] != 0) {
				resultArray[k][0] = i;
				resultArray[k][1] = j;
				resultArray[k][2] = paraPtr->elements[i][j];
				k++;
			}
		}
	}
	return resultArray;	
}

TwoDArrayPtr returnCompressed(CompressedMatrixPtr paraPtr) {
	TwoDArrayPtr resultArray = initTwoDArray(paraPtr->rows, paraPtr->columns);
	
	int k = 0;
	for (int i = 0; i < paraPtr->rows; i++) {
		for (int j = 0; j < paraPtr->columns; j++) {
			if (paraPtr->elements[k].i == i && paraPtr->elements[k].j == j) {
				resultArray->elements[i][j] = paraPtr->elements[k].e;
				k++;
			} else {
				resultArray->elements[i][j] = 0;
			}
			
		}
	}
	return resultArray;
}

void test() {
	printf("---- test begins ----\n");
	TwoDArrayPtr tempPtr = initTwoDArray(3, 3);
	//稀疏数组初始化
	for (int i = 0; i < 3; i++) {
		for(int j = 0; j < 3; j++) {
			if (i == 0 && j == 0) {
				tempPtr->elements[i][j] = 2;
			} else if (i == 0 && j == 2) {
				tempPtr->elements[i][j] = 3;
			} else if (i == 2 && j == 0) {
				tempPtr->elements[i][j] = 5;
			} else if (i == 2 && j == 1) {
				tempPtr->elements[i][j] = 6;
			} else {
				tempPtr->elements[i][j] = 0;
			}
		}
	}
	
	printf("after init array.\n");
	printTwoDArray(tempPtr);
	
	//压缩
	int** array = exchangeCompressed(tempPtr);
	CompressedMatrixPtr tempCompressedPtr = initCompressedMatrix(tempPtr->rows, tempPtr->columns, countValuableElement(tempPtr), array);
	printf("After exchange.\n");
	printCompressedMatrix(tempCompressedPtr);
	
	//转置 
	CompressedMatrixPtr tempCompressedPtr2 = transposeCompressedMatrix(tempCompressedPtr);
	printf("After transpose.\n");
	printCompressedMatrix(tempCompressedPtr2);
	
	//返回稀疏函数 
	TwoDArrayPtr tempDAPtr =  returnCompressed(tempCompressedPtr2);
	printf("After retrun.\n");
	printTwoDArray(tempDAPtr);
	printf("---- test ends ----\n");
}
int main(void){
	compressedMatrixTest();
	test();
	return 0;
}

星辰小嘟嘟
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
稀疏数组（压缩数组）
XPiedPiperX的博客
12-08 931
如何用代码来表示棋盘？ 棋盘（11 * 11） 如图所示，一个 11 * 11 的围棋棋盘。 三枚黑子的位置分别为 (1,2) (2,3) (3,2) 一枚白子的位置为 (2,2) 传统方式一般会联想到二维数组来表示棋盘，假设： 黑棋的值为1。 白棋的值为2。 没有落子的值为0。 用二维数组来表示棋盘和棋子的 Golang 代码： package main import "fmt" type Node struct { row int // 行 column in..
一种通用整形数组压缩方法
阿里云技术
07-13 360
我们在开发中后台应用或者中间件的时候，会存储一些数据在内存中以加快访问速度。随着数据量的增加，除了可以放置于堆外，还可以通过实时压缩来缓解。今天就给大家介绍一种压缩整形数组的方式。 一 数据压缩 数组指 long[] 或者 int[] 类型，在 Java 中应用很广。当数据量很大时，其内存占用的问题便突显出来，原因是一个 long 类型是占 8 个字节，而 int 也是占用 4 个字节，当有千万级别的数据时，其占用的空间便是上百 MB 级别的了。 1 去冗余 首先想到的就是缩减每个数字占用的空间..
数组存储压缩原理
fight252的博客
06-02 900
啊
Array和特殊数组的压缩
读书 好学 求知
12-22 546
1. Array数组简介 当我们提到数组时，很多时候都说的是一维数组，一维数组是线性的，但数组本身并不是线性的，它包括二维，多维数组。 数组在内存中的分配是连续的，也就意味着你在创建它时就需要告诉内存它的容量(length)。这里我们用length表示，以和Java中的数组属性一致。length在java的数组中是固有属性，在一般情况下也是所以其他的数组实现是固有属性。 1.1 Array的数学表...
Java数据结构和算法—稀疏数组
karenelise的博客
03-22 130
Java数据结构和算法—稀疏数组和队列基本介绍 基本介绍 当一个数组中大部分元素为0，或者为同一个值的数组时，可以用稀疏数组来保存该数组。 稀疏数组的处理方法是： 1、记录数组一共有几行几列，有多少个不同的值 2、把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模。 ...
数组取平均压缩
weixin_30301449的博客
03-19 173
后台蓝牙采集到的数据量很大，比如有1389条数据，但是在界面上只能显示30个数据点，多了的话这回影响界面美观。那么这样我们后台向前台提供数据时需要将数据压缩成30个点。1389/30=46.3。如果简单将每46个数据取平均或者没47个取平均都会影响精度。所以基本想法是将0.3作为修正因子，每隔46加0.3。直到修正因子达到1 或者1以上时，就将47个数据取平均，再将小数部分作为修正因子。由于只需要...
Microsoft Cognitive Toolkit-快速指南
cunzai1985的博客
09-22 1248
Microsoft Cognitive Toolkit-快速指南 (Microsoft Cognitive Toolkit - Quick Guide) Advertisements 广告 Previous Page 上一页 Next Page 下一页 Microsoft认知工具包(CNTK)-简介 (Microsoft Cognitive Toolkit ...
A002-185-2502-李林
m0_50973829的博客
01-03 2919
作业A001-185-2502-李林 课程名称 软件需求分析与建模 班级 18软件工程5班 教导教师 董瑞生 李林 1814080902502 日期 2020.12.15 目录 作业内容目录一、个人查找档总结Requirements baseline（需求基线） 一、个人查找档总结 Requirements baseline（需求基线） ...
再读 Laravel 5.5 文档
OneGoal的博客
05-16 2691
本文档前言 Laravel 文档写的很好，只是新手看起来会有点吃力，需要结合经验和网上的文章，多读、细读才能更好的理解。Again，多读、细读官方文档。本文类似于一个大纲，欲知其中详情，且去细读官方文档：Laravel 5.5 docs。 ####################################################################...
《Linux命令行与shell脚本编程》学习笔记
wdxzuishuia的博客
05-20 1492
学习《Linux命令行与shell脚本编程大全》以后的个人笔记，如有侵权请联系我，立刻删除
要看就看最好，16万字全网最硬核redis总结，谁赞成，谁反对？（被粉丝疯狂催更，已有人反馈看完专栏拿到大厂offer！！！）
热门推荐
Java框架、并发编程、分布式、微服务、Redis、HarmonyOS、中间件等技术
10-10 1万+
被粉丝疯狂催更，已有人反馈看完专栏拿到大厂offer，非常适合应届毕业生和初中级工程师！！！
【JavaScript】如何压缩和解压数组
最新发布
鑫宝的博客
02-12 628
两个或多个数组的 Zipping 是指将它们的元素合并成一个数组。可以看到，本例中的第一个数组包含原始数组的所有第一个元素，第二个数组包含所有第二个元素，以此类推。
数组压缩为稀疏数组
ou_shen_xian的博客
11-27 257
***数组压缩 数组中多数为零，造成空间浪费 压缩示意图如下 package Continue; public class ArraysDemo9 { //稀疏数组，压缩数组，节省空间，只记录有效数据 /* * 0 0 0 0 0 0 0 * 0 5 0 0 0 0 0 * 0 0 0 0 6 0 0 * 0 0 0 0 0 0 0 * * 将上面的数组压缩为 * 4 7 2 4行7列的数组，有效数字2个
压缩数组.c
封雷的博客
12-12 1226
已知一维整型数组a中的数已按由小到大的顺序排列， 编写程序，删去一维数组中所有相同的数，使之只剩一个。 #include &lt;stdio.h&gt; int main() { int arr1[] = {1,1,2,3,3,3,4,4,4,4,5}; int len1 = sizeof arr1 / sizeof(int); int arr2[len1]; int len2 ...
【Unity5.x Shaders】压缩数组Packed arrays
森系少女的游戏梦
10-18 634
在Cg中有两种变量：单一值和压缩数组。 压缩数组的定义是类型 + 数字 例如float3，int4 压缩数组看起来跟普通的数组很像却又不一样，压缩数组的元素可以作为普通结构访问。压缩数组中成员的访问及赋值 通常通过x,y,z,w访问float4 a; a.x=2.0; Cg也提供别名：r, g, b, a。这两种访问方式没有区别，但是不能混用,例如_Color.xgb是错误的 Cg允许压
数据结构：数组—特殊矩阵的压缩存储
weixin_47957908的博客
03-17 616
相同类型特例扩展结构固定维数和维界不再改变取元素和修改元素值插入和删除具有相同的数据类型对应的下标随机存储结构注意内存单元地址是一维解决将多维关系映射到一维关系。
数组的压缩存储（数据结构学习笔记）
省洗发水钱买书
12-14 2969
文章目录数组数组的存储结构一维数组的存储结构二维数组的存储结构一、二维数组按行优先存放二、二维数组按列优先存放特殊矩阵的压缩存储一、对称矩阵的压缩存储二、上、下三角矩阵的压缩存储上三角矩阵下三角矩阵三、对角矩阵的压缩存储 数组 数组的存储结构 在设计数组的存储结构时，通常将数组的所有元素存储到存储器的一块地址连续的内存单元中，即数组特别适合采用顺序存储结构来存储。 一维数组的存储结构 对于一维数组(a1,a2,···,ai,···,an),按元素顺序存储到一块地址连续的内存单元中，假设第一个元素a1的存储
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值