模仿st_table写的StTable类

最新推荐文章于 2023-08-08 14:19:00 发布
最新推荐文章于 2023-08-08 14:19:00 发布
阅读量246 收藏
点赞数
分类专栏： java 文章标签： Ruby 数据结构 单元测试
    读ruby hacking guide，其中专门辟了一个章节介绍了st.c中的st_table，这个数据结构也就是类似java中的HashMap，基本原理是利用数组存储，数组的每一个元素是一个单向链表，链表中再存储具体的元素，如下图所示的结构

   ruby中利用这个结构来存储对象变量、类方法、常量、全局变量等信息，在c ruby中，方法、变量都是用一个整型作为键值来存储在st_table中，因此这个数据结构对于以整性为键的map类型来说速度非常不错（我没有测试内存的占用情况）。
源码如下：
java 代码
 
  1. //接口，用于定义hash函数  
  2. //HashFunction.java  
  3. public interface HashFunction<T> {  
  4.    public int hash(T key);  
  5. }  

链表元素类：
java 代码
 
  1. public class StTableEntry<T, V> {  
  2.     protected int hash; //hash值  
  3.   
  4.     protected T key;   //键  
  5.   
  6.     protected V value; //存储值  
  7.   
  8.     protected StTableEntry<T, V> next; //下一节点  
  9.   
  10.     public StTableEntry() {  
  11.   
  12.     }  
  13.   
  14.     public StTableEntry(int hash, T key, V value, StTableEntry<T, V> next) {  
  15.         super();  
  16.         this.hash = hash;  
  17.         this.key = key;  
  18.         this.value = value;  
  19.         this.next = next;  
  20.     }  
  21.   
  22.     public int getHash() {  
  23.         return hash;  
  24.     }  
  25.   
  26.     public void setHash(int hash) {  
  27.         this.hash = hash;  
  28.     }  
  29.   
  30.     public T getKey() {  
  31.         return key;  
  32.     }  
  33.   
  34.     public void setKey(T key) {  
  35.         this.key = key;  
  36.     }  
  37.   
  38.     public StTableEntry<T, V> getNext() {  
  39.         return next;  
  40.     }  
  41.   
  42.     public void setNext(StTableEntry<T, V> next) {  
  43.         this.next = next;  
  44.     }  
  45.   
  46.     public V getValue() {  
  47.         return value;  
  48.     }  
  49.   
  50.     public void setValue(V value) {  
  51.         this.value = value;  
  52.     }  
  53.   
  54. }  

