位图排序（位图技术应用）

最新推荐文章于 2024-03-31 21:10:18 发布
最新推荐文章于 2024-03-31 21:10:18 发布
阅读量3.7k 收藏 6
点赞数
分类专栏： 结构与算法 文章标签： exception string null file 测试 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovesqcc/article/details/6204224
版权

 

        1.  问题描述

         给定不大于整数 n 的 k 个互不相等的整数 ( k <n ) ， 对这些整数进行排序。本文讨论的内容具体可参见《编程珠玑》（第二版）的第一章。

 

        2.  问题分析

        关于排序，已经有多种排序方法了：插入排序，归并排序，快速排序，希尔排序等。每种排序都有不同的用武之地。为什么需要位图排序呢？所有的内部排序（上述所提及）都必须一次性将所有排序元素载入内存。假如有1000,000个整数，每个整数4字节，则意味着，至少需要4000,000B 约为 4MB 的内存空间， 如果仅仅只有 1MB 的内存空间可用，那么，应该怎么办呢？

        很多问题都有通用的求解策略，而在通用之外，常常需要根据问题的实际需求及特征挖掘有针对性的解决方案。这里的特征是，所有整数均不大于 n , 并且整数互不重复。怎么利用这一特征呢？

        可以采用位图技术。所谓位图技术，就是将问题映射到位串上，对位串进行处理后，再将位串逆射到问题空间上。具体而言， 假设要对数组 不大于 20 的元素数组 [5, 2, 12, 18, 7, 9, 13, 19, 16, 4, 6] 进行排序， 则可以将其映射到位串 11010011001001110100 ，其中， 1 表示数组元素出现的位置（最高位在后面，最低位在左边，以下标0起头），然后，从低位往高位扫描， 即可得到 { 2, 4, 5, 6, 9, 12,13,16,18,19} 这样就排序好了。根据位图技术， 1000,000 个互不重复的整数数组的排序， 只需要大约 1000,000 b = 0.125MB 内存空间。

 

       3.  详细设计

         [ 1 ]  输入： 一个未排序的数组， 数组中的各数互不相等， 都不大于某个整数 n , 且稠密地分布在[0, n-1] 的区间中

         [ 2 ]  输出： 一个已排序的数组

         [ 3 ]  数据结构： 位向量。 位图排序的关键在于位向量的实现。位向量有“置一”、“清零”、“测试位是否为1”等操作。从实现角度，可以使用一个整型数组来实现（因为在Java中，移位、按位运算都是以整数为基本单位），这意味着，每32位为一组。 位向量长度最好取为 32 的倍数， 以方便编程。 假设有 64位， 那么对第59位置1,  59/32 = 1 ， 59 %32 = 27；这意味着，需要对第1组 a[1] 的第 27 位进行置位。 除以32 可使用 右移 5 位 （ i >> 5） 来实现， 对 32 取模， 可以通过 1 << ( i & 0x1f )  来实现。 剩下的，就是细节问题了，比如，确保边界不出错。位串方向规定为： a[p]a[p-1]...a[1]a[0] , p = N / 32; N 为不小于 n 的 32 倍数的最小整数。 a[p] 为最高位的32位， a[0] 为最低位的32位。

 

        4.   算法描述

          STEP1： 根据问题描述确定位向量的位数， 初始化位向量bv；

          STEP2： 对于数组的每一个元素，用其数值作为位置，对位向量的相应位置 1；

          STEP3： 从低位向高位扫描，对位向量的每一位，若位为1, 则输出该位的位置下标，作为最终排序数组的元素值。

  

       5.   Java 代码实现

         

package datastructure.vector;

/**
 * 实现 n 维位向量 
 *
 */
public class NBitsVector {
	
	 private static final int BITS_PER_INT = 32;
	 private static final int SHIFT = 5;
	
	 // 将一个整型数组中的所有整数的位串联成一个位向量
	 private int[] bitsVector;
	 
	 // 位向量的总位数
	 private int bitsLength;
	 
