十种排序算法

十种排序算法

之前看了一个大牛的博客，太牛了，没啥好写的，推荐出来
https://www.cnblogs.com/onepixel/articles/7674659.html

自己实现

/*
 * sortfun.h
 *
 *  Created on: 2019年5月1日
 *      Author: Administrator
 */

#ifndef SORTFUN_H_
#define SORTFUN_H_

#include<vector>

// 1
void bubbleSort(int * a, int size)
{
    for(int i = 0; i < size -1; i++)
    {
        for(int j = 0; j < size - 1 - i; j++)
        {
            if(a[j] > a[j+1])
            {
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

// 2
void selectSort(int * a, int size)
{
    for(int i = 0; i < size -1; i++)
    {
        int max = a[0];
        int index = 0;
        for(int j = 1; j < size  - i; j++)
        {
            if(a[j] > max)
            {
                max = a[j];
                index = j;
            }
        }
        a[index] = a[size - i - 1];
        a[size - i - 1] = max;


    }
}


// 3
void insertSort(int * a, int size)
{
    for(int i = 1; i < size ; i++)
    {
        int index = i;
        for(int j = i - 1; j >= 0; j--)
        {
            if(a[index] < a[j])
            {
                int temp = a[index];
                a[index] = a[j];
                a[j] = temp;
                index--;
            }
            else
                break;
        }
    }
}


// 4
void merge(int a[], int left, int right)
{
    int b[right - left +1] = {0};
    int indexb = 0;
    int indexb2 = 0;
    if(left == right)
        b[0] = a[left];
    if(left < right)
    {
        int tempindex = (left + right)/2;
        int index1 = left, index2 = tempindex + 1;
        while(index1 <= tempindex && index2 <= right)
        {
            if(a[index1] < a[index2])
                b[indexb++] = a[index1++];
            else
                b[indexb++] = a[index2++];
        }
        for(;index1 <= tempindex; index1++)
            b[indexb++] = a[index1];
        for(;index2 <= right; index2++)
            b[indexb++] = a[index2];
    }
    for(int i = left; i <= right; i++)
        a[i] = b[indexb2++];
}


void mergesort(int a[], int left, int right)
{
    if(left < right)
    {
        int tempindex = (left + right)/2;
        mergesort(a, left, tempindex);
        mergesort(a, tempindex+1, right);
        merge(a, left, right);
    }
    else
        return;
}

// 5
void swap(int *a, int index1, int index2)
{
    int temp = a[index1];
    a[index1] = a[index2];
    a[index2] = temp;
}

void adjust(int * a, int size, int index)
{
    int largest = a[index];
    if((2*index + 1) < size)
    {
        int light = a[2*index + 1];
        if(largest < light)
        {
            swap(a, index, 2*index + 1);
            adjust(a, size, 2*index + 1);
        }
    }
    if((2*index + 2) < size)
    {
        int right = a[2*index + 2];
        if(largest < right)
        {
            swap(a, index, 2*index + 2);
            adjust(a, size, 2*index + 2);
        }
    }
}
void buildHeap(int * a, int size)
{
    for(int i = size/2 - 1; i >= 0; i--)
    {
        adjust(a, size, i);
    }
}

void heapSort(int * a, int size)
{
    buildHeap(a, size);
    int len =size;
    for(int i = size - 1; i >= 1; i--)
    {
        swap(a, 0, i);
        len--;
        adjust(a, len, 0);
    }
}

// 6
void countingSort(int * a, int size)
{
    int min = a[0], max = a[0];
    for(int i = 1; i < size; i++)
    {
        if(a[i] > max)
            max = a[i];
        if(a[i] < min)
            min = a[i];
    }

    int b[max - min + 1] = {0};
    for(int i = 0; i < size; i++)
    {
        b[a[i] - 1]++;
    }
    int index = 0;
    for(int i = 0; i < max - min + 1; i++)
    {
        while(b[i] > 0)
        {
            a[index++] = i + 1;
            b[i]--;
        }
    }



}

// 7
void radixSort(int * a, int size)
{

    int max = a[0];
    for(int i = 1; i < size; i++)
    {
        if(a[i] > max)
            max = a[i];
    }
    int radixlen = 1;
    while(max/10 > 0)
    {
        radixlen++;
        max = max/10;
    }

    std::vector<std::vector<int>> radixarr(10);

    for(int i = 1; i <= radixlen; i++)
    {
        for(int j = 0; j < size; j++)
        {
            radixarr[a[j]%(10 * i)].push_back(a[j]);
        }
    }
}

#endif /* SORTFUN_H_ */