user-0 提问: 明明感觉很简单，可就是写不出来，求各位大侠看下（能用递归最好）

回复:
user: user-1
content: 引用 9 楼 lm_whales 的回复:int invorder(int a[],int n){       int c =0;      if(n==1)return 0;       for(int i=0;i<n-1;i++)              c+= a[i]>a[n-1];        return c + invorder(a,n-1); } 修改一下

user: user-1
content: int invorder(int a[],int n){       int c =0;      if(n==1)return 0;       for(int i=0;i<n-1;i++)              c+= a[i]>a[n-1];        return t + invorder(a,n-1); }

user: user-2
content: 引用 13 楼 yaojuntong77 的回复:还有一个想法，就是把排列中的所有元素组织成小根堆树，则问题可以转化为： 值超过树根或者子树根的节点总数； 在构造出树结构了以后，再调整成满二叉树，就可以直接用数学公式了  可以在构造出的小根堆的每个节点追加一个卫星数据，用于记录其在原排列中的顺序下标值 接着从树根开始递归遍历树，遇上下标值小于树根或者子树根的就累计加1，否则不累计加

user: user-2
content: 还有一个想法，就是把排列中的所有元素组织成小根堆树，则问题可以转化为： 值超过树根或者子树根的节点总数； 在构造出树结构了以后，再调整成满二叉树，就可以直接用数学公式了

user: user-2
content: 我有个主意，楼主试试： 1、从序偶的要求来看，可以从找到排列中的最小值对应的下标 k[i] 开始，则在该下标前的所有下标均符合序偶构造要求，所以此时有 k[i] 个序偶，将其计入累积量 summary 中； 2、将步骤1找到的最小值从排列中删除，剩下来 n-1 容量的排列，这是步骤1的子问题； 3、判断 剩余的 n-1 容量是否递减到1，如果没有到1，返回 步骤1继续 执行，否则结束循环查找； 4、输出 summary 结果

user: user-3
content: 楼上的算法，我很欣赏，这个是我没有想到的一种实现方式。不过效率还是比我的效率低，测试代码如下： #include <stdio.h> #include <time.h> #include <stdlib.h> #include <string.h>  int invorder(int a[],int n){     int c =0;     if(n==1)return 0;     for(int i=0;i<n-1;i++)         c+= a[i]>a[n-1];     return c + invorder(a,n-1); }  struct Node{     int data;     int nums_r;     Node *parent;     Node *lChild;     Node *rChild; };  class CGetNixuNum { public:     CGetNixuNum() {         nNiXuNum = 0;          NIL = new Node;         memset(NIL, 0, sizeof(Node));         NIL->lChild = NIL;         NIL->rChild = NIL;         NIL->parent = NIL;         root = NIL;      }      ~CGetNixuNum() {         DestroyTree(root);         delete NIL;     }      size_t GetNixuNum() {return nNiXuNum;}      void Insert(int data) {         Node *node = new Node;         memset(NIL, 0, sizeof(Node));          node->data = data;         node->parent = NIL;         node->lChild = node->rChild = NIL;          InsertNode(node);     }  private:     void InsertNode(Node *node) {         Node *p = root;         Node *pP = NIL;         while (p != NIL) {             pP = p;             if (p->data <= node->data) {                 ++(p->nums_r);                 p = p->rChild;             }             else {                 nNiXuNum +=  p->nums_r + 1;                 p = p->lChild;             }         }         node->parent = pP;         if (pP == NIL) root = node;         else {             if (pP->data > node->data) pP->lChild = node;             else pP->rChild = node;         }      }      void DestroyTree(Node *node) {         if (node == NIL) return;         DestroyTree(node->lChild);         DestroyTree(node->rChild);          delete node;     } private:     Node *NIL;     Node *root;      size_t nNiXuNum; };   int main() {     const int SIZE = 50000;     int *a = new int[SIZE];      for (int i=0; i<SIZE; ++i)  {         a[i] = rand() % SIZE;     }      clock_t t1, t2;     double dt;      int nixu;      t1 = clock();     nixu = invorder(a, SIZE);     t2 = clock();     dt = ((double)(t2 - t1))/ CLOCKS_PER_SEC;     printf("%lf sec\n", dt);     printf("ni xu num is: %d\n", nixu);      t1=clock();     CGetNixuNum tree;     for (int i=0; i<SIZE; ++i) {         tree.Insert(a[i]);     }     nixu = tree.GetNixuNum();     t2=clock();     dt = ((double)(t2 - t1))/ CLOCKS_PER_SEC;     printf("%lf sec\n", dt);     printf("ni xu num is: %d\n", nixu);      delete [] a;      return 0; }  测试结果如下： 4.480000 sec ni xu num is: 623351270 0.020000 sec ni xu num is: 623351270

