基本排序算法

typedef int datatype;

inline void swap(datatype &a, datatype &b)
{
    datatype tmp = a;
    a = b;
    b = tmp;
}

/***********************************
  冒泡排序:
  每次将最小的数"冒"在最前面 
***********************************/
void BubbleSort(datatype Array[], int length)
{
    for (int i = 0; i < length; i++)
    {
        for (int j = i+1; j < length; j++)
        {
            if (Array[j] < Array[i])
            {
                swap(Array[i], Array[j]);
            }
        }
    }
}

/*********************************** 
 插入排序
   从后往前依次插入元素 
***********************************/
void InsertSort(datatype Array[], int length)
{

    for(int j = 1; j  != length; j++)  
    {  
        datatype key = Array[j];  
        int i = j - 1;  
        while(i != -1 && Array[i] > key)  
        {  
            Array[i+1]= Array[i];  
            i--;  
        }  
         
        Array[i+1] = key;  
    }  

}

/*********************************** 
 归并排序
   分别对左右两边进行排序,然后合并,需要申请新的空间 
***********************************/ 
static void Merge(datatype SortArray[], int start, int middle, int end)  
{  
    int LeftLength = middle - start + 1;  
    int RightLength = end - middle;  
  
    // 创建临时数组保存已排序好的左右数组   
    datatype *LeftArray = (datatype *)malloc(LeftLength * sizeof(datatype));  
    for(int i = 0; i != LeftLength; ++i)  
        LeftArray[i] = SortArray[start + i];  
    datatype *RightArray = (datatype *)malloc(RightLength * sizeof(datatype));  
    for(int i = 0; i != RightLength; ++i)  
        RightArray[i] = SortArray[middle + i + 1];  
 
    // 归并   
    int i = 0;  
    int j = 0;  
    int k = start;  
    while(i != LeftLength && j != RightLength)  
    {  
        if(LeftArray[i] <= RightArray[j])  
            SortArray[k++] = LeftArray[i++];  
        else  
            SortArray[k++] = RightArray[j++];  
    }  
  
    while(i != LeftLength)  
    {  
        SortArray[k++] = LeftArray[i++];      
    }  
  
    while(j != RightLength)  
    {  
        SortArray[k++] = RightArray[j++];  
    }  
  
    free(LeftArray);  
    free(RightArray);  
}  

static void _MergeSort(datatype Array[], int start, int end)
{
    if (start < end)
    {
        int middle = (start + end)/2;
        _MergeSort(Array, start, middle);
        _MergeSort(Array, middle+1, end);
        Merge(Array, start, middle, end);
    }
}

void MergeSort(datatype Array[], int length)
{
    _MergeSort(Array, 0, length -1);
}

/*********************************** 
    快速排序算法,和归并排序相比,快速排序不需要额外的空间
***********************************/
// 将数组划分为2组,左边的都比中间元素小,右边的都比中间元素大
static int Partition(datatype SortArray[], int start, int end)  
{  
    datatype middleValue = SortArray[end];  
    int middleIndex = start - 1;  
  
   for(int j = start; j != end; ++j)  
    {  
        if (SortArray[j] <= middleValue)  
        {  
          middleIndex++;  
           swap(SortArray[middleIndex], SortArray[j]);  
        }  
          
    }  
    swap(SortArray[middleIndex+1], SortArray[end]);  
  
    return middleIndex+1;  
}  

static void _QuickSort(datatype SortArray[], int start, int end)  
{  
    if(start < end)  
    {  
        int middle = Partition(SortArray, start, end);  
        _QuickSort(SortArray, start, middle-1);  
        _QuickSort(SortArray, middle+1, end);  
    }  
}  

void QuickSort(datatype SortArray[], int length)
{
    _QuickSort(SortArray, 0, length-1);    
}

/*********************************** 
 计数排序 
    计数排序的基本思想是对每一个输入元素x,确定 
 出不小于x的元素个数。 
    只适用于正整数 
***********************************/
static void _CountingSort(datatype SortArray[], datatype SortedArray[], int ArrayLength,datatype maxValue)  
{  
    datatype *CountArray  = (datatype *)malloc((maxValue+1) * sizeof(datatype)); 
    assert(NULL != CountArray);
  
    // 初始化   
    for(int i = 0; i != maxValue+1; ++i)  
        CountArray[i] = 0;  
  
    // 计数   
    for(int i = 0; i != ArrayLength; ++i)  
        CountArray[(SortArray[i])] += 1;    // 等于的元素个数   
  
    /*
       若不考虑稳定性,可以使用以下代码,此时实际不需要SortedArray数组
        int index = 0;
        for (datatype i = 0; i <= maxValue; i++)
        {
            for (int j = 0; j < CountArray[i]; j++)
            {
                SortedArray[inddex++] = i; 
            }
        }

    */
    
    // 重排   
    /* 
    从大到小,可保持稳定性,即具有相同值的元素 
    在输出数组中的相对次序与他们在输入数组中的次序相同 
    */  
    for(int i = 1; i != maxValue+1; ++i)  
        CountArray[i] += CountArray[i-1];   // 小于或等于的个数   
   
    for(int i = ArrayLength-1; i != -1; --i)  
    {  
        // CountArray[SortArray[i]]：小于或等于SortArray[i]的个数,再-1即为排序后在数组中的位置
        SortedArray[(CountArray[(SortArray[i])]) - 1] = SortArray[i];   
        CountArray[(SortArray[i])] -= 1;  
          
    }  
  
    free(CountArray);  
}  