完整的StTable实现,没有实现remove，有兴趣的话自己实现一下：
java 代码
 
  1. public final class StTable<T, V> {  
  2.     private HashFunction<T> hashFunction;  
  3.   
  4.     private int num_bins;  
  5.   
  6.     int num_entries;  
  7.   
  8.     StTableEntry<T, V>[] bins;  
  9.   
  10.     public static int DEFAULT_SIZE = 10;  
  11.   
  12.     private static int DEFAULT_MAX_DENSITY = 5;  
  13.   
  14.     private static int DEFAULT_MIN_SIZE = 8;  
  15.   
  16.     private static long primes[] = { 8 + 3, 16 + 3, 32 + 5, 64 + 3, 128 + 3,  
  17.             256 + 27, 512 + 9, 1024 + 9, 2048 + 5, 4096 + 3, 8192 + 27,  
  18.             16384 + 43, 32768 + 3, 65536 + 45, 131072 + 29, 262144 + 3,  
  19.             524288 + 21, 1048576 + 7, 2097152 + 17, 4194304 + 15, 8388608 + 9,  
  20.             16777216 + 43, 33554432 + 35, 67108864 + 15, 134217728 + 29,  
  21.             268435456 + 3, 536870912 + 11, 1073741824 + 85, 0 };  
  22.   
  23.     public StTable(HashFunction<T> hashFunction) {  
  24.         this.hashFunction = hashFunction;  
  25.         this.num_bins = DEFAULT_SIZE;  
  26.         this.num_entries = 0;  
  27.         this.bins = (StTableEntry<T, V>[]) new StTableEntry[this.num_bins];  
  28.     }  
  29.   
  30.     public StTable(HashFunction<T> hashFunction, int size) {  
  31.         this.hashFunction = hashFunction;  
  32.         if (size == 0)  
  33.             throw new IllegalArgumentException(  
  34.                     "The size could not less than zero:" + size);  
  35.         this.num_bins = size;  
  36.         this.num_entries = 0;  
  37.         this.bins = (StTableEntry<T, V>[]) new StTableEntry[this.num_bins];  
  38.     }  
  39.   
  40.     private long newSize(int size) {  
  41.   
  42.         for (int i = 0, newsize = DEFAULT_MIN_SIZE; i < primes.length; i++, newsize <<= 1) {  
  43.             if (newsize > size)  
  44.                 return primes[i];  
  45.         }  
  46.         /* Ran out of polynomials */  
  47.         return -1; /* should raise exception */  
  48.     }  
  49.   
  50.     public V get(T key) {  
  51.         int hash_val = doHash(key);  
  52.         StTableEntry<T, V> entry = findEntry(hash_val, key);  
  53.         if (entry == null)  
  54.             return null;  
  55.         else  
  56.             return entry.getValue();  
  57.     }  
  58.   
  59.     public V put(T key, V value) {  
  60.         int hash_val = doHash(key);  
  61.         StTableEntry<T, V> entry = findEntry(hash_val, key);  
  62.         if (entry == null) {  
  63.             // 未有键值，直接添加  
  64.             addDirect(key, value);  
  65.             return value;  
  66.         } else {  
  67.             V v = entry.value;  
  68.             entry.value = value;  
  69.             return v;  
  70.         }  
  71.     }  
  72.   
  73.     // hash函数，调用hashFunction的hash方法  
  74.     private int doHash(T key) {  
  75.         if (hashFunction.hash(key) < 0)  
  76.             throw new IllegalArgumentException(  
  77.                     "hash value could not less than zero:"  
  78.                             + hashFunction.hash(key));  
  79.         return hashFunction.hash(key);  
  80.     }  
  81.   
  82.     // 过于拥挤，重新分布  
  83.     public void reHash() {  
  84.         int new_size = (int) newSize(this.num_bins);  
  85.         StTableEntry<T, V>[] new_bins = (StTableEntry<T, V>[]) new StTableEntry[new_size];  
  86.         for (int i = 0; i < this.num_bins; i++) {  
  87.             StTableEntry<T, V> entry = this.bins[i];  
  88.             while (entry != null) {  
  89.                 StTableEntry<T, V> next = entry.next;  
  90.                 int hash_val = entry.hash % new_size;  
  91.                 entry.next = new_bins[hash_val];  
  92.                 new_bins[hash_val] = entry;  
  93.                 entry = next;  
  94.             }  
  95.         }  
  96.         this.bins = null; //gc  
  97.         this.num_bins = new_size;  
  98.         this.bins = new_bins;  
  99.   
  100.     }  
  101.   
  102.     private void addDirect(T key, V value) {  
  103.         int hash_val = doHash(key);  
  104.         int bin_pos = hash_val % this.num_bins;  
  105.         if ((this.num_entries / this.num_bins) > DEFAULT_MAX_DENSITY) {  
  106.             reHash();  
  107.             bin_pos = hash_val % this.num_bins;  
  108.         }  
  109.         StTableEntry<T, V> entry = new StTableEntry<T, V>();  
  110.         entry.setHash(hash_val);  
  111.         entry.setKey(key);  
  112.         entry.setValue(value);  
  113.         entry.setNext(this.bins[bin_pos]);  
  114.         this.bins[bin_pos] = entry;  
  115.         this.num_entries++;  
  116.     }  
  117.   
  118.     private StTableEntry<T, V> findEntry(int hash_val, T key) {  
  119.         int bin_pos = hash_val % this.num_bins;  
  120.         StTableEntry<T, V> entry = this.bins[bin_pos];  
  121.         if (entryNotEqual(entry, key, hash_val)) {  
  122.             entry = entry.next;  
  123.             while (entryNotEqual(entry, key, hash_val)) {  
  124.                 entry = entry.next;  
  125.             }  
  126.         }  
  127.         return entry;  
  128.     }  
  129.   
  130.     // 判断元素是否相同  
  131.     private boolean entryNotEqual(StTableEntry<T, V> entry, T key, int hash_val) {  
  132.         return entry != null  
  133.                 && (entry.getHash() != hash_val || (!key.equals(entry.getKey())));  
  134.     }  
  135.   
  136. }  

   单元测试类就不列了，给一个与HashMap的简单性能对比，以整型为键，显然StTable快多了，对于字符串型，关键是HashFunction的定义，我直接调用String的hashCode方法，不知道有没有其他更好的方法让元素分布的更均匀些：
