内排序—数组实现（c++）

参考资料：数据结构与算法分析（第三版）（c++）  
          http://blog.csdn.net/theprinceofelf/article/details/6672677  
            
            
            
            
    内排序，均采用数组实现，数组有较多的局限性，这些实现是为了去了解排序算法  
的操作流程  
  
#include<iostream>  
using namespace std;  
  
void Swap(int &a,int &b);  
void Print(int *array,int n);  
void BubbleSort(int *array,int n);   
void InsertSort(int *array,int n);   
void ShellSort(int *array,int n);  
void RadixSort(int *array,int n,int k,int r,int *cnt,int *B);  
void QuickSort(int Left,int Right,int *array);   
int FindPos(int Left,int Right);  
int Parttion(int Left,int Right,int& pos,int *A);  
void MergeSort(int Left,int Right,int *array,int *B);  
void ShellSort(int *array,int n);  
void IssSort(int *array,int n,int temp);  
void HeapSort(int *array,int n);  
void HeapAdjust(int *array,int high,int low);  
int main()  
{  
    int n=20;  
    int arry[n]={12,45,78,2,3,45,12,47,36,5,112,1178,14,20,10,58,74,65,24,17};  
    //这两个数组主要是在用数组实现基数排序过程中要使用到   
    int cnt[n];  
    int B[n];  
      
    printf("要进行排序的数组为：\n");  
    Print(arry,n);  
      
      
    printf("冒泡排序：\n");  
    BubbleSort(arry,n);  
    Print(arry,n);  
    printf("插入排序：\n");  
    InsertSort(arry,n);  
    Print(arry,n);  
    printf("基数排序：\n");  
    RadixSort(arry,n,4,10,cnt,B);  
    Print(arry,n);  
    printf("快速排序：\n");  
    QuickSort(0,n-1,arry);  
    Print(arry,n);  
    printf("归并排序：\n");  
    MergeSort(0,n-1,arry,B);  
    Print(arry,n);  
    printf("希尔排序：\n");  
    ShellSort(arry,n);  
    Print(arry,n);  
    printf("堆排序：\n");  
    HeapSort(arry,n);  
    Print(arry,n);  
    return 0;  
}  
  
  
  
void Swap(int &a,int &b)  
{  
    int temp=a;  
    a=b;  
    b=temp;  
}  
  
void Print(int *array,int n)  
{  
      
    for(int i=0;i<n;i++)  
    {  
        printf("%d\t",array[i]);  
    }  
    printf("\n\n");  
}  
  
//冒泡排序的时间复杂度为n^2，稳定   
void BubbleSort(int *array,int n)  
{  
    for(int i=0;i<n;i++)  
    {  
        //for(int j=n-i;j>0;j--)  //这个是从最后一位开始进行冒泡排序，比较直观   
        for(int j=0;j<n-1-i;j++)  
        {  
            if(array[j]>array[j+1])  
            {  
                Swap(array[j],array[j+1]);  
            }  
        }  
    }  
}  
   
//插入排序的实现   
void InsertSort(int *array,int n)  
{  
    for(int i=1;i<n;i++)  
    {  
        for(int j=i;j>0;j--)  
        {  
            if(array[j]<array[j-1])  
            {  
                Swap(array[j],array[j-1]);  
            }  
        }  
    }  
}  
  
  
   
//基数排序的数组实现的过程  
 /*参数的意义：三个数组为交换过程中的使用，标记位置过程的使用，原数组 
 K为要进行排序的数组中数字的最大位数，r为进制*/   
void RadixSort(int *array,int n,int k,int r,int *cnt,int *B)  
{  
    int j;  
      
    for(int i=0,rtoi=1;i<k;i++,rtoi*=r)  
    {  
        for(j=0;j<r;j++)  
        {  
            cnt[j]=0;  
        }  
        for(j=0;j<n;j++)  
        {  
            cnt[(array[j]/rtoi)%r]++;  
        }  
        for(j=1;j<r;j++)  
        {  
            cnt[j]=cnt[j]+cnt[j-1];  
        }  
        for(j=n-1;j>=0;j--)  
        {  
            //式子中所要表达的就是进行取余，从最低位开始进行   
            B[--cnt[(array[j]/rtoi)%r]]=array[j];  
        }  
        for(j=0;j<n;j++)  
        {  
            array[j]=B[j];  
        }  
    }  
}  
  
  
  
