这将使用rbind：

c(rbind(a, b))

例如：

a = c(1,2,3)
b = c(11,12,13)

c(rbind(a,b))

#[1]  1 11  2 12  3 13

说明

这是因为R以列为主的顺序存储数组。
当您将两个向量rbind()时，您会得到：

rbind_result <- rbind(a, b)
rbind_result
#   [,1] [,2] [,3]
# a    1    2    3
# b   11   12   13

然后c()将rbind_result强制转换为按列展平的向量：

merged <- c(rbind_result)
merged
# [1] 1 11 2 12 3 13

@jalapic给出的rbind()答案非常好，这里有一个替代方法，创建一个新向量，然后给它分配交替值。

a <- c(1,2,3)
b <- c(11,12,13)

x <- vector(class(a), length(c(a, b)))
x[c(TRUE, FALSE)] <- a
x[c(FALSE, TRUE)] <- b
x
# [1]  1 11  2 12  3 13

还有一个显示append

c(sapply(seq_along(a), function(i) append(a[i], b[i], i)))
# [1]  1 11  2 12  3 13

只是想添加一个更简单的解决方案，适用于矢量长度不相等，并且您希望将额外的数据附加到末尾的情况。

> a <- 1:3
> b <- 11:17
> c(a, b)[order(c(seq_along(a)*2 - 1, seq_along(b)*2))]
 [1]  1 11  2 12  3 13 14 15 16 17

说明：

• c(a, b)创建a和b中的值的向量。
• seq_along(a)*2 - 1创建第一个length(a)奇数的向量。
• seq_along(b)*2创建第一个length(b)偶数的向量。
• order(...)将返回两个seq_along向量中数字的索引，使得x[order(x)]是有序列表。由于第一个seq_along包含偶数，第二个seq_along具有赔率，因此order将从第一个seq_along中获取第一个元素，然后是第二个seq_along的第一个元素，然后是来自第一个seq_along的第二个元素，等等，散布两个向量索引并在尾部留下额外的数据。
• 通过使用order向量索引c(a, b)，我们将散布a和b。

注意，由于当输入为NULL时，seq_along返回numeric(0)，因此即使其中一个向量的长度为0，该解决方案也有效。

我也要解决一个类似的问题，但是我的向量长度不相等，而且，我不想循环使用较短的向量，而只是把较长向量的尾部附加上去。
@RichardScriven的解决方案对我不起作用（尽管我可能做错了什么，没有努力排除故障）。
下面是我的解决方案：

#' Riffle-merges two vectors, possibly of different lengths
#'
#' Takes two vectors and interleaves the elements.  If one vector is longer than
#' the other, it appends on the tail of the longer vector to the output vector.
#' @param a First vector
#' @param b Second vector
#' @return Interleaved vector as described above.
#' @author Matt Pettis
riffle <- function(a, b) {
  len_a <- length(a)
  len_b <- length(b)
  len_comm <- pmin(len_a, len_b)
  len_tail <- abs(len_a - len_b)

  if (len_a < 1) stop("First vector has length less than 1")
  if (len_b < 1) stop("Second vector has length less than 1")

  riffle_common <- c(rbind(a[1:len_comm], b[1:len_comm]))

  if (len_tail == 0) return(riffle_common)

  if (len_a > len_b) {
    return(c(riffle_common, a[(len_comm + 1):len_a]))
  } else {
    return(c(riffle_common, b[(len_comm + 1):len_b]))
  }
}

# Try it out
riffle(1:7, 11:13)
  [1]  1 11  2 12  3 13  4  5  6  7

riffle(1:3, 11:17)
   [1]  1 11  2 12  3 13 14 15 16 17

马特·特赫

@MBo对我在https://stackoverflow.com/a/58773002/2556061上的问题的回答暗示了一种不等长均匀交错矢量的解决方案。我在这里报告它以供参考。

interleave <- function(x, y)
{
  m <- length(x)
  n <- length(y)
  xi <- yi <- 1
  len <- m + n
  err <- len %/% 2
  res <- vector()
  for (i in 1:len)
  {
    err <- err - m
    if (err < 0)
    {

      res[i] <- x[xi]
      xi <- xi + 1
      err <- err + len
    } else
    {
       res[i] <- y[yi]
      yi <- yi + 1
     }
  }
  res
}

给予

interleave(1:10, 100:120)

c(100, 1, 101, 102, 2, 103, 104, 3, 105, 106, 4, 107, 108, 5, 109, 110, 111, 6, 112, 113, 7, 114, 115, 8, 116, 117, 9, 118, 119, 10, 120)