排序

　　堆排序

#include<stdio.h>
#include<iostream>
using namespace std;


void print(int a[], int n){  
    for(int j= 0; j<n; j++){  
        cout<<a[j] <<"  ";  
    }  
    cout<<endl;  
}  
  
  
  
/** 
 * 已知H[s…m]除了H[s] 外均满足堆的定义 
 * 调整H[s],使其成为大顶堆.即将对第s个结点为根的子树筛选,  
 * 
 * @param H是待调整的堆数组 
 * @param s是待调整的数组元素的位置 
 * @param length是数组的长度 
 * 
 */  
void HeapAdjust(int H[],int s, int length)  
{  
    int tmp  = H[s];  
    int child = 2*s+1; //左孩子结点的位置。(i+1 为当前调整结点的右孩子结点的位置)  
    while (child < length) {  
        if(child+1 <length && H[child]<H[child+1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的孩子结点)  
            ++child ;  
        }  
        if(H[s]<H[child]) {  // 如果较大的子结点大于父结点  
            H[s] = H[child]; // 那么把较大的子结点往上移动，替换它的父结点  
            s = child;       // 重新设置s ,即待调整的下一个结点的位置  
            child = 2*s+1;  
        }  else {            // 如果当前待调整结点大于它的左右孩子，则不需要调整，直接退出  
             break;  
        }  
        H[s] = tmp;         // 当前待调整的结点放到比其大的孩子结点位置上  
    }  
    print(H,length);  
}  
  
  
/** 
 * 初始堆进行调整 
 * 将H[0..length-1]建成堆 
 * 调整完之后第一个元素是序列的最小的元素 
 */  
void BuildingHeap(int H[], int length)  
{   
    //最后一个有孩子的节点的位置 i=  (length -1) / 2  
    for (int i = length/2 -1 ; i >= 0; --i)  
        HeapAdjust(H,i,length);  
}  
/** 
 * 堆排序算法 
 */  
void HeapSort(int H[],int length)  
{  
    //初始堆  
    BuildingHeap(H, length);  
    //从最后一个元素开始对序列进行调整  
    for (int i = length - 1; i > 0; --i)  
    {  
        //交换堆顶元素H[0]和堆中最后一个元素  
        int temp = H[i]; H[i] = H[0]; H[0] = temp;  
        //每次交换堆顶元素和堆中最后一个元素之后，都要对堆进行调整  
        HeapAdjust(H,0,i);  
  }  
}   
  
int main(){  
    int H[10] = {3,1,5,7,2,4,9,6,10,8};  
    cout<<"初始值：";  
    print(H,10);  
    HeapSort(H,10);  
    //selectSort(a, 8);  
    cout<<"结果：";  
    print(H,10);  
  
}  

 基数排序

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

typedef struct node
{
    int nValue;
    struct node *pNext;
}MyRadix;

void Sort(int arr[],int nLength,int nBase)
{
    int nNum = 1;
    MyRadix **pRadix = NULL;
    int i;
    int nIndex;
    MyRadix  *pTemp = NULL;
    MyRadix *pMark = NULL;

    //求被除数
    while(nBase > 1)
    {
        nNum*=10;
        nBase--;
    }

    //申请桶
    pRadix = (MyRadix**)malloc(sizeof(MyRadix*) * 10);
    memset(pRadix,0,sizeof(MyRadix*) * 10);

    for(i = 0;i<nLength;i++)
    {
        nIndex = arr[i]/nNum%10;

        pTemp = (MyRadix*)malloc(sizeof(MyRadix));
        pTemp->nValue = arr[i];
        pTemp->pNext = NULL;

        //尾添加
        if(pRadix[nIndex] == NULL)
        {
            pRadix[nIndex] = pTemp;
        }
        else
        {
            pMark = pRadix[nIndex];
            while(pMark->pNext != NULL)
            {
                pMark = pMark->pNext;
            }
            pMark->pNext = pTemp;
        }
    }

    //将元素放回原数组
    nBase = 0;
    for(i = 0;i<10;i++)
    {
        pMark = pRadix[i];
        while(pMark)
        {
            arr[nBase] = pMark->nValue;
            nBase++;
            pMark = pMark->pNext;
        }
    }

    //释放空间
    for(i = 0;i<10;i++)
    {
        pMark = pRadix[i];
        while(pMark)
        {
            pTemp = pMark;
            pMark = pMark->pNext;
            free(pTemp);
            pTemp = NULL;
        }
    }

    free(pRadix);
    pRadix = NULL;
}