//快速排序实现，选择轴值在中间，但是在极端情况下，轴值在首位或者末尾均可  
//快速排序的优化有许多的方式，可以用堆栈代替递归，子数组在排序时长度的选择均可以进行优化   
void QuickSort(int Left,int Right,int *A)  
{  
   if (Left >= Right)  
    {  
        return;  
    }  
    //将轴值放在数组的最后  
    int pos = FindPos(Left, Right);  
    Swap(pos, Right);  
    // Left-1这个位置在数组的下界之前，目的是为了防止溢出  
    int k = Parttion(Left - 1, Right, A[Right],A);  
    Swap(k, Right);  
    QuickSort(Left, k - 1,A);  
    QuickSort(k + 1, Right,A);  
}  
  
  
int FindPos(int Left, int Right)  
{  
    return (Left + Right) /2;  
}  
  
  
int Parttion(int Left, int Right, int& pos,int *A)  
{  
    int i = Left;  
    int j = Right;  
    do  
    {  
        while ((pos>=A[Left])&&(Left<Right))  
        {  
            Left++;  
        }  
        //此处Left<Right保证了当轴值为子数组的最小值（即分隔出来以后左半部分的长度为0）不会越界  
        while ((Left < Right) && (pos <=A[Right]))  
        {  
            Right--;  
        }  
        Swap(Left, Right);  
    } while (Left < Right);  
    return Left;  
}  
  
  
  
//归并排序的实现：    
void MergeSort(int Left,int Right,int *array,int *B)  
{  
    if(Left==Right)  
    {  
        return;  
    }  
    int mid=(Left+Right)/2;  
    MergeSort(Left,mid,array,B);  
    MergeSort(mid+1,Right,array,B);  
    //复制到数组B中进行操作   
    for(int i=Left;i<=Right;i++)  
    {  
        B[i]=array[i];  
    }  
      
    int i=Left,j=mid+1;  
    for(int k=Left;k<=Right;k++)  
    {  
        //左侧数组是否已经用完   
        if(i==mid+1)  
        {  
            array[k]=B[j++];  
        }  
        //右侧数据是否用完   
        else if(j>Right)  
        {  
            array[k]=B[i++];  
        }  
        //均未用完，则需要进行比较归位   
        else if(B[i]<B[j])  
        {  
            array[k]=B[i++];  
        }  
        else  
        {  
            array[k]=B[j++];  
        }  
    }  
}  
  
  
//希尔排序的实现  
//希尔排序的最后一轮处理其实就是插入排序   
void ShellSort(int *array,int n)  
{  
    for(int i=n/2;i>2;i/=2)  
    {  
        for(int j=0;j<i;j++)  
        {  
            IssSort(&array[j],n-j,i);  
        }  
        //最后一次处理为插入排序。所以增量为1   
        IssSort(array,n,1);  
    }  
}  
  
  
  
void IssSort(int *array,int n,int temp)  
{  
    for(int i=temp;i<n;i+=temp)  
    {  
        for(int j=i;(j>=temp)&&(array[j]<array[j-temp]);j-=temp)  
        {  
            Swap(array[j],array[j-temp]);  
        }  
    }  
}  
  
  
  
  
//堆排序的实现  
void HeapSort(int *array,int n)  
{  
    for(int i=n/2-1;i>=0;--i)  
    {  
        HeapAdjust(array,i,n-1);  
    }  
    for(int i=n-1;i>0;--i)  
    {  
        Swap(array[0],array[i]);  
        HeapAdjust(array,0,i-1);  
    }  
}  
  
  
  
void HeapAdjust(int *array,int low,int high)  
{  
    int temp=array[low];  
    for(int i=low*2+1;i<=high;i*=2)  
    {  
        if(i<high&&array[i]<=array[i+1])  
        {  
            ++i;  
        }  
        if(array[i]<=temp)  
        {  
            break;  
        }  
        array[low]=array[i];  
        low=i;  
    }  
    array[low]=temp;  
}