懒惰的JY--关于遍历

先上题：

【问题描述】

            众所周知，JY的百度搜索算法已经练的炉火纯青，任何搜索题都能0.000ms出解。

            不幸的是，JY遇到了一道百度搜索算法解决不了的题目，题目是这样的：

            给定N个数A[1] A[2] .. A[N]，你需要将其重新排序，满足：

            1. 对于1<i<=N，A[i]>=A[i/2]。(i/2取下整)

            2. 在所有满足条件1的答案中，取A[1]最大的。

            3. 仍有多解则取A[2]最大的，依次类推。

            JY只好去问他的LBH，可是LBH正在准备数学联赛，没空理JY。JY表示懒得做这道水题，于是这道题就交给你了。

【输入格式】

            第一行 N

            接下来一行N个数

【输出格式】

    一行N个数，相邻的数用空格隔开

【输入输出样例】

lazy.in	lazy.out
7 1 2 3 4 5 6 7	1 5 2 7 6 4 3

 

【数据范围】

    50%：N<=2000

            100%：N<=100000

一看到这题，便可想到树，对于a[i]，我们可以先排序，用线性表来实现树，即当我们把最小值放在中间，把他的左子树放较小的剩下的数，

把他的右子树放较大的数，再重复建树过程即可，代码如下：

var
    i,k,n:longint;
    a,b:array[-100..100001]of longint;

procedure qsort(l,r:longint);                            //快排
    var
        i,j,mid,t:longint;
    begin
        i:=l; j:=r; mid:=a[(l+r)div 2];
        repeat
            while a[i]<mid do inc(i);
            while a[j]>mid do dec(j);
            if i<=j then
                begin
                    t:=a[i];
                    a[i]:=a[j];
                    a[j]:=t;
                    inc(i);
                    dec(j);
                end;
        until i>j;
        if i<r then qsort(i,r);
        if l<j then qsort(l,j);
    end;

procedure put(x:longint);                            //用后序遍历（？）建立一个树
    begin
        inc(k);
    if k>n then exit;
        b[x]:=a[k];
    if (2*x+1)<=n then
          put(2*x+1);
    if 2*x<=n then
      put(2*x);
    end;

begin
    assign(input,'lazy.in');
    assign(output,'lazy.out');
    reset(input);
    rewrite(output);
    readln(n);                                        //读入n
    for i:=1 to n do
        read(a[i]);
    qsort(1,n);
    k:=0;
    put(1);                                    //从1开始建树    
  for i:=1 to n do
    write(b[i],' ');                    //正序输出
    close(input);
    close(output);
end.