//动态多叉堆排序
class MaxPQ< Key extends Comparable<Key>>{
Key[] pq;
private int treeSize;//几叉树
private int start;//起始位置
private int N;//
public MaxPQ(int maxSize) {
treeSize=2;
start=1;
N=start-1;
//初始化
pq=(Key[])new Comparable[maxSize+1];
}
/**
*
* @param maxSize 最大长度
* @param start 起始位置
* @param treeSize 几叉树
*/
public MaxPQ(int maxSize,int start,int treeSize) {
this.start=start;
this.treeSize=treeSize;
this.N=start-1;
//初始化
pq=(Key[])new Comparable[maxSize+1];
}
public boolean isEmpty() {
return this.N==start-1;
}
public int size() {
return this.N;
}
public void insert(Key key) {
pq[++N]=key;
swim(N);
}
/**
* 删除最大元素,并返回
* @return
*/
public Key delMax() {
Key max=pq[start];
exch(start,N);
pq[N]=null;
N--;
sink(start);
return max;
}
/**
* 上浮操作
* @param k
*/
public void swim(int k) {
//当k不是根节点 且 k的父节点比k小,则交换位置,一直循环
int j;
while(k>start && less(j=getFather(k),k)) {
exch(j,k);
k=j;
}
}
/**
* 下沉操作
* @param k
*/
public void sink(int k) {
//若k有子节点
int j;
while((j=getSon(k))+1<N) {
//选择子节点中较大的那一个
int max=j;
for(int i=0;i<treeSize-1;i++) {
if(less(max,j+1)) {
max=++j;
}else {
++j;
}
}
//比较子节点和父节点大小
if(!less(k,j))
break;
//交换位置
exch(k,j);
//继续循环
k=j;
}
}
/**
* 比较大小 k<j true
* @param k
* @param j
* @return
*/
public boolean less(int k,int j) {
return pq[k].compareTo(pq[j]) < 0;
}
/**
* 交换两元素
* @param k
* @param j
*/
public void exch(int k,int j) {
Key t=pq[k];
pq[k]=pq[j];
pq[j]=t;
}
/**
* 删除指定位置的元素
* @param k
* @return
*/
public Key delete(int k) {
if(k>N) {
return null;
}
if(k<start) {
return null;
}
Key item=pq[k];
exch(k,N);
N--;
swim(k);
sink(k);
pq[N+1]=null;
return item;
}
//获取父节点 根据最基本的情况分析
public int getFather(int son) {
return (son-(start-1)+(treeSize-2))/treeSize+start-1;
}
//获取子节点 根据最基本的情况分析
public int getSon(int father) {
return (father-(start-1))*treeSize+(start-1)-(treeSize-2);
}
public List getAll() {
return Arrays.asList(pq);
}
}
开头元素动态的多叉堆实现
最新推荐文章于 2021-12-12 08:55:21 发布