void levelorder(node *root)
{
node *temp=root;
pushqueue(temp);
while(!isempty_q())
{
node *hold=popqueue();
if(hold!=NULL)
{
printf("%d\n",hold->data);
if(hold->left!=NULL)
pushqueue(hold->left);
if(hold->right!=NULL)
pushqueue(hold->right);
}
}
}
int arrange(int child, int percent, void *re_src, void *mv_src)
{
CompactSrc *re_decompact = (CompactSrc *) re_src;
FileDesc *Re_Child = re_decompact->out;
FileDesc Re_Same = re_decompact->same;
CompactSrc *mv_decompact = (CompactSrc *) mv_src;
FileDesc *Mv_Child = mv_decompact->out;
//FileDesc Mv_Same = mv_decompact->same;
long long max_child_size;
long long sum_all_size;
long long child_size;
int cmin, cmax;
struct FileSource tmp_move;
int i;
struct FileSource cmp[child];
sum_all_size = Re_Same->sum_size;
child_size = 0;
for(i=0; i<child; i++)
{
sum_all_size += Re_Child[i]->sum_size;
child_size += Re_Child[i]->sum_size;
}
max_child_size = percent*sum_all_size/100;
printf("%lld\n", max_child_size);
if(child_size<max_child_size)
{
while(child_size<max_child_size)
{
cmin = min_child(Re_Child, child);
tmp_move = dequeue(Re_Same);
enqueue(Re_Child[cmin], tmp_move);
enqueue(Mv_Child[cmin], tmp_move);
child_size += tmp_move.size;
}
return 1;
}
else
{
while(child_size>max_child_size)
{
for(i=0; i<child; i++)
{
cmp[i] = *(Re_Child[i]->tail);
}
cmax = maxxx_child(cmp, child);
tmp_move = popqueue(Re_Child[cmax]);
pushbottom(Re_Same, tmp_move);
enqueue(Mv_Child[cmax], tmp_move);
child_size -= tmp_move.size;
}
if(child_size!=0)
{
tmp_move = dequeue(Re_Same);
cmin = min_child(Re_Child, child);
enqueue(Re_Child[cmin], tmp_move);
child_size += tmp_move.size;
popqueue(Mv_Child[cmin]);
}
return 0;
}
}
void tkd_exec(){
int i,j,k,s,t,tau;
miss = 0;
/*
* calculate missing values O(N*D) and initialize T
*/
for(i = 0; i < N; ++i){
for(j = 0; j < D; ++j){
dataset[i].T[j] = N-1;//initialization
miss += dataset[i].missing[j];
}
}
/*
* calculate the number of objects a certain object dominates on a certain dimention O(D*N*logN)
*/
for(i = 0; i < D; ++i){
missd[i] = 0;
for(j = 0; j < N; ++j){
arr[j] = j;
if(dataset[j].missing[i])
++missd[i];
}
quicksort(arr,i,0,N-1);
j = N-1;
while(j>=missd[i]){
k = j;
while(k>0 && dataset[arr[j]].value[i]==dataset[arr[--k]].value[i]);
if(k==0)
--k;
for(s = k+1; s <= j; ++s)
dataset[arr[s]].T[i] = missd[i]+N-k-2;
j = k;
}
}
/*
* calculate maxscore O(N*D)
*/
for(i = 0;i < N; ++i){
maxscore[i]=dataset[i].T[0];
for(j = 1; j < D; ++j)
if(dataset[i].T[j]<maxscore[i])
maxscore[i]=dataset[i].T[j];
}
/*
* maintain a priority queue O(N*logN)
*/
queue[0] = N;
for(i = 1;i <= N; ++i)
queue[i] = i-1;
for(i = 1; i <= N/2; ++i)
perculateUp(maxscore,queue,i);
/*
* maintain a candidate set with max scores and using pruning
*/
tau = -1,candidateset[0]=0;
while(queue[0]){
t = popqueue(queue,maxscore);
if(maxscore[t]<tau) // maxscore pruning
break;
else{
score[t]=getscore(t,tau,miss,candidateset[0]); // bitscore pruning
if(score[t]>tau || tau<0){
if(candidateset[0]==K){
for(i=1;i<=candidateset[0];++i){
if(score[candidateset[i]]==tau){
candidateset[i]=t;
break;
}
}
}
else {
candidateset[++candidateset[0]]=t;
}
if(candidateset[0]==K){ // candidate set full
tau=score[candidateset[1]];
for(i=2;i<=K;++i)
if(score[candidateset[i]]<tau)
tau=score[candidateset[i]];
}
}
}
}
}