	 public NBitsVector(int n) {
		 int i = 1;
		 while (i * BITS_PER_INT < n) { i++;}
		 this.bitsLength = i * BITS_PER_INT;
		 if (bitsVector == null) {
			 bitsVector = new int[i];
		 }
		 
	 }
	 
	 /**
	  * setBit: 将位向量的第 i 位置一
	  * @param i  要置位的位置
	  */
	 public void setBit(int i) {
		 bitsVector[i >> SHIFT] |= 1 << (i & 0x1f);
	 }
	 
	 /**
	  * clrBit: 将位向量的第 i 位清零
	  * @param i 要清零的位置
	  */
	 public void clrBit(int i) {
		 bitsVector[i >> SHIFT] &= ~(1 << (i & 0x1f));
	 }
	 
	 /**
	  * testBit: 测试位向量的第 i 位是否为 1
	  * @param i 测试位的位置
	  * @return 若位向量的第 i 位为 1, 则返回true, 否则返回 false
	  */
     public boolean testBit(int i) {
    	 return (bitsVector[i >> SHIFT] & 1 << (i & 0x1f)) != 0;
     }
     
     
     /**
      * clr: 位向量全部清零
      */
     public void clr() {
    	int vecLen = bitsVector.length;
    	for (int i = 0; i < vecLen; i++) {
    		bitsVector[i] = 0;
    	}
     }
     
     /**
      * getBitsLength: 获取位向量的总位数
      */
     public int getBitsLength() {
		return bitsLength;
	}

	/**
      * 获取给定整数 i 的二进制表示， 若高位若不为 1 则补零。 
      * @param i 给定整数 i
      */
     public String intToBinaryStringWithHighZero(int i) {
    	 String basicResult = Integer.toBinaryString(i); 
    	 int bitsForZero = BITS_PER_INT - basicResult.length();
    	 StringBuilder sb =  new StringBuilder("");
    	 while (bitsForZero-- > 0) {
    		 sb.append('0');
    	 }
    	 sb.append(basicResult);
    	 return sb.toString();
     }
     
     public String toString() {
    	 StringBuilder sb = new StringBuilder("Bits Vector: ");
    	 for (int i = bitsVector.length-1; i >=0 ; i--) {
    		 sb.append(intToBinaryStringWithHighZero(bitsVector[i]));
    		 sb.append(" ");
    	 }
    	 return sb.toString();
     }
     
     public static void main(String[] args) 
     {
    	 NBitsVector nbitsVector = new NBitsVector(64);
    	 nbitsVector.setBit(2);
    	 System.out.println(nbitsVector);
    	 nbitsVector.setBit(7);
    	 nbitsVector.setBit(18);
    	 nbitsVector.setBit(25);
    	 nbitsVector.setBit(36);
    	 nbitsVector.setBit(49);
    	 nbitsVector.setBit(52);
    	 nbitsVector.setBit(63);
    	 System.out.println(nbitsVector);
    	 nbitsVector.clrBit(36);
    	 nbitsVector.clrBit(35);
    	 System.out.println(nbitsVector);
    	 System.out.println("52: " + nbitsVector.testBit(52));
    	 System.out.println("42: " + nbitsVector.testBit(42));
    	 nbitsVector.clr();
    	 System.out.println(nbitsVector);
     }
	 
}

  

package algorithm.sort;

import java.util.Arrays;

import datastructure.vector.NBitsVector;

/**
 * 位图排序
 *
 */
public class BitsMapSort {
	
	private NBitsVector nBitsVector; 
	
	public BitsMapSort(int n) {
		if (nBitsVector == null) {
			nBitsVector = new NBitsVector(n);
		}
	}
	
