Question

我需要一个类似deque的数据结构，我相信它被称为循环缓冲区。

这就是我所做的。

public class MyStack {


    byte[][] orders = {  {0, 1, 2, 3}, {1, 2, 3, 0}, {2, 3, 0, 1}, {3, 0, 1, 2}  };

    byte state      = 0;

    int[] data      = {1, 2, 3, 4};


    void swap(int value){           
        data[state] = value;

        if(state == 3){
            state = 0;

        }else{
            state ++;

        }       
    }

    int[] dump(){

        int[] output = {  
                          data[  orders[state][0]  ],
                          data[  orders[state][1]  ],
                          data[  orders[state][2]  ],
                          data[  orders[state][3]  ],
                       };

        return output;
    }

}

这里的输出正是我需要的功能类型。它基本上是一个长度为4的窗口，在无限的离散空间中移动，或沿着数字线移动。

我的问题是：这个解决方案有效吗？是否有为此功能设计的内置库？如果是这样，是否值得使用？

Answer 1

对此的一个改进是，删除大小为n的订单2D数组。

byte[][] orders = {  {0, 1, 2, 3}, {1, 2, 3, 0}, {2, 3, 0, 1}, {3, 0, 1, 2}  };

因为如果您知道状态，那么orders数组也可以通过公式

动态确定

for(int i =0; i<data.length; i++){
  output[i] = data[(state+i)%data.length];
}

这可以用来返回输出。

Answer 2

circular buffer的典型实现使用两个索引来标记队列的第一个和最后一个元素。没有必要明确存储状态，因为enqueue和dequeue可以通过索引计算完成。 swap方法的更好名称是rotate。

您可以移除orders数组并将dump实施更改为：

    int[] output = {  
                      data[  (state+0)%4  ],
                      data[  (state+1)%4  ],
                      data[  (state+2)%4  ],
                      data[  (state+3)%4  ],
                   };

Java中的循环缓冲区？

2 个答案: