POJ 1007

题目大意：

给出n个长度为m的DNA序列，按照DNA序列的逆序对数目（顺序是：A->C-> G-> T，逆序对，就是不按照这个顺序出现的字母对数。）进行排序，要求是稳定的排序算法。

---------------------------------------------------------------------------------------我是华丽的分割线----------------------------------------------------------------------------

这个题应该不是很难，虽然说要找出DNA序列中的逆序对，不过仔细分析题目就知道，其实不要找逆序对，只要告诉逆序对的个数就可以了。所以只要逐个扫描字符然后统计字符出现的个数，在当前字符之前出现的所有逆序的字符就会和当前的字符构成逆序对，所以只要用个变量根据记录的字符个数统计一下就可以了。

还有一点呢是，关于排序的，他所要求的排序是指稳定的排序算法，所以不能偷懒使用qsort了...上网查了一下：

1.稳定的排序
冒泡排序（bubble sort） — O(n2) 
鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2) 
插入排序 （insertion sort）— O(n2) 
桶排序 （bucket sort）— O(n); 需要 O(k) 额外 记忆体 
计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外 记忆体 
归并排序 （merge sort）— O(n log n); 需要 O(n) 额外记忆体 
原地归并排序 — O(n2) 
二叉树排序 （Binary tree sort） — O(n log n); 需要 O(n) 额外记忆体 
鸽巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 额外记忆体 
基数排序 （radix sort）— O(n·k); 需要 O(n) 额外记忆体 
Gnome sort — O(n2) 
Library sort — O(n log n) with high probability, 需要 (1+ε)n 额外记忆体 
2.不稳定的排序
选择排序 （selection sort）— O(n2) 
希尔排序 （shell sort）— O(n log n) 如果使用最佳的现在版本 
Comb sort — O(n log n) 
堆排序 （heapsort）— O(n log n) 
Smoothsort — O(n log n) 
快速排序 （quicksort）— O(n log n) 期望时间, O(n2) 最坏情况; 对於大的、乱数串列一般相信是最快的已知排序 
Introsort — O(n log n) 
Patience sorting — O(n log n + k) 最外情况时间, 需要 额外的 O(n + k) 空间, 也需要找到最长的递增子序列（longest increasing subsequence）

为了不超出时间限制（由于POJ1061的原因现在有心理阴影了），所以排序算法选择了计数排序

代码如下：

#include <stdio.h>
#include <stdlib.h>

typedef struct __data{
  char *data;
  int order;
} da;

int calOrderness(char *DNA,int len){
  int code[4];
  int sum=0;
  int i;
  
  for (i=0;i<4;i++)
    code[i]=0;
  
  for (i=0;i<len;i++){
    switch(DNA[i]){
      case 'A':
      	code[0]++;
      	sum+=code[3]+code[2]+code[1];
      break;
      case 'C':
      	code[1]++;
      	sum+=code[3]+code[2];
      break;
      case 'G':
        code[2]++;
      	sum+=code[3];
      break;
      case 'T':
        code[3]++;
      break;
      default:
      break;
    }
  }
  return sum;
}
//计数排序，稳定的排序算法
#define COUNT_MAX 99*50
#define SORT_DATA_TO_COUNT(a) SDTC(a)
#define SDTC(a) (a).order

typedef da sortData_t;
typedef int sortCount_t;

void countingSort(sortData_t *dataPoint,sortCount_t dataLength){
   sortData_t *B;
   sortCount_t *C;
   sortCount_t j;
   
   C=(sortCount_t *)calloc(COUNT_MAX,sizeof(sortCount_t));
   B=(sortData_t *)calloc(dataLength+1,sizeof(sortData_t));
   
   for (j=0;j<dataLength;j++){
   	  C[SDTC(dataPoint[j])]=C[SDTC(dataPoint[j])]+1;
   }
   
   for (j=1;j<COUNT_MAX;j++){
   	  C[j]=C[j]+C[j-1];
   }

   for (j=dataLength-1;j>=0;j--){
      B[C[SDTC(dataPoint[j])]]=dataPoint[j];
      C[SDTC(dataPoint[j])]=C[SDTC(dataPoint[j])]-1;
   }

   for (j=0;j<dataLength;j++){
   	  dataPoint[j]=B[j+1];
   }
   
   free(B);
   free(C);
   B=NULL;
   C=NULL;
}

int main(){
	
	int nDNA,len,i;
	da *DNAlist;
	
	scanf("%d %d",&len,&nDNA);
	
	DNAlist=(da *)calloc(nDNA,sizeof(da));
	
	for (i=0;i<nDNA;i++){
		DNAlist[i].data=(char *)calloc(len+1,sizeof(char));
		scanf("%s",(DNAlist[i].data));
	  DNAlist[i].order=calOrderness(DNAlist[i].data,len);
	}
	
	countingSort(DNAlist,nDNA);
	
	for (i=0;i<nDNA;i++){
		printf("%s\n",(DNAlist[i].data));
	  free(DNAlist[i].data);
	}
	
	free(DNAlist);
	
}