C++ 为什么'*'；比散列查找更快，c++；

我刚学会数据结构，谁能告诉我为什么散列速度慢，谢谢

此问题来自LeetCode：

bool-isHappy（int-n）{
无序地图M；
M[0]=0，M[1]=1，M[2]=4，M[3]=9，M[4]=16，M[5]=25\
M[6]=36，M[7]=49，M[8]=64，M[9]=81；
int temp，mark=0；//temp为下一个n，mark为检测圆
while（n）{
温度=0；
如果（n==1）返回true；
如果（n<10）{
如果（标记==n）
返回false；
标记=n；
}
//下一步计算
while（n）{
温度+=（n%10）*（n%10）；//4毫秒
//温度+=M[n%10]；//8毫秒
n/=10；
}
n=温度；
}
}

为什么不呢？哈希是有效的，因为它的平均获取时间是恒定的。就这样

不能保证它比

*

快。请注意，您的密钥通常是而不是直接用作哈希表的密钥（这称为“直接地址表”，有其自身的缺点）。通常，从您的密钥到散列密钥有一个计算：

hash\u key=hash（您的\u密钥）

。因此，时间完全取决于如何实现

hash

。一旦计算了散列键，就只需要对表进行索引

事实上，最常见的哈希实现涉及模数（%）运算，它很可能比“*”慢。想想看：

C=A%B

相当于

C=A–B*（A/B）

---

您可能会问，两个

%

（如

*

案例）和一个

%

（如map案例）怎么样？我的猜测是

n%10

在第一种情况下被优化为只计算一次。

为什么不呢？哈希是有效的，因为它的平均获取时间是恒定的。就这样

不能保证它比

*

快。请注意，您的密钥通常是而不是直接用作哈希表的密钥（这称为“直接地址表”，有其自身的缺点）。通常，从您的密钥到散列密钥有一个计算：

hash\u key=hash（您的\u密钥）

。因此，时间完全取决于如何实现

hash

。一旦计算了散列键，就只需要对表进行索引

事实上，最常见的哈希实现涉及模数（%）运算，它很可能比“*”慢。想想看：

C=A%B

相当于

C=A–B*（A/B）

---

您可能会问，两个

%

（如

*

案例）和一个

%

（如map案例）怎么样？我猜

n%10

在第一种情况下优化为只计算一次。

这并不能回答您的问题，但在这种情况下使用

std:：unordered_map

是对内存和CPU周期的极大浪费。在这里，一个简单的数组也可以很好地工作，而且几乎可以肯定会更快

bool isHappy(int n) {
    static const int M[] = { 0,  1,  4,  9,  16,  25, 36,  49,  64,  81 };
    int temp, mark = 0;   //temp is next n, mark is for detect circle 
    while(n){
        temp = 0;
        if(n == 1) return true;
        if(n < 10){
            if(mark == n)
               return false;
            mark = n;
        }
        //calc next n
        while(n){
            temp += M[n%10];
            n /= 10;
        }
        n = temp;
    }
}

bool-isHappy（int-n）{
静态常量int M[]={0,1,4,9,16,25,36,49,64,81}；
int temp，mark=0；//temp为下一个n，mark为检测圆
while（n）{
温度=0；
如果（n==1）返回true；
如果（n<10）{
如果（标记==n）
返回false；
标记=n；
}
//下一步计算
while（n）{
温度+=M[n%10]；
n/=10；
}
n=温度；
}
}

这并不能回答您的问题，但在这种情况下使用

std:：unordered_map

是对内存和CPU周期的极大浪费。在这里，一个简单的数组也可以很好地工作，而且几乎可以肯定会更快

bool isHappy(int n) {
    static const int M[] = { 0,  1,  4,  9,  16,  25, 36,  49,  64,  81 };
    int temp, mark = 0;   //temp is next n, mark is for detect circle 
    while(n){
        temp = 0;
        if(n == 1) return true;
        if(n < 10){
            if(mark == n)
               return false;
            mark = n;
        }
        //calc next n
        while(n){
            temp += M[n%10];
            n /= 10;
        }
        n = temp;
    }
}

bool-isHappy（int-n）{
静态常量int M[]={0,1,4,9,16,25,36,49,64,81}；
int temp，mark=0；//temp为下一个n，mark为检测圆
while（n）{
温度=0；
如果（n==1）返回true；
如果（n<10）{
如果（标记==n）
返回false；
标记=n；
}
//下一步计算
while（n）{
温度+=M[n%10]；
n/=10；
}
n=温度；
}
}

您是如何测量该时间的？您用于

n

的值是多少？是否在启用优化的情况下编译？哈希表需要计算哈希值，然后取消对该表的引用。这比简单地计算值要慢。时间不是由IDE给出的，而是由LeetCode给出的，可能不准确，但使用哈希更慢，谢谢你的回答为什么不使用查找数组呢？它比散列快得多您是如何测量时间的？您用于

n

的值是多少？您是在启用优化的情况下编译的吗？散列表需要计算散列，然后取消对该表的引用。这比简单地计算值要慢。时间不是由IDE给出的，而是由LeetCode给出的，可能不准确，但使用哈希更慢，谢谢你的回答为什么不使用查找数组呢？它比散列快得多