FUN的功能：把形参a所指数中的最大值放在a[0]中，接着求出a所指数中的最小值放在a[1]中，再把a所指数元素中的次大值放在 a[2]中，把a数组元素中的次小值放在a[3]中，其余以此类推
若a 所指数的数据最初排列：1，4，2，3，9，6，5，8，7.按规格移动后，数据排列：9，1，8，2，7，3，6，4，5。形参n中存放a所指数中的数据的个数
源码以下
#include    <stdio.h>
#define    N    9
/**********found**********/
void fun(int  ___1___, int  n)
{  int  i, j, max, min, px, pn, t;
/**********found**********/
   for (i=0; i<n-1; i+=___2___)
   {  max = min = a[i];
      px = pn = i;
/**********found**********/
      for (j=___3___; j<n; j++)
      {  if (max < a[j])
         {  max = a[j]; px = j;  }
         if (min > a[j])
         {  min = a[j]; pn = j;  }
      }
      if (px != i)
      {  t = a[i]; a[i] = max; a[px] = t;
         if (pn == i) pn= px;
      }
      if (pn != i+1)
      {   t = a[i+1]; a[i+1] = min; a[pn] = t; }
   }
}
main()
{  int  b[N]={1,4,2,3,9,6,5,8,7}, i;
   printf("\nThe original data  :\n");
   for (i=0; i<N; i++)  printf("%4d ", b[i]);
   printf("\n");
   fun(b, N);
   printf("\nThe data after moving  :\n");
   for (i=0; i<N; i++)  printf("%4d ", b[i]);
   printf("\n");
}
谁知道怎么做

第一个空( *a )
第二个空( 2  )
第三个空( i+1)

谢谢你

我的想法是用二叉树，然后递归rank

个人感觉算法还 ok这里是我的code

但是貌似调不过

#include<iostream>                                                                                                           
using namespace std;                                                                                                         
struct BiNode{                                                                                                               
    long key;                                                                                                                
    BiNode *pre;                                                                                                             
    BiNode *next;                                                                                                            
    BiNode(long n){ key =n ;pre=NULL; next=NULL;}                                                                            
};                                                                                                                           
class BiTree{                                                                                                                
private:                                                                                                                     
    static int Rank;                                                                                                         
    void BiTreeInsert(BiNode *&root,long n)                                                                                  
        {                                                                                                                    
            if( NULL == root)                                                                                                
            {                                                                                                                
                root= new BiNode(n);                                                                                         
            }                                                                                                                
            else                                                                                                             
            {                                                                                                                
                if( root->key < n )                                                                                          
                    root->pre=new BiNode(n);                                                                                 
                if(root->key >n )                                                                                            
                    root->next=new BiNode(n);                                                                                
                if( root->key == n)                                                                                          
                    return ;                                                                                                 
            }                                                                                                                
        }                                                                                                                    
    void BiTreeRank(BiNode * root, int r , long & key)                                                                       
        {                                                                                                                    
            if( NULL == root)                                                                                                
            {                                                                                                                
                return ;                                                                                                     
            }                                                                                                                
            else                                                                                                             
            {                                                                                                                
                BiTreeRank( root->next, r , key);                                                                            
                Rank++;                                                                                                      
                if( Rank == r)                                                                                               
                    key=root->key;                                                                                           
                BiTreeRank( root->pre, r, key);                                                                              
            }                                                                                                                
        }                                                                                                                    
    void BiTreeShow(BiNode * root )                                                                                          
        {                                                                                                                    
            if(NULL == root)                                                                                                 
                return ;                                                                                                     
            BiTreeShow(root->pre);                                                                                           
            cout<<root->key<<" ";                                                                                            
            BiTreeShow(root->next);                                                                                          
        }                                                                                                                    
    void BiTreeDestroy(BiNode *root){                                                                                        
        if( NULL == root)                                                                                                    
            return ;                                                                                                         
        BiTreeDestroy(root->pre);                                                                                            
        BiTreeDestroy(root->next);                                                                                           
        delete root;                                                                                                         
    }                                                                                                                        
public:                                                                                                                      
    BiNode *root;                                                                                                            
    BiTree(){ root = NULL ;}                                                                                                 
    ~BiTree()                                                                                                                
        {                                                                                                                    
            // BiTreeDestroy(root);                                                                                          
        }                                                                                                                    
    void insert(long n){ BiTreeInsert(root, n);}                                                                             
    long rank(int r)
        {
            long k;
            BiTreeRank(root,r, k);
            return k;
        }
    void show(){ BiTreeShow( root);}
};
int BiTree::Rank=0;
int main()
{
    int n;
    long key;
    while(cin>>n)
    {
        if ( 0 == n)
            break;
        BiTree *tree=new BiTree();
        for( int i=0;i<n;i++)
        {
            cin>>key;
            tree->insert(key);
        }

        tree->show();
        cout<<endl;
        int rank=-1;
        rank=tree->rank(1);
        if( -1 == rank )
            cout<<"NO such score!"<<endl;
        else
            cout<<rank<<endl;
    }
    return 0;
}

哪位高人帮check一下。