排序算法

 

一、直接插入排序

在要排序的一组数中，假设前面（n-1）个数已经有序，现在要把第n个数插到前面的有序数中，

使得这n个数也是有序的。如此反复循环，直到全部有序。

/*void swap(int arr[],int i,int j)
{
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

void show(int arr[],int len)
{
    for(int i=0;i<len;i++)
    {
        cout<<arr[i]<<" ";
    }
    cout<<endl;
}
*/
//插入排序
void InsertSort(int arr[],int len)
{
    if(arr == NULL || len < 2)
        return;
    int j = 0;
    int i = 0;
    int temp = 0;
    for(i=1; i<len;i++)
    {
        temp = arr[i];
        for(j=i-1;j>=0&&temp<arr[j];j--)
        {
            arr[j+1] = arr[j];
        }
        arr[j+1] = temp;
    }
}

二、shell排序

先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d。

对每组中全部元素进行直接插入排序，然后再用一个较小的增量对它进行分组，在每组中

再进行直接插入排序。

当增量减到1，进行直接插入排序后，排序完成。

void ShellSort(int arr[],int len)
{
    int j = 0;
    int temp = 0;
    for(int dk=len/2;dk>0;dk /= 2)
    {
        for(int i=dk;i<len;i++)
        {
            temp = arr[i];
            for(j=i-dk;j>=0 && arr[j]>arr[j+dk];j -= dk)
            {
                arr[j+dk] = arr[j];
            }
            arr[j+dk] = temp;
        }
    }
}

三、直接选择排序

在要排序的一组数中，选出最小的一个数与第一个位置的数交换，然后在剩下的数当中

再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止

 void SelectSort(int arr[],int len)
 {
     if(arr == NULL || len < 2)
         return;
     for(int i=0;i<len-1;i++)
     {
         int minIndex = i;
         for(int j=i+1;j<len;j++)
         {
            minIndex = arr[j]<arr[minIndex] ? j : minIndex;
         }
            swap(arr,i,minIndex);
      }
}

四、堆排序

堆排序是一种树形选择排序，是对直接选择排序的优化。

void HeapAdjust(int* arr,int begin,int end)
{
    int i = begin;
    int j = 2*i+1;
    int tmp = arr[i];
    
    while(j <= end)
    {
        if(j < end && arr[j+1] > arr[j])
        {
            j++;
        }
        if(tmp > arr[j])
        {
            break;
        }
        arr[i] = arr[j];
        i = j;
        j = 2*i+1;
    }
    arr[i] = tmp;
}
void HeapSort(int arr[],int len)
{
    int tmp;
    int i;
    
    for(i = (len-2)/2; i>=0; i--)
    {
        HeapAdjust(arr,i,len-1);
    }
    
    for(int k = len-1; k>0; k--)
    {
        tmp = arr[0];
        arr[0] = arr[k];
        arr[k] = tmp;
        HeapAdjust(arr,0,k-1);
    }
}

五、冒泡排序

void BubbleSort(int arr[],int len)
{
    for(int i=0;i<len-1;i++)
        for(int j=0;j<len-i-1;j++)
        {
            if(arr[j]>arr[j+1])
                swap(arr,j,j+1);
        }
}

六、快排

int Parition(int* arr,int low,int high)
{
    int tmp = arr[low];
    
    while (low < high)
    {
        while(low < high && arr[high] >= tmp)
            high--;
        arr[low] = arr[high];
        while(low < high && arr[low] <= tmp)
            low++;
        arr[high] = arr[low];
    }
    arr[low] = tmp;
    return low;
}

void QuickSort(int* arr,int low,int high)
{
    if (low < high)
    {
        int boundkey = Parition(arr,low,high);
        QuickSort(arr,low,boundkey-1);
        QuickSort(arr,boundkey+1,high);
    }
    
}
void Quick(int* arr,int len)
{
    QuickSort(arr,0,len-1);
}

七、归并排序

void SortProcess(int arr[],int left,int right,int help[]);
void Merge(int arr[],int left,int mid,int right,int help[]);
void MergeSort(int arr[],int len)
{
    if(arr == NULL || len < 2)
        return;
    int *help = new int[len];
    SortProcess(arr,0,len-1,help);
    delete[] help;
}
void SortProcess(int arr[],int left,int right,int help[])
{
    if(left==right)
        return;
    int mid = (left+right)/2;
    SortProcess(arr,0,mid,help);
    SortProcess(arr,mid+1,right,help);
    Merge(arr,left,mid,right,help);
}
void Merge(int arr[],int left,int mid,int right,int help[])
{
    int help_len = right-left+1;
    int i = 0;
    int p1 = left;
    int p2 = mid+1;
    while(p1<=mid && p2<=right)
    {
        help[i++] = arr[p1]<arr[p2] ? arr[p1++] : arr[p2++];
    }
    while(p1<=mid)
    {
        help[i++] = arr[p1++];
    }
    while(p2<=right)
    {
        help[i++] = arr[p2++];
    }
    for(i=0;i<help_len;i++)
    {
        arr[left+i] = help[i];
    }
}

 八、基数排序

int Find_fin_num(int num,int fin)
{
    return num / (int)pow(10.0,fin)  % 10;
}

void RadixSort(int* arr,int len,int fin)
{
    int bucket[10][N] = {0};
    int count[10] = {0};

    for (int i=0; i<len; i++)
    {
        int fin_num = Find_fin_num(arr[i],fin);
        bucket[fin_num][count[fin_num]] = arr[i];
        count[fin_num]++;
    }

    int Index = 0;
    for (int i=0; i<10; i++)
    {
        for (int j=0; j<count[i]; j++)
        {
            arr[Index++] = bucket[i][j];
        }
    }
}
int FindMaxPos(int* arr,int len)
{
    int max = arr[0];
    int count = 0;
    for (int i=0; i<len; i++)
    {
        if (arr[i] > max)
        {
            max = arr[i];
        }
    }

    while(max != 0)
    {
        max = max/10;
        count++;
    }
    return count;
}

void radix(int* arr,int len)
{
    int max_pos = FindMaxPos(arr,len);
    for (int i=0; i < max_pos; i++)
    {
        RadixSort(arr,len,i);
    }
}