java 代码
 
  1. import java.util.HashMap;  
  2. import java.util.Map;  
  3.   
  4. public class Benchmark {  
  5.     public static void main(String args[]) {  
  6.         long map_cost = testStringMap();  
  7.         long table_cost = testStringTable();  
  8.         if (map_cost <= table_cost)  
  9.             System.out.println("map is faster than table ");  
  10.         else  
  11.             System.out.println("table is faster than map ");  
  12.   
  13.         map_cost = testIntegerMap();  
  14.         table_cost = testIntegerTable();  
  15.         if (map_cost <= table_cost)  
  16.             System.out.println("map is faster than table ");  
  17.         else  
  18.             System.out.println("table is faster than map ");  
  19.     }  
  20.   
  21.     public static long testIntegerMap() {  
  22.         Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
  23.         long start = System.nanoTime();  
  24.         for (int i = 0; i < 10000; i++)  
  25.             map.put(i, i);  
  26.         long result = 0;  
  27.         for (int i = 0; i < 10000; i++)  
  28.             result += map.get(i);  
  29.         long end = System.nanoTime();  
  30.         System.out.println("result:" + result);  
  31.         System.out.println("map:" + (end - start));  
  32.         return (end - start);  
  33.     }  
  34.   
  35.     public static long testIntegerTable() {  
  36.         HashFunction<Integer> intHash = new HashFunction<Integer>() {  
  37.             public int hash(Integer key) {  
  38.                 return key;  
  39.             }  
  40.         };  
  41.         StTable<Integer, Integer> table = new StTable<Integer, Integer>(intHash);  
  42.         long start = System.nanoTime();  
  43.         for (int i = 0; i < 10000; i++)  
  44.             table.put(i, i);  
  45.         long result = 0;  
  46.         for (int i = 0; i < 10000; i++)  
  47.             result += table.get(i);  
  48.         long end = System.nanoTime();  
  49.         System.out.println("result:" + result);  
  50.         System.out.println("table:" + (end - start));  
  51.         return (end - start);  
  52.     }  
  53.   
  54.     public static long testStringMap() {  
  55.         Map<String, String> map = new HashMap<String, String>();  
  56.         long start = System.nanoTime();  
  57.         for (int i = 0; i < 10000; i++)  
  58.             map.put(String.valueOf(i), String.valueOf(i));  
  59.         long result = 0;  
  60.         for (int i = 0; i < 10000; i++)  
  61.             result += Integer.parseInt(map.get(String.valueOf(i)));  
  62.         long end = System.nanoTime();  
  63.         System.out.println("result:" + result);  
  64.         System.out.println("map:" + (end - start));  
  65.         return (end - start);  
  66.     }  
  67.   
  68.     public static long testStringTable() {  
  69.         HashFunction<String> intHash = new HashFunction<String>() {  
  70.             int i = 0;  
  71.             public int hash(String key) {  
  72.                 int hashCode = key.hashCode();  
  73.                 return hashCode < 0 ? -hashCode : hashCode;  
  74.             }  
  75.         };  
  76.         StTable<String, String> table = new StTable<String, String>(intHash);  
  77.         long start = System.nanoTime();  
  78.         for (int i = 0; i < 10000; i++)  
  79.             table.put(String.valueOf(i), String.valueOf(i));  
  80.         long result = 0;  
  81.         for (int i = 0; i < 10000; i++)  
  82.             result += Integer.parseInt(table.get(String.valueOf(i)));  
  83.         long end = System.nanoTime();  
  84.         System.out.println("result:" + result);  
  85.         System.out.println("table:" + (end - start));  
  86.         return (end - start);  
  87.     }  
  88.   
  89. }  

