数据结构_桶排序

// 数据结构_桶排序.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
/*当桶排序的输入符合均匀分布时，即可以以线性期望时间运行*/
/*算发导论中的伪代码*/
/*
BUCKET-SORT(A)
1 n <- length[A]
2 for i <- 1 to n
3    do insert A[i] into list B[|_nA[i]_|]
4 for i <- 0 to n-1
5  do sort list B[i] with insertion sort
6 concatenate the lists B[0],B[1],...,
B[n-1] together in order
桶排序的时间复杂度为N

*/

//定义链表的头
typedef struct LNODE{

  float data;

  LNODE *next;

}LNODE,*PLNODE;

//这里，我们定义10个桶，用来存放不同的数据

const int NUMDATA = 10;

#define k 10

int paixu_jishu(float a[],int ilength){
 
 int j = 0;
 
 int c[k];
 
 char chtemp[4];
 
 
    /*分配临时空间，大小和待排序的数据空间大小一致*/
 float *b = (float *)malloc(sizeof(float)*ilength);
 
 int *atemp = (int *)malloc(sizeof(int)*ilength);
 
 /*依次从最低位开始取得数字，转换为整数，一直到最高位*/
 for(j = 0; j < ilength; j++){
  
  sprintf(chtemp,"%02f",a[j]);
  
  atemp[j] = chtemp[3] - '0';
  
  
 }
 
 
    /*计数的数组进行清0*/
 for(j = 0; j < k; j++){
  
  c[j] = 0;
 }
   
 /*分别得到等于0，1，2，3.....一直到9的数字个数*/
 for(j = 0;j < ilength;j++){
  
  
  c[atemp[j]] = c[atemp[j]] + 1;
 }
 

    /*分别得到小于等于0，1，2，3.....一直到9的数字个数*/
 for(j = 1; j < k; j++){
  
  c[j] = c[j] + c[j-1];
 }
 

 
 for(j = ilength - 1; j >= 0; j--){
  // 注意这里跟计数排序有点不一样，因为我们是多位数，计数排序是b[c[atemp[j]] - 1] = atemp[j];
  b[c[atemp[j]] - 1] = a[j];
  
  c[atemp[j]] = c[atemp[j]] - 1;
  
  
  
 }

 for(j = 0; j < ilength;j++){
  
  a[j] = b[j];
  
 
 }
 
 free(b);
 free(atemp);
 
 return 0;
 
}