user: user-3
content: 目前 ，我能想到的最快的方法是使用二叉查找数的建立过程来提高算法的效率

user: user-3
content: #include <stdio.h> #include <string.h>  struct Node{     int data;     int nums_r;     Node *parent;     Node *lChild;     Node *rChild; };  class CGetNixuNum { public:     CGetNixuNum() {         nNiXuNum = 0;          NIL = new Node;         memset(NIL, 0, sizeof(Node));         NIL->lChild = NIL;         NIL->rChild = NIL;         NIL->parent = NIL;         root = NIL;      }      ~CGetNixuNum() {         DestroyTree(root);         delete NIL;     }      size_t GetNixuNum() {return nNiXuNum;}      void Insert(int data) {         Node *node = new Node;         memset(NIL, 0, sizeof(Node));          node->data = data;         node->parent = NIL;         node->lChild = node->rChild = NIL;          InsertNode(node);     }  private:     void InsertNode(Node *node) {         Node *p = root;         Node *pP = NIL;         while (p != NIL) {             pP = p;             if (p->data <= node->data) {                 ++(p->nums_r);                 p = p->rChild;             }             else {                 nNiXuNum +=  p->nums_r + 1;                 p = p->lChild;             }         }         node->parent = pP;         if (pP == NIL) root = node;         else {             if (pP->data > node->data) pP->lChild = node;             else pP->rChild = node;         }      }      void DestroyTree(Node *node) {         if (node == NIL) return;         DestroyTree(node->lChild);         DestroyTree(node->rChild);          delete node;     } private:     Node *NIL;     Node *root;      size_t nNiXuNum; };  int main() {     int a[10] = {0, 8, 9, 5, 7, 6, 2, 1, 3, 4};      CGetNixuNum tree;     for (int i=0; i<10; ++i) {         tree.Insert(a[i]);     }      printf("ni xu num is: %d\n", tree.GetNixuNum());      return 0; }

user: user-4
content: 最直接的方法两层循环 int i, j; int a[SIZE]; for(i = 0; i < sizeof a; ++i)      for(j = i + 1; j < sizeof a; ++j)            if(a[i] > a[j])                //输出

user: user-5
content: 拿分走人，谢谢楼主

user: user-6
content: 直接用merge_sort的思想, a 是输入, t是临时buffer与a等长 int invert_count(int *a,int x,int y,int *t){     if(y-x<=1) return 0;     int m =x+(y-x)/2;     int lct=invert_count(a,x,m,t);     int rct=invert_count(a,m,y,t);     int ct =0,p=x,q=m,i=x;     while(q<y||p<m){         if(q>=y||(p<m&&a[p]<=a[q])) t[i++] =a[p++];         else{             t[i++]  =a[q++];             ct +=m-p;         }     }     for(i=x;i<y;i++) a[i]=t[i];     return ct+lct+rct; }

user: user-7
content: 好像直接有公式都可以算个数的

user: user-1
content: 逆序数量，冒泡排序并统计可以不？

user: user-8
content: 人是怎么做的，就怎么写程序