void CountingSort(datatype SortArray[], int length)
{
    datatype maxValue = 0;
    for (int i = 0; i < length; i++)
    {
        maxValue = maxValue > SortArray[i] ? maxValue : SortArray[i];
    }

    datatype *SortedArray = (datatype *)malloc(length * sizeof(datatype));
    assert(NULL !=SortedArray);

    _CountingSort(SortArray, SortedArray, length, maxValue);

    for (int i = 0; i < length; i++)
    {
        SortArray[i] = SortedArray[i];
    }

    free(SortedArray);

}

/***********************************
 基数排序 
    利用计数排序算法,对数组从低向高位排序 
***********************************/
static void CountingSortForRadixSort(datatype SortArray[], datatype CmpArray[], int ArrayLength, int maxValue)  
{  
    datatype *CountArray  = (datatype *)malloc((maxValue+1) * sizeof(datatype));  
    datatype *SortedArray = (datatype *)malloc(ArrayLength * sizeof(datatype));  
    assert(NULL != CountArray || NULL != SortedArray);

    for(int i = 0; i != maxValue+1; ++i)  
        CountArray[i] = 0;  
      
    for(int i = 0; i != ArrayLength; ++i)  
        CountArray[(CmpArray[i])]++;  
    for(int i = 1; i != maxValue+1; ++i)  
        CountArray[i] += CountArray[i-1];  
  
    for(int i = ArrayLength-1; i != -1; --i)  
    {  
        SortedArray[(CountArray[CmpArray[i]])-1]= SortArray[i];  
        CountArray[CmpArray[i]] -= 1;  
    }  
  
    for(int i = 0; i != ArrayLength; ++i)  
        SortArray[i] = SortedArray[i];  
  
    free(CountArray);  
    free(SortedArray);  
      
}  

void RadixSort(datatype SortArray[], int ArrayLength)  
{  
    datatype *RadixArray = (datatype *)malloc(ArrayLength * sizeof(datatype)); 
    assert(NULL != RadixArray);
     
    datatype BaseNumber = 1;  
    bool rsIsOk = false;  
  
    while(false ==rsIsOk)  
    {  
        rsIsOk = true;  
        BaseNumber *= 10;  
  
        for(int i = 0; i != ArrayLength; ++i)  
        {  
            RadixArray[i] = SortArray[i] % BaseNumber;  
            RadixArray[i] = RadixArray[i] / (BaseNumber / 10);  
            if(RadixArray[i] > 0)  
                rsIsOk = false;  
        }  
        if(true == rsIsOk)  
            break;  
        CountingSortForRadixSort(SortArray, RadixArray, ArrayLength, 9);  
    }  
  
    free(RadixArray);  
}  
/***********************************
堆排序算法 
    堆: 可以视为一棵完全二叉树,树的每一层都是填满的,除了最后一层 
    其任何一非叶节点满足性质：
    Key[i]<=key[2i+1]&&Key[i]<=key[2i+2]或者Key[i]>=Key[2i+1]&&key>=key[2i+2]

    堆排序算法主要用于优先级队列 
***********************************/
#define PARENT(x)   ((x) >> 1)            // 节点x的父节点下标号   
#define LEFT(x)     ((x) << 1)            // 节点x的左子节点下标号   
#define RIGHT(x)    (((x) << 1) + 1)      // 节点x的右子节点下标号   
  
static void MaxHeapify(int SortArray[], int heap_size, int parent)  
{   
    int left, right, largest;  
  
    left = LEFT(parent+1) - 1;  
    right = RIGHT(parent+1) -1;  
  
    if(left < heap_size && SortArray[left] > SortArray[parent])  
        largest = left;  
    else  
        largest = parent;  
  
    if(right < heap_size && SortArray[right] > SortArray[largest])  
        largest = right;  
  
    if(largest != parent)  
    {  
        swap(SortArray[largest], SortArray[parent]);  
  
        MaxHeapify(SortArray, heap_size, largest);  
    }  
}  

static void BuildMaxHeap(int SortArray[], int ArrayLength)  
{  
    int HeapSize = ArrayLength;  
  
    for(int i = ArrayLength/2; i != -1; --i)  
        MaxHeapify(SortArray,HeapSize,i);  
} 

void HeapSort(int SortArray[], int ArrayLength)  
{  
    int HeapSize = ArrayLength;  
  
    BuildMaxHeap(SortArray, ArrayLength);  
    for(int i = ArrayLength-1; i !=0; --i)  
    {  
        swap(SortArray[0], SortArray[i]);  
        HeapSize--;  
        MaxHeapify(SortArray, HeapSize, 0);  
    }  
}