	public int[] sort(int[] arr) throws Exception {
		if (arr == null || arr.length == 0) {
			return null;
		}
		nBitsVector.clr();
		int arrLen = arr.length;
		for (int i=0; i < arrLen ; i++) {
			if (arr[i] < 0 || arr[i] > nBitsVector.getBitsLength()-1) {
				throw new Exception("给定整数 " + arr[i] + " 超过范围，请检查输入");
			}
			if (nBitsVector.testBit(arr[i])) {
				throw new Exception("存在重复整数: " + arr[i] + " ，请检查输入！");
			}
			nBitsVector.setBit(arr[i]);		
		}
		int bitsLength = nBitsVector.getBitsLength();
		int count = 0;
		for (int i=0; i < bitsLength; i++) {
			if (nBitsVector.testBit(i)) {			
				arr[count++] = i;
			}
		}
		return arr;
	}
	
	public static int maxOfArray(int[] arr)
	{
		int max = arr[0];
		for (int i=1; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
		}
		return max;
	}
	
	public static void test(int[] arr) 
	{
		try {
			// 63 可以改为 数组最大值 maxOfArray(arr)
			BitsMapSort bms = new BitsMapSort(64);
			System.out.println("排序前： " + Arrays.toString(arr));
			int[] sorted = bms.sort(arr);
			System.out.println("排序后： " + Arrays.toString(sorted));
		}
		catch(Exception e) {
			System.out.println(e.getMessage());	
		}
	}
	
	public static void main(String[] args) 
	{
		int[] empty = null;
		test(empty);
		empty = new int[0];
		test(empty);
		
		int[] unsorted = new int[] { 15, 34, 46, 52, 7, 9, 5, 10, 25, 37, 48, 13};
		test(unsorted);
		int[] unsorted2 =  new int[] { 15, 34, 46, 52, 7, 9, 5, 7, 25, 37, 48, 13};
		test(unsorted2);
		int[] unsorted3 =  new int[] { 15, 34, 46, 52, 7, 9, 5, 72, 25, 37, 48, 13};
		test(unsorted3);
	}

}

  

6.  C 源程序：

 

/*
 * bitvec.c : N维位向量的实现 
 * author: shuqin1984  2011-08-31
 */

#include <assert.h>

#define N  10000000
#define M  ((N%32==0) ? (N/32) : (N/32+1))
#define SHIFT 5
#define mod32(n)  ((n) - (((n) >> SHIFT) << SHIFT))

int bitvec[M];  // N维位向量用 M个整数的数组来实现 

int test(int i);    // 测试位向量的位 i 是否为 1
void set(int i);    // 将位向量第 i 位置 1
void clear(int i);  // 将位向量第 i 位清零
void clearAll();    // 将位向量所有位清零 
void show();        // 显示位向量的当前值
void printb(int x, int i);  // 打印正整数 x 的第 i 位二进制 
void printbz(int x, int n); // 打印正整数的二进制表示(从低位数起的n位)，若位数不够前面补零 

int test(int i)
{
    assert(i >= 0);
    return (bitvec[i>>SHIFT] & (1 << mod32(i))) != 0;
}

void set(int i)
{
    assert(i >= 0);
    bitvec[i>>SHIFT] |= (1 << mod32(i));
}

void clear(int i)
{
    assert(i >= 0);
    bitvec[i>>SHIFT] &= ~(1 << mod32(i));
}

void clearAll()
{
    int i;
    for (i = 0; i < M; i++) {
       bitvec[i] = 0;
    }     
}

void show()
{
     int i = 0;
     if (M == 1) {
         printbz(bitvec[i], N);     
     }
     else {
         int bits = (N%32==0)? 32: (N%32);
         printbz(bitvec[M-1], bits); 
         for (i=M-2; i >=0 ; i--) {
             printbz(bitvec[i], 32);
         } 
     }
     printf("\n");
}

void printb(int x, int i)
{
    printf("%c", '0' + ((((unsigned)x) & (1 << i)) >> i));    
}

void printbz(int x, int n)
{
   int i;
   for (i = n-1; i >= 0; i--) {
      printb(x, i);
   }
}


 

/*
 * bitsort.c: 实现位图排序并测量运行时间 
 * author: shuqin1984 2011-8-31
 */

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <assert.h>
#include <limits.h>
#include "bitvec.c"