int main(int argc, char* argv[])
{

 int iList_len[10];

 int x = 0;

 /*用算法导论中的，待排序的数据，进行举例*/

 float a[] ={0.78,0.17,0.39,0.26,0.72,0.94,0.21,0.12,0.23,0.68};

 int iLength = 0;

 int iCycle = 0;

 float *b[10];

 PLNODE pHeadnode[NUMDATA];

 PLNODE pTempNode[NUMDATA];

 PLNODE pNode = NULL;

 iLength = sizeof(a) / 4;

 printf("\n");

 /*给每个头结点和临时结点分配空间，并答应待排序的数据*/

 for(iCycle = 0; iCycle < iLength; iCycle++){

  pHeadnode[iCycle] = (LNODE *)malloc(sizeof(LNODE));

  pTempNode[iCycle] = (LNODE *)malloc(sizeof(LNODE));

  iList_len[iCycle] = 0;

  printf(" %02f ",a[iCycle]);
 }

 printf("\n");
  
    // 将数据放进不同的桶中，这个数据应该有函数，后续再修改。
 for(iCycle = 0; iCycle < iLength; iCycle++){

  if((a[iCycle] >= 0.0) && (a[iCycle] < 0.1)){

    pNode = (LNODE *)malloc(sizeof(LNODE));
   
    if(0 == iList_len[0])
    {
      pHeadnode[0] = pNode;

      pTempNode[0] = pNode;
    }
    else
    {
     pHeadnode[0] -> next = pNode;

     pHeadnode[0] = pHeadnode[0] ->next;
      
    }
     iList_len[0]++;

     pNode ->data = a[iCycle];

  } 
  if((a[iCycle] >= 0.1) && (a[iCycle] < 0.2)){
   
   pNode = (LNODE *)malloc(sizeof(LNODE));

   pNode = (LNODE *)malloc(sizeof(LNODE));
   
   if(0 == iList_len[1])
   {
    pHeadnode[1] = pNode;
    
    pTempNode[1] = pNode;
   }
   else
   {
    pHeadnode[1] -> next = pNode;
    
    pHeadnode[1] = pHeadnode[1] ->next;
    
   }
   iList_len[1]++;
   
   pNode ->data = a[iCycle];
 
  }
  if((a[iCycle] >= 0.2) && (a[iCycle] < 0.3)){
   
    pNode = (LNODE *)malloc(sizeof(LNODE));
   
    if(0 == iList_len[2])
    {
      pHeadnode[2] = pNode;

      pTempNode[2] = pNode;
    }
    else
    {
     pHeadnode[2] -> next = pNode;
     
     pHeadnode[2] = pHeadnode[2] ->next;
     
    }
    iList_len[2]++;
    
    pNode ->data = a[iCycle];
  
  } 
  if((a[iCycle] >= 0.3) && (a[iCycle] < 0.4)){
   
    pNode = (LNODE *)malloc(sizeof(LNODE));
   
    if(0 == iList_len[3])
    {
      pHeadnode[3] = pNode;

      pTempNode[3] = pNode;
    }
    else
    {
     pHeadnode[3] -> next = pNode;
     
     pHeadnode[3] = pHeadnode[3] ->next;
     
    }
     iList_len[3]++;
    
     pNode ->data = a[iCycle];

   
  } 
  if((a[iCycle] >= 0.4) && (a[iCycle] < 0.5)){
   
    pNode = (LNODE *)malloc(sizeof(LNODE));
   
    if(0 == iList_len[4])
    {
      pHeadnode[4] = pNode;

      pTempNode[4] = pNode;
    }
    else
    {
     pHeadnode[4] -> next = pNode;
     
     pHeadnode[4] = pHeadnode[4] ->next;
     
    }
     iList_len[4]++;
    
     pNode ->data = a[iCycle];
   
  } 
  if((a[iCycle] >= 0.5) && (a[iCycle] < 0.6)){
   
    pNode = (LNODE *)malloc(sizeof(LNODE));
   
    if(0 == iList_len[5])
    {
      pHeadnode[5] = pNode;

      pTempNode[5] = pNode;
    }
    else
    {
     pHeadnode[5] -> next = pNode;
     
     pHeadnode[5] = pHeadnode[5] ->next;
     
    }
     iList_len[5]++;
    
     pNode ->data = a[iCycle];
  } 
  if((a[iCycle] >= 0.6) && (a[iCycle] < 0.7)){
   
    pNode = (LNODE *)malloc(sizeof(LNODE));
   
    if(0 == iList_len[6])
    {
      pHeadnode[6] = pNode;

      pTempNode[6] = pNode;
    }
    else
    {
     pHeadnode[6] -> next = pNode;
     
     pHeadnode[6] = pHeadnode[6] ->next;
     
    }
     iList_len[6]++;
    
     pNode ->data = a[iCycle];

   
   } 
  if((a[iCycle] >= 0.7) && (a[iCycle] < 0.8)){
   
    pNode = (LNODE *)malloc(sizeof(LNODE));
   
    if(0 == iList_len[7])
    {
      pHeadnode[7] = pNode;

      pTempNode[7] = pNode;
    }
    else
    {
     pHeadnode[7] -> next = pNode;
     
     pHeadnode[7] = pHeadnode[7] ->next;
     
    }
     iList_len[7]++;
    
     pNode ->data = a[iCycle];

   
   
   } 
  if((a[iCycle] >= 0.8) && (a[iCycle] < 0.9)){
   
    pNode = (LNODE *)malloc(sizeof(LNODE));
   
    if(0 == iList_len[8])
    {
      pHeadnode[8] = pNode;

      pTempNode[8] = pNode;
    }
    else
    {
     pHeadnode[8] -> next = pNode;
     
     pHeadnode[8] = pHeadnode[8] ->next;
     
    }
     iList_len[8]++;
    
     pNode ->data = a[iCycle];
  } 
  if((a[iCycle] >= 0.9) && (a[iCycle] < 1.0)){
   
    pNode = (LNODE *)malloc(sizeof(LNODE));
   
    if(0 == iList_len[9])
    {
      pHeadnode[9] = pNode;

      pTempNode[9] = pNode;
    }
    else
    {
     pHeadnode[9] -> next = pNode;
     
     pHeadnode[9] = pHeadnode[9] ->next;
     
    }
     iList_len[9]++;
    
     pNode ->data = a[iCycle];
   
   
   
   } 

 }

 //这里，iList_len[iCycle] 记录了iCycle的桶中的数据个数 pTempNode[iCycle]记录了每个桶的头结点
 //继续排序，我们又要用到基数排序，基数排序又会用到记数排序
    //我们看到对于更多的数据，我们可以用用空间换时间的方法，增加桶的数量，降低时间复杂度

 for(iCycle = 0; iCycle < 10 ; iCycle++){
        
  if(iList_len[iCycle] > 0){

   x = 0;
 
   b[iCycle] = (float *)malloc((sizeof(float))*iList_len[iCycle]);

   while(iList_len[iCycle] > 0){

       b[iCycle][x] = pTempNode[iCycle] ->data;

    pTempNode[iCycle] = pTempNode[iCycle]->next;
    
    iList_len[iCycle]--;
    
    x++;

   }

   paixu_jishu(b[iCycle],x);

   for(int ix = 0; ix < x; ix++){

    printf(" %02f ",b[iCycle][ix]);
   } 

  }
 }

 return 0;
}