用环形数组实现队列（多种高级方法，由浅入深）

于 2024-11-07 20:15:12 发布
阅读量1.2k 收藏 34
点赞数 16
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xuziang13/article/details/143600692
版权

同普通数组实现的队列相比，普通数组的头结点和尾节点都是固定的，在进行移除的时候如果移除了一个节点，后面所有节点都需要进行移除操作，需要的时间复杂度更高

在环形数组中，确定了头尾指针的环形数组很好地解决了这一点

我们来看具体思路

方法一：牺牲一个存储容量

有两个指针，在环形数组为空的时候它们都指向这个0索引

加入元素之后，尾指针后移一位，直到尾指针的 下一个和头指针重合，如图

在进行移除操作的时候，将头指针前进一位即可

 

 

 isfull：当尾指针的下一个位置与头指针重合时，说明环形数组已经满了

用索引来表示的话每次让移动让tail+1，和数组长度取模即可，再和head的值进行判断

isempty:当尾指针与头指针重合的时候，说明环形数组为空

为了使下标可以为0到4循环，我们需要控制tail和head，所以我们可以这么表示

进行head和tail的迭代

 head=(head+1)%array.length;
 tail=(tail+1)%array.length;

在迭代器中，将初始节点定位为p=head，循环条件为p！=tail，因为tail指的是下一个存入元素的数组位置 

我们来看方法实现

public class ArrayQueue1 <E>implements Queue<E>,Iterable<E>{

    private E[] array;
    private int head=0;
    private int tail=0;

    @SuppressWarnings("all")
    public ArrayQueue1(int capacity) {
        array = (E[]) new Object[capacity+1];
    }
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p=head;
            @Override
            public boolean hasNext() {
                return p!=tail;
            }

            @Override
            public E next() {
                E value=array[p];
                p=(p+1)%array.length;
                return value;
            }
        };
    }

    @Override
    public boolean offer(E value) {
        if(isFull()){
            return false;
        }
        array[tail]=value;
        tail=(tail+1)%array.length;
        return true;
    }

    @Override
    public E poll() {
        if(isEmpty()){
            return null;
        }
        E value=array[head];
        head=(head+1)%array.length;
        return value;
    }

    @Override
    public E peek() {
        if(isEmpty()){
            return null;
        }
        return array[head];
    }

    @Override
    public boolean isEmpty() {
        return head==tail;
    }

    @Override
    public boolean isFull() {
        return (tail+1)%array.length==head;
    }
}

方法二：通过数组内元素个数进行判断

和之前的思路相近，我们多设置一个size记录元素个数，这个时候不需要牺牲一个存储容量，在isfull判断中直接通过比较size和数组长度，在非空判断中，判断size是否为0即可

关于迭代器遍历，我们需要再引入一个变量count，初始值赋值为0，循环条件是count<size,因为size代表元素个数

我们来看代码

ic class ArrayQueue2 <E>implements Queue<E>,Iterable<E>{

    private E[] array;
    private int head=0;
    private int tail=0;
    private int size=0;//队列中元素个数

    @SuppressWarnings("all")
    public ArrayQueue2(int capacity) {
        array = (E[]) new Object[capacity];
    }
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p=head;
            int count=0;
            @Override
            public boolean hasNext() {
                return count<size;
            }

            @Override
            public E next() {
                E value=array[p];
                p=(p+1)%array.length;
                count++;
                return value;
            }
        };
    }

    @Override
    public boolean offer(E value) {
        if(isFull()){
            return false;
        }
        array[tail]=value;
        tail=(tail+1)%array.length;
        size++;
        return true;
    }

    @Override
    public E poll() {
        if(isEmpty()){
            return null;
        }
        E value=array[head];
        head=(head+1)%array.length;
        size--;
        return value;
    }

    @Override
    public E peek() {
        if(isEmpty()){
            return null;
        }
        return array[head];
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public boolean isFull() {
        return size==array.length;
    }
}

方法三：不通过牺牲元素和进行headtail处理