void RadixSort(int arr[],int nLength)
{
    int nMax;
    int i;
    int nLoopTimes;
    if(arr == NULL || nLength <=0)return;
    
    //找最大值
    nMax = arr[0];
    for(i = 1;i<nLength;i++)
    {
        if(arr[i] > nMax)
        {
            nMax = arr[i];
        }
    }
    //获得入桶次数
    nLoopTimes = 0;
    while(nMax)
    {
        nMax/=10;
        nLoopTimes++;
    }

    //各个位入桶
    for(i = 1;i<=nLoopTimes;i++)
    {
        //当前位入桶
        Sort(arr,nLength,i);
    }

}

int main()
{
    int arr[] = {24,23,34,270,18,29,110,220,19,46,32};
    int i;
    RadixSort(arr,sizeof(arr)/sizeof(arr[0]));
    for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d  ",arr[i]);
    }
    return 0;
}

桶排序

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

typedef struct node
{
    int nValue;
    struct node *pPre;
    struct node *pNext;
}MyBucket;

//创建桶
MyBucket **CreateBucket(int arr[],int nLength,int *pSize)
{
    int nMax;
    int nMin;
    int nMaxIndex;
    int nMinIndex;
    int i;
    int nNum;
    int nIndex;
    MyBucket *pTemp = NULL;
    MyBucket **pBucket = NULL;

    if(arr == NULL || nLength <=0)return NULL;

    //查询最大值最小值
    nMax = arr[0];
    nMin = arr[0];
    for(i = 1;i<nLength;i++)
    {
        if(arr[i] > nMax)
        {
            nMax = arr[i];
        }
        if(arr[i] < nMin)
        {
            nMin = arr[i];
        }
    }

    //计算位数
    nNum = nMax;
    i = 0;
    while(nNum >0)
    {
        i++;
        nNum/=10;
    }

    //计算被除数
    nNum = 1;
    while(i >1)
    {
        nNum*=10;
        i--;
    }

    //根据最大值最小值建桶
    nMaxIndex = nMax/nNum;
    nMinIndex = nMin/nNum;
    *pSize = nMaxIndex-nMinIndex+1;

    pBucket = (MyBucket**)malloc(sizeof(MyBucket*)*(nMaxIndex-nMinIndex+1));
    memset(pBucket,0,sizeof(MyBucket*)*(nMaxIndex-nMinIndex+1));

    for(i = 0;i<nLength;i++)
    {
        nIndex = arr[i]/nNum - nMinIndex;

        pTemp = (MyBucket*)malloc(sizeof(MyBucket));
        pTemp->nValue = arr[i];
        pTemp->pPre = NULL;

        //双向链表头添加
        pTemp->pNext = pBucket[nIndex];

        if(pBucket[nIndex] != NULL)
        {
            pBucket[nIndex]->pPre = pTemp;
        }

        pBucket[nIndex] = pTemp;
    }

    return pBucket;    
}

void Sort(MyBucket *pHead)
{
    MyBucket *pLast= NULL; //有序的最后一个
    MyBucket *pFirst = NULL; //无序的第一个
    int nNum;

    pFirst = pHead->pNext;

    while(pFirst != NULL)
    {
        //有序数组的最后一个 是无序数组的前一个
        pLast = pFirst->pPre;

        //标记待插入值
        nNum = pFirst->nValue;

        //将无序元素放入有序数组
        while(pLast != NULL && pLast->nValue > nNum)
        {
            pLast->pNext->nValue = pLast->nValue;
            pLast = pLast->pPre;
        }

        //到达链表头的情况
        if(pLast == NULL)
        {
            pHead->nValue = nNum;
        }
        else
        {
            pLast->pNext->nValue = nNum;
        }

        pFirst = pFirst->pNext;
    }
}
void BucketSort(int arr[],int nLength)
{
    MyBucket **pBucket = NULL;
    int i;
    int nSize;
    int j;
    MyBucket *pMark = NULL;
    MyBucket *pDel = NULL;

    if(arr == NULL || nLength <=0)return;

    pBucket = CreateBucket(arr,nLength,&nSize);

    //各桶内进行排序
    for(i = 0;i<nSize;i++)
    {
        if(pBucket[i] != NULL)
        {
            Sort(pBucket[i]);
        }
    }

    //元素放回原数组
    j = 0;
    for(i = 0;i<nSize;i++)
    {
        pMark = pBucket[i];
        while(pMark)
        {
            arr[j] = pMark->nValue;
            pMark = pMark->pNext;
            j++;
        }
    }
    //空间释放
    for(i = 0;i<nSize;i++)
    {
        pMark = pBucket[i];
        while(pMark)
        {
            pDel = pMark;
            pMark = pMark->pNext;
            free(pDel);
            pDel = NULL;
        }
    }

    free(pBucket);
    pBucket = NULL;
}


int main()
{
    int arr[] = {150,234,343,270,128,239,110,220,119,246,342};
    int i;
    BucketSort(arr,sizeof(arr)/sizeof(arr[0]));
    for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d  ",arr[i]);
    }
    return 0;
}