共同学习Java源代码-数据结构-PriorityQueue类(七)

    privatevoid siftUp(intk, E x) {

        if (comparator != null)

            siftUpUsingComparator(k, x);

        else

            siftUpComparable(k, x);

}

这是siftUp方法 判断comparator属性是否为空如果不为空就调用siftUpUsingComparator方法 否则调用siftUpComparable方法

 

    @SuppressWarnings("unchecked")

    privatevoid siftUpComparable(intk, E x) {

        Comparable<? super E> key = (Comparable<? super E>) x;

        while (k > 0) {

            intparent = (k - 1) >>> 1;

            Object e = queue[parent];

            if (key.compareTo((E) e) >= 0)

                break;

            queue[k] = e;

            k = parent;

        }

        queue[k] = key;

}

这个是用Comparable方式将元素前移的方法

第一个参数是要前移的下标k 第二个参数是要前移的元素x

将最后一个x转为Comparable接口实现类key

判断如果k大于0 就进入while循环 将k减一后无符号右移一位 就是除以2 得到临时变量parent 获取数组parent处的元素e 判断如果key大于等于e 也就是参数元素大于等于parent元素 直接跳出循环 如果key小于e 那么将k处也就是参数下标处的元素设为e将k赋为parent 继续进入循环判断

跳出循环后将k处赋为key

这个就类似选择排序 将参数不断与下标的中间值进行比较 如果大于就跳出循环将参数直接放在下标处 如果不大于就将下标不断减半再比较参数和减半后的下标的中间值 就是一步步缩小比较的范围 然后将参数放在合适的位置

 

    @SuppressWarnings("unchecked")

    privatevoid siftUpUsingComparator(intk, E x) {

        while (k > 0) {

            intparent = (k - 1) >>> 1;

            Object e = queue[parent];

            if (comparator.compare(x, (E) e) >= 0)

                break;

            queue[k] = e;

            k = parent;

        }

        queue[k] = x;

}

这个和上面那个非常类似 就是用comparator进行比较

 

    privatevoid siftDown(intk, E x) {

        if (comparator != null)

            siftDownUsingComparator(k, x);

        else

            siftDownComparable(k, x);

}

siftDown方法 根据comparator属性是否为空调用不同的siftDown方法 和上面的siftUp类似

 

    @SuppressWarnings("unchecked")

    privatevoid siftDownComparable(intk, E x) {

        Comparable<? super E> key = (Comparable<? super E>)x;

        inthalf = size >>> 1;               while (k < half) {

            intchild = (k << 1) + 1;            Object c = queue[child];

            intright = child + 1;

            if (right < size &&

                ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)

                c = queue[child = right];

            if (key.compareTo((E) c) <= 0)

                break;

            queue[k] = c;

            k = child;

        }

        queue[k] = key;

    }

这个是根据comparable方式将元素后移的方法

第一个参数是要移动到的下标 第二个参数是要后移的元素

先将第二个参数x强转为Comparable

计算出数组非空元素长度的一半half

进入while循环 循环条件为下标小于half

将下标乘以二加一 赋给临时变量child

将数组child下标处元素赋给临时变量c

将child变量加一赋给临时变量right

判断如果right小于size 也就是说没有超过非空元素数目且 child处元素c大于right处元素将right赋给child c赋为right处元素 也就是c赋为原来child右边那个元素 child值加一

判断如果参数元素小于c 跳出while循环

将参数下标处元素赋为c 将k赋为child

跳出循环后将下标为k的元素赋为参数元素

这个也类似选择排序 只是范围越来越大 将参数元素与下标的二倍和二倍加一不断比较

 

    @SuppressWarnings("unchecked")

    privatevoid siftDownUsingComparator(intk, E x) {

        inthalf = size >>> 1;

        while (k < half) {

            intchild = (k << 1) + 1;

            Object c = queue[child];

            intright = child + 1;

            if (right < size &&

                comparator.compare((E) c, (E) queue[right]) > 0)

                c = queue[child = right];

            if (comparator.compare(x, (E) c) <= 0)

                break;

            queue[k] = c;

            k = child;

        }

        queue[k] = x;

    }

 

这是用Comparator进行向后移位 几乎完全一样 不多说了