算法导论笔记(四) ： 计数排序

1 计数排序概述

计数排序假设待排序数组中每一个元素都是0到k间的一个整数.如果k = O(n)，则计数排序运行的时间为O(n).

2 计数排序执行过程

(i)  填充辅助数组C(C的长度为K),数组A中的每一个元素都在C的对应位置加1.

(ii) 对C进行计算使得C[i] = C[i] + C[i-1]

(iii)从后向前遍历A数组,根据该元素的值找到C中对应位置的数。将该数字作为索引将当前元素填到结果数组B中.

(iv)C中对应位置的值减1.

下边是一个8个元素的数组A的计数排序过程：

3 代码实现

#ifndef __COUNTINGSORT_H__
#define __COUNTINGSORT_H__

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

class Countingsort
{
int* m_data_input;
int* m_data_output;
int* m_counter;
int  m_size;
int  m_k;
public:
Countingsort(int size ,int k);
~Countingsort();
void Sort();
bool Verify();
void Create();
};

#endif

#include "Countingsort.h"

Countingsort::Countingsort(int size,int k)
{
m_size = size;
m_k = k;
m_data_input = (int*)malloc(sizeof(int)*size);
m_data_output = (int*)malloc(sizeof(int)*size);
m_counter = (int*)malloc(sizeof(int)*k);
}

Countingsort::~Countingsort()
{
if(m_data_input)
{
free(m_data_input);
free(m_data_output);
free(m_counter);
}
}

void Countingsort::Create()
{
srand((unsigned)time(NULL));
for(int i=0;i< m_size;i++)
{
m_data_input[i] = rand() % m_k;
}
}

void Countingsort::Sort()
{
for(int i=0;i<m_k;i++)
{
m_counter[i] = 0;
}
for(int j=0;j<m_size;j++)
{
m_counter[m_data_input[j]]++;
}
for(int i=1;i<m_k;i++)
{
m_counter[i] = m_counter[i] + m_counter[i-1];
}
for(int v = m_size-1;v>=0;v--)
{
m_data_output[m_counter[m_data_input[v]]-1] = m_data_input[v];
m_counter[m_data_input[v]]--;
}
}

bool Countingsort::Verify()
{
int oldValue = m_data_output[0];
for(int i=1;i<m_size;i++)
{
if(m_data_output[i]<oldValue)
{
return false;
}
oldValue = m_data_output[i];
}
return true;
}

#include "Countingsort.h"

int main()
{
int size = 1000* 1000;
int k  =1024;
Countingsort pSort(size,k);
pSort.Create();
pSort.Sort();
if(pSort.Verify())
{
printf("Success \n");
}
else
{
printf("error \n");
}
return 0;
}

4 性能分析

(i)计数排序的性能是O(n)，优于基于元素比较的排序算法

(ii)计数排序是稳定的排序： 输入输出数组中相同值的顺序不变.