结果为：
result:49995000
map:55501468
result:49995000
table:60999652
map is faster than table

 
result:49995000
map:44634444
result:49995000
table:26209477
table is faster than map



dennis_zane
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STtable
刘皓东的博客
10-30 149
【代码】STtable。
ST table
ding_ning123的博客
11-05 225
建表 设dp(i,k)dp(i,k)dp(i,k)为区间 [i,i+2k][i,i+2^k][i,i+2k]内min⁡,max⁡\min,\maxmin,max dp(i,k)=max⁡,min⁡(dp(i,k−1),dp(i+2k−1,k−1))dp(i,k)=\max,\min(dp(i,k-1),dp(i+2^{k-1},k-1))dp(i,k)=max,min(dp(i,k−1),dp(i+2k−1,k−1)) 因此建表是O(NlogN)O(NlogN)O(NlogN)的 查询 把区间[l,r
ST表（Sparse Table）
LzyRapX
08-13 960
ST表（Sparse Table）： 它是一种动态规划的方法，实际上也是RMQ问题。以最小值为例。a为所寻找的数组，用一个二维数组f(i,j)记录区间[i,i+2^j-1]区间中的最小值。其中f[i,0] = a[i];所以，对于任意的一组(i,j)，f(i,j) = min{ f (i,j-1),f (i+2^(j-1),j-1) }来使用动态规划计算出来。这个算的高明之处不是在于这个动态规划
ST表 (Sparse Table)
CHAOS_ORDER的博客
10-04 799
ST表(Sparse Table)是一种用于区间查询最值的数据结构，常用于解决RMQ问题 例如 当然这个问题也可以使用线段树或树状数组实现，不过ST表算法的代码量很少，且查询效率为Θ(1) ★★★ 基本思想：动态规划和倍增 st_max[i][j]表示为在第i个元素处，向后包括i在内的的共2j个元素的最大值，显然我们可以将该区间平均分为两个区间，[i,i+2j-1-1]和[i+2j-1,i+2j...
linux设备驱动：xx_driver结构体中成员driver.of_match_table、id_table和设备树的关系
zerolity的博客
09-25 8951
** 内容属个人理解 ** 设备树中 compatible = “myvendor,wm5102” 匹配优先级 of_match_table>id_table of_match_table表中的厂商和设备树中条目compatible(包含供应商字符串) 的厂商“myvendor”不匹配，则会用id_table去匹配设备树条目compatible (不包含供应商字符串)。 参考： lin...
mysql8 json_table_新特性解读 | MySQL 8.0 json到表的转换
weixin_31858171的博客
01-20 5695
原创：杨涛涛我们知道，JSON是一种轻量级的数据交互的格式，大部分NO SQL数据库的存储都用JSON。MySQL从5.7开始支持JSON格式的数据存储，并且新增了很多JSON相关函数。MySQL 8.0 又带来了一个新的把JSON转换为TABLE的函数JSON_TABLE，实现了JSON到表的转换。举例一我们看下简单的例子：简单定义一个两级JSON 对象mysql> set @ytt='...
python制作数据透视表pivot_table方法详解
Norsaa的博客
06-18 7096
数据透视表（Pivot Table）是一种交互式的表，可以进行某些计算，如求和与计数等。所进行的计算与数据跟数据透视表中的排列有关。 之所以称为数据透视表，是因为可以动态地改变它们的版面布置，以便按照不同方式分析数据，也可以重新安排行号、列标和页字段。每一次改变版面布置时，数据透视表会立即按照新的布置重新计算数据。另外，如果原始数据发生更改，则可以更新数据透视表。 函数详解 df.pivot_table(values=None, index=[列名]，columns=[列名], aggfunc='me
postgresql regexp_split_to_table函数
unknow_oracle的博客
02-22 6874
最近公司系统在做改造,数据库产品也换了,由Oracle数据库换成postgresql 数据库。 在开发的过程中，同事遇到一问题，就是有张表有个字段的数据存储格式是 A|B|C 这种形式, 现在要专业这种形式 钻石|铂金|黄金。 A对应的是钻石 B对应的是铂金 C对应的是黄金 刚开始以为要自定义一个函数,实现这样一个转换功能，偶然在qq群看到 pg有 regexp_split_to_table 函数。于是看是做实验测试: --建表 drop table if exists te...
pandas 之 pivot_table 与 pivot 的区别
jieru_liu的博客
03-28 6481
1、pivot：通过指定的索引和列对数据进行重塑，无法聚合 语法： DataFrame.pivot(self, index=None, columns=None, values=None) 构建一个 DataFrame 数据 df = pd.DataFrame({'foo': ['one', 'one', 'one', 'two', 'two', ...
ST算法(Sparse-Table)
L.
06-06 766
当求RMQ问题时可以用ST算法，预处理时间为O(nlogn)，但查询时间为O(1). 另d[[i][j]表示从i开始长度为2^j的一段元素的最小值,那么d[i][j] = min(d[i][j-1], d[i+(1<<(j-1)][j-1]).void Init(){ for(int i = 0; i < n; i++) d[i][0] = a[i]; for(int j
ST表讲解与例题
SCUEC__zhazhahui的博客
01-08 529
ST（Sparse Table） 算法 简介 适用范围 ST 表是用于解决可重复贡献问题的的区间询问的数据结构，基本思想是倍增和DP。 所谓可重复贡献问题，即运算具有自反性的问题，例如求最大/小值，最大公约数，最小公倍数x=max(x,x)=min(x,x)=gcd(x,x)=lcm（x,x）x=max(x,x)=min(x,x)=gcd(x,x)=lcm（x,x）x=max(x,x)=min(x,x)=gcd(x,x)=lcm（x,x）（显然都是**RMQ（Range Minimum/Maximum Q
【数据结构：线性表】倍增表（ST表）
gzkeylucky的博客
09-06 5187
学习ST倍增表RMQ算法
RMQ算法（一）：ST表（Sparse Table）
不忘初心
08-22 545
#include #include #include #include #include #include using namespace std; int n; int a[100005], dp[10005][20], upper[100005];//以最小值为例；upp
ST（Sparse Table）算法基本思路及实现
Wyt_code的博客
11-07 490
ST算法是在倍增的思想上建立的 什么是倍增？小白可以看这里：https://blog.csdn.net/jarjingx/article/details/8180560 来看一下ST算法是怎么实现的(以最大值为例）： 首先是预处理，用一个DP解决。设a[i]是要求区间最值的数列，f[i,j]表示从第i个数起连续2^j个数中的最大值。 例如数列3 2 4 5 6 8 1 2 9 7 f[...
vue element-ui实现table表格可编辑修改
热门推荐
weixin_43613849的博客
12-14 1万+
代码如下：点击编辑按钮可编辑当前行，点击保存可以保存当前行，可以结合业务需要，进一步修改 <template> <div class="st-table"> <el-table :data="tableData" border style="width: 100%"> <el-table-column prop="date" label="日期" width="180"> <template slot..
基于streamlit的表格展示-完美解决方案
euler1983的专栏
05-15 1万+
问题 用streamlit开发web app非常实用。但是streamlit的表格展示非常不友好，只有两个简单的接口函数：st.table(df)和st.dataframe(df)。 对于字段稍微比较多的dataframe显示效果相当不友好。 st.table(df)会展开所有字段，st.dataframe(df)会压缩到一起，字段名称看不清楚。 主要局限为： 1. 不能控制每个列的宽度。虽然接口里有width和height两个参数，但是亲测不太管用。 2. 行数多的时候，会一直在页面上往下排列
【Streamlit 库介绍与学习笔记】
weixin_45775136的博客
04-19 3270
streamlit库介绍
Streamlit 讲解专栏（七）：解析数据元素
最新发布
蓝色是天的博客
08-08 3090
在本篇博文中，我们介绍了使用 Streamlit 的 st.metric 方法展示指标数据的方法。我们首先展示了如何使用 st.metric 单独展示一个指标数据，并解释了 label、value 和 delta 参数的作用。接着，我们展示了如何结合 st.columns 方法创建多个指标数据的布局，并提供了一个示例。然后，我们介绍了如何通过设置 delta_color 参数控制增量指示器的颜色和显示。最后，我们展示了使用 st.json 方法展示 JSON 数据的示例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值