假设你的观测值是来自实数的类，当你的观测值是2,2,3,3时，你期望模态为2.5，然后你可以用mode = l1 + I * (f1-f0) / (2f1 -f0 - f2)来估计模态，其中l1..最频繁类的下限，f1..最频繁类的频率，f0..在最频繁类之前的类的频率，f2..在最频繁类之后的类的频率，i..分类间隔，如在1,2,3中给出:

#Small Example
x <- c(2,2,3,3) #Observations
i <- 1          #Class interval

z <- hist(x, breaks = seq(min(x)-1.5*i, max(x)+1.5*i, i), plot=F) #Calculate frequency of classes
mf <- which.max(z$counts)   #index of most frequent class
zc <- z$counts
z$breaks[mf] + i * (zc[mf] - zc[mf-1]) / (2*zc[mf] - zc[mf-1] - zc[mf+1])  #gives you the mode of 2.5


#Larger Example
set.seed(0)
i <- 5          #Class interval
x <- round(rnorm(100,mean=100,sd=10)/i)*i #Observations

z <- hist(x, breaks = seq(min(x)-1.5*i, max(x)+1.5*i, i), plot=F)
mf <- which.max(z$counts)
zc <- z$counts
z$breaks[mf] + i * (zc[mf] - zc[mf-1]) / (2*zc[mf] - zc[mf-1] - zc[mf+1])  #gives you the mode of 99.5

如果你想要最频繁的级别，并且你有多个最频繁的级别，你可以得到所有的级别，例如:

x <- c(2,2,3,5,5)
names(which(max(table(x))==table(x)))
#"2" "5"

还有一个解决方案，适用于数字和字符/因子数据:

Mode <- function(x) {
  ux <- unique(x)
  ux[which.max(tabulate(match(x, ux)))]
}

在我的小机器上，它可以在大约半秒内生成并找到一个10m整数向量的模式。

如果您的数据集可能有多种模式，上述解决方案采用与which相同的方法。Max，并返回模式集中第一个出现的值。要返回所有模式，使用这个变体(来自评论中的@digEmAll):

Modes <- function(x) {
  ux <- unique(x)
  tab <- tabulate(match(x, ux))
  ux[tab == max(tab)]
}

抱歉，我可能把它理解得太简单了，但这不是可以工作的吗?(我的机器上的1E6值在1.3秒内):

t0 <- Sys.time()
summary(as.factor(round(rnorm(1e6), 2)))[1]
Sys.time()-t0

你只需要用你的向量替换“round(rnorm(1e6)，2)”。

如果你问R中的内置函数，也许你可以在软件包pracma中找到它。在这个包中，有一个叫做Mode的函数。

基于@Chris的函数来计算模态或相关指标，但是使用Ken Williams的方法来计算频率。这个方法修复了根本没有模式(所有元素频率相等)的情况，并提供了一些更易读的方法名。

Mode <- function(x, method = "one", na.rm = FALSE) {
  x <- unlist(x)
  if (na.rm) {
    x <- x[!is.na(x)]
  }

  # Get unique values
  ux <- unique(x)
  n <- length(ux)

  # Get frequencies of all unique values
  frequencies <- tabulate(match(x, ux))
  modes <- frequencies == max(frequencies)

  # Determine number of modes
  nmodes <- sum(modes)
  nmodes <- ifelse(nmodes==n, 0L, nmodes)

  if (method %in% c("one", "mode", "") | is.na(method)) {
    # Return NA if not exactly one mode, else return the mode
    if (nmodes != 1) {
      return(NA)
    } else {
      return(ux[which(modes)])
    }
  } else if (method %in% c("n", "nmodes")) {
    # Return the number of modes
    return(nmodes)
  } else if (method %in% c("all", "modes")) {
    # Return NA if no modes exist, else return all modes
    if (nmodes > 0) {
      return(ux[which(modes)])
    } else {
      return(NA)
    }
  }
  warning("Warning: method not recognised.  Valid methods are 'one'/'mode' [default], 'n'/'nmodes' and 'all'/'modes'")
}

由于它使用Ken的方法来计算频率，性能也得到了优化，使用AkselA的帖子，我对之前的一些答案进行了基准测试，以显示我的函数在性能上是如何接近Ken的，各种输出选项的条件只导致很小的开销:

CRAN上现在可用的折叠包中的通用函数fmode实现了基于索引哈希的基于c++的模式。它比上述任何一种方法都要快得多。它提供了向量、矩阵、data.frames和dplyr分组tibbles的方法。语法:

libary(collapse)
fmode(x, g = NULL, w = NULL, ...)

其中x可以是上述对象之一，g提供一个可选的分组向量或分组向量列表(用于分组模式计算，也在c++中执行)，w(可选)提供一个数值权重向量。在分组tibble方法中，没有g参数，您可以执行data %>% group_by(idvar) %>% fmode。