[Algorithm] Circular buffer

You run an e-commerce website and want to record the last N order ids in a log. Implement a data structure to accomplish this, with the following API:

• record(order_id): adds the order_id to the log
• get_last(i): gets the ith last element from the log. i is guaranteed to be smaller than or equal to N.

You should be as efficient with time and space as possible.

It seems like an array would be the perfect fit for this problem. We can just initialize the array to have size N, and index it in constant time. Then, when we record any orders, we can pop off the first order and append it to the end. Getting the ith last order would then just be indexing the array at length - i.

This is one issue with this solution, however: when we have to pop off an element when the array is full, we have to move every other element down by 1. That means record takes O(N) time. How can we improve this?

What we can do to avoid having to moving every element down by 1 is to keep a current index and move it up each time we record something. For get_last, we can simply take current - i to get the appropriate element. Now, both record and get_last should take constant time.

This is actually called Circular buffer:

function CB_log (total) {
  let current = 0;
  let n = total;
  let logs = [];
  return {
    record (id) {
      logs[current] = id;
      current = (current + 1) % n;
    },
    get_last(i) {
      if (i > n || !i) {
          return null;
      }
      let idx = current - i;
      if (idx >= 0) {
        return logs[idx]
      } else {
        return logs[n - Math.abs(idx)]
      }
    }
  }
}



const log = new CB_log(5);

log.record(41);
log.record(17);
log.record(12);
log.record(78);
log.record(100);//3
log.record(1);//2
log.record(0);//1

console.log(
  log.get_last(4) // 78
)