#define MAX_LEN  10

void bitsort(char* filename);
void bitsortf();
void runtime(void (*f)());
void testdata(int, int);
int randRange(int low, int high);

int main()
{
    srand(time(0));
    printf("sizeof(int) = %d\n", sizeof(int));
    printf("RAND_MAX = %d\n", RAND_MAX);
    printf("INT_MAX = %d\n", RAND_MAX);
    
    runtime(bitsortf);
    
    getchar();
    return 0;
}


/*
 * 从指定文件名中读取数据，并进行排序，最后将排序后的数据写入 output.txt 中 
 */
void bitsort(char* filename)
{
     int i;
     char buf[MAX_LEN];
     
     FILE* fin = fopen(filename, "r");
     if (fin == NULL) {
         fprintf(stderr, "can't open file: %s", filename);
         exit(1);
     }
     while (fgets(buf, MAX_LEN, fin)) {
         set(atoi(buf));      
     }
     fclose(fin);
     
     // show();
     
     FILE* fout = fopen("output.txt", "w");
     if (fout == NULL) {
         fprintf(stderr, "can't open file: %s", "output.txt");
         exit(1);
     }
     for (i = 0; i < N; i++) {
         if (test(i)) {
             fprintf(fout, "%d\n", i);             
         }
     }
     fclose(fout);
     
     printf("---------- sort successfully ---------------");
     printf("\n");
     
}

void  bitsortf()
{
      bitsort("data.txt");
}

void  runtime(void (*f)())
{
      printf("runtime ... \n");
      int scale = 10;
      while (scale <= N) {
         testdata(scale, N);  
         clock_t start = clock();
         (*f)();
         clock_t end = clock();
         printf("scale: %d\t cost : %8.4f\n", scale, (double)(end-start)/CLOCKS_PER_SEC);
         printf("---------------------------------------------------");
         printf("\n");
         scale *= 10;
      }
}

/*
 *  创建测试数据：选出不大于 max 的 num 个正整数，并写入文件 data.txt 中  
 */
void testdata(int num, int max)
{
     int i;
     
     assert(num <= max);
     
     FILE* fout = fopen("data.txt", "w");
     if (fout == NULL) {
         fprintf(stderr, "can't open file: %s", "data.txt");
         exit(1);
     }
     for (i = 0; i < num; i++) {
        fprintf(fout, "%d\n", (rand()*rand()) % max);
     }
     fclose(fout);
     printf("---------- testdata successfully ---------------");
     printf("\n");
}
	
	/*
	 * randRange: 生成给定范围的随机整数
	 */
	int randRange(int low, int high)
	{
		assert (high <= low) ;
		return rand() % (high-low) + low;	
	}

 

 7.  额外说明

         位图技术，可以说是一种非常有效的求解技术，在文件管理中就有应用到， 其作用类似于二分搜索技术。位图技术还能检测重复整数，缺失整数，比如在 43亿多个不大于2^32的随机整数排列中寻找一个重复整数（根据抽屉原理知必然存在）。在读书时，不仅要汲取问题的求解方案，还要领悟背后的通用技术。

          如果问题不是对整数数组排序，而是对一系列记录排序，怎么利用已有算法呢？ 可以通过某种函数对记录的关键字进行计算，得到互不重复的整数（这个过程类似于散列法），然后，使用位图技术对整数数组进行排序。

 