我们还是设置头尾指针，我们以上图为例子，有一个长度为3的环形数组

我们一直将head和tail进行移动的时候递增，不再通过head和tail做处理来代表索引，而是通过将递增的head和tail进行计算来求索引，我们不再通过array[head]或者array[tail]代表元素值，而是通过

array[head%array.length]和array[tail%array.length]

在进行非空判断的时候，思路还是tail=head

在进行非满判断的时候，思路则是通过tail-head等不等于数组长度，无需牺牲一个存储空间。

我们来看代码

public class ArrayQueue3<E> implements Queue<E>, Iterable<E>{

    private final E[] array;
    private int head = 0;
    private int tail = 0;

    @SuppressWarnings("all")
    public ArrayQueue3(int capacity) {
        array = (E[]) new Object[capacity];
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            int p=head;
            @Override
            public boolean hasNext() {
                return p!=tail;
            }

            @Override
            public E next() {
                E value=array[head%array.length];
                p++;
                return value;
            }
        };
    }

    @Override
    public boolean offer(E value) {
        if(isFull()){
            return false;
        }
        array[tail%array.length] = value;
        tail++;
        return true;
    }

    @Override
    public E poll() {
        if (isEmpty()){
            return null;
        }
        E value=array[head%array.length];
        head++;
        return value;
    }

    @Override
    public E peek() {
        if (isEmpty()){
            return null;
        }
        E vakue=array[head%array.length];
        return vakue;
    }

    @Override
    public boolean isEmpty() {
        return head == tail;
    }

    @Override
    public boolean isFull() {
        return tail-head == array.length;
    }
}

一些问题思考

在方法三中，我们不对head和tail进行处理，而是放任其递增，因为int是有范围的，再超过tail的最大范围之后会报错，所以我们思考处理方法

第一种方法，通过转成长整型long避免越界报错，强制转型

array[(int) (Integer.toUnsignedLong(tail)%array.length)]

但是所有涉及的数组都需要进行强制转型，会比较复杂

二进制中按位与运算

求模运算：

  • 如果除数是2的n次方
  • 那么被除数的后n位即为余数（模）
  • 求被除数的后n位方法：与2^n-1次方进行按位与运算
array[head&(array.length-1)];

修改如上

如果数组长度不是2的n次方，我们该如何应对呢

将数组长度根据传入参数设置成2的n次方

第一种方法直接抛出异常

2^n&2^n-1=0

我们可以根据这个规律直接抛出异常

public ArrayQueue3(int capacity) {
        //1.抛异常
        if((capacity&capacity-1)!=0){
            throw new IllegalArgumentException("capacity must be a power of 2");
        }
        array = (E[]) new Object[capacity];
    }

第二种方法是修改传入参数

我们先看思路，假设传进来的数值是30

我们需要将30改成32，也就是找到最近的2的n次方等于32，

我们可以看到log2（30）大约是等于4.几，为了使其变成5，我们可以将log（30）+1，并将其强制转型为整型

又因为idea java语言中的Math包里面只有log10，所以我们可以使用换底公式

但是如果说本来这个数字就是2的n次幂的话再+1就会修改它的值，所以我们可以给传入的参数值进行-1处理，这样就可以很好的避免

在我们得到了n次幂的基础上，我们只需要对1进行左移即可（2^0=1）

代码如下

public static void main(String[] args) {
        int c=30;
        int n=(int)(Math.log10(c-1)/Math.log10(2))+1;
        System.out.println(1<<n);
    }

或者我们也可以直接利用一个公式

求离C最近，比C大的2^n次幂

c-=1;
c|=c>>1;
c|=c>>2;
c|=c>>4;
c|=c>>8;
c|=c>>16;
c+=1;

代码如下

 @SuppressWarnings("all")
    public ArrayQueue3(int c) {
     
        c-=1;
        c|=c>>1;
        c|=c>>2;
        c|=c>>4;
        c|=c>>8;
        c|=c>>16;
        c+=1;
        array = (E[]) new Object[c];
    }

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值