影儿
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C++实现位图排序实例
09-04
在上述的【描述】和【部分内容】中，我们首先了解了位图排序的应用场景，即处理一个包含1千万个非负整数且大小不超过10000000的文件，内存限制为1MB，需要在几分钟内完成线性时间复杂度的排序。位图排序的核心思想是...
位图排序
松子茶的专栏
04-05 3500
主要是阐述位图在排序中的使用. 问题描述 位图排序是一种效率极高(复杂度可达O(n))并且很节省空间的一种排序方法，但是这种排序方法对输入的数据是有比较严格的要求(数据不能重复，大致知道数据的范围)。位图排序即利用位图或者位向量来表示集合。可以说算法中用到位操作的很多，因为速度快，空间小，比如哈有bitmask dp。文中的问题可以抽象为对[1:10000000]区间内的随机排列进行排序，
排序8：位图排序
纵横千里 捭阖四方 的专栏
08-02 601
位图排序也称为bitmap排序，它主要用于海量数据去重和海量数据排序，假如说有10 亿个int类型且全部不相同的数据，给1G内存让你排序，你怎么排，如果全部加载到内 存中，相当于40亿个字节，大概约等于4G内存。所以全部加载到内存肯定不行，如果我 们使用位图排序的话，我们用long类型表示，一个long占用8个字节也就是64位，所以 如果我们使用位图排序的话只会占用约0.125G内存,内存占用大大减少。但位图排序有 个缺点就是数据不能有重复的，如果有重复的会覆盖掉，这也是位图能在海量数据中去 重的原因，我们
算法之美——位图排序
小熊不去实验室
09-20 8792
辉爷的高级数据结构开讲了，辉爷V5啊，今天辉爷讲的是位图排序。   问题描述： •输入 –给出至多10,000,000个正整数的序列 •特征： –每个数都小于10,000,000 –数据不重复且 数据之间不存在关联关系 •输出：增序输出序列 •约束： –内存容量1MB –磁盘空间充足 –运行时间至多几分钟---最好线性时间   解答： 首先回顾下计数排序： •思
经典算法：位图排序
weixin_33730836的博客
12-26 204
最近发现一个有趣的排序算法，通过位图来完成排序。位图排序其实就是基数排序，只不过位图排序的下标是比特位。 问题描述 输入：一个最多包含n个正整数的文件，每个数都小于n，其中n=10^7。如果在输入文件中有任何正数重复出现就是致命错误。没有其他数据与该正数相关联。输出：按升序排列的输入正数的列表。 约束：最多有1MB的内存空间可用，有充足的...
C语言位图算法详解
09-04
位图算法是一种高效的数据处理技术，特别是在处理大量数据并判断数据状态时，它利用每一位来表示数据的一个特定状态。在C语言中，位图算法通常通过unsigned int类型的数组来实现，因为一个unsigned int变量可以存储...
Java 位图法排序的使用方法
09-05
位图法排序是一种在特定情况下效率较高的排序技术，尤其适用于数据范围相对较小的整数排序。这种方法基于位操作，利用数组来表示一个位图，其中每一位对应一个可能的数值。在Java中，虽然标准库中的排序算法如`...
C语言实现的bitmap位图代码分享
09-04
最后，程序将所有已设置的位对应的数字输出到`out.txt`文件中，实现了数字的排序或去重。 总结起来，这段C语言代码展示了如何利用位图数据结构来高效地处理和存储大量布尔值，以及如何进行位操作（如设置、清除和...
c# 实现位图算法（BitMap）
08-18
2. 不可对重复的数据进行排序和查找。 C# 中的 BitMap 实现 在 .NET 中已经实现了 BitMap 的数据结构——BitArray，我们可以直接使用官方的 BitArray 来解决问题。但是，我们也可以参照 .NET 源码实现一个简化版的...
位图排序《编程珠玑》
03-18
详见：http://blog.csdn.net/xjm199/article/details/21476491 实现位图排序，其中假设n为10 000 000，且输入文件包含1 000 000个正数；具体细节详见《编程珠玑》第一章问题； 由于数据的大小问题，在这#define N 1000，即数据在1000以内的100个数据，进行排序（当然由于随机数的产生问题，有数重复，在此并未处理）；
位图排序及其应用
zhangxinrun的专栏
10-14 1111
<br />输入：一个包含n个正整数的文件，每个正整数小于n,n等于10的7次方（一千万）。并且文件内的正整数没有重复和关联数据。<br />输出:  输入整数的升序排列<br />约束： 限制在1M左右内存，充足的磁盘空间<br /><br />假设整数占32位，1M内存可以存储大概250000个整数，第一个方法就是采用基于磁盘的合并排序算法，第二个办法就是将0-9999999切割成40个区间，分40次扫描（10000000/250000)，每次读入250000个在一个区间的整数，并在内存中使用快速排序。
【位图（Bitmap）】数据结构：高效存储与处理大量数据
StuLearn-LJC的博客
03-01 1723
位图是一种数据结构，是用每一位来存放某种状态，适用于海量数据，整数，数据无重复的场景。通常是用来判断某个数据存不存在的。数据是否在给定的整形数据中，结果是在或者不在，刚好是两种状态，那么可以使用一个二进制比特位来代表数据是否存在的信息，如果二进制比特位为1，代表存在，为0代表不存在。
位图排序（Bitmap）
lancelot0902的博客
04-10 447
<<编程珠玑>>第一章中需要编写一个排序程序，排序的对象是电话号码，每条电话记录都是7为整数，一共一千万条，号码都不重复。 该程序只有1MB的内存可用，而且排序时间最多几分钟，十秒钟为理想情况。 在32位操作系统下，如果用32位整数在表示每个号码，那么1MB可以存储250000个号码，可以进行40趟来完成。 这是一种方法，只是进行40趟所需时间较长，而问题的核心是是否能找到...
深入探索位图技术：原理及应用
最新发布
无敌岩雀的博客
03-31 1143
虽然位图在图形处理中也常被提及，但在此上下文中，我们需要明确区分两种不同类型的“位图”：一种是数据结构中的位图，如上所述，它主要用于数据的高效存储和检索；当我们要标记第n个数据元素是否存在时，我们只需要找到对应的整数（通过n除以32得到整数索引），然后在该整数中找到对应的二进制位（通过n对32取余得到位索引），并将其设置为0或1。在上面的例子中，如果使用一个整型数组来存储集合中的元素，每个整数需要4个字节（假设是32位系统），那么存储1亿个整数需要大约400MB的空间。如果是1，表示该整数存在于集合中；
位图法排序
lanzh_
11-29 2887
位图法：bitmap，就是用每一位来存放某种状态，适用于大规模数据，但数据状态又不是很多的情况。通常是用来判断某个数据存不存在的。 对unsigned没有重复的数字进行排序，假设我们要对0-7内的5个元素(4,7,2,5,3)排序。那么我们就可以采用Bit-map的方法来达到排序的目的。要表示8个数，我们就只需要8个Bit（1Bytes），首先我们开辟1Byte的空间，将这些空间的所有Bit
位图基本操作与实现
ENSHADOWER的博客
09-17 4874
位图  一、位图的原理：在位图中采用比特位表示对应的元素存在或者不存在0：不存在 1：存在，例如一个int整数有32个比特位可以                                         表示0-31个整数。                    图解：           二、位图的优点：使用位图最大的优点就是节省空间。(因为位图的处理方式是信息压缩)     ...
位图的详细介绍及模拟实现
weixin_45897952的博客
06-27 975
本文将面向一个初学者来先介绍位图的概念，以及STL中位图的使用，最后模拟实现位图
《编程珠玑》之位图技术
sf_jiang的博客
09-15 581
编程珠玑，相当不错的一本书。其中很多金句需要在工作的过程当中，铭记于心： chapter 1，书中的金典语句： @1，明确问题（问对正确的问题），这场战役就成功了90%. @2，几分钟的仔细研究可以大幅削减代码的长度、程序员的时间和程序系统运行的时间。 @3，设计者确定其设计已经达到了完美的标准，不是不能再增加任何东西，而是不能再减少任何东西。 @4，程序员的主要问题，与其说是技术问题，...
Java服务端面试复习资料：位图排序解十亿QQ号问题
这份资料对于准备Java服务端岗位面试的初学者来说，是一个很好的复习资源，尤其是对于理解如何在实际问题中应用位图排序这一概念，有助于提升解决大数据问题的能力。同时，作者提供的内推机会也为求职者提供了更多的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值