排序算法

1. 冒泡排序

　　两两比较相邻元素，逆序则交换，外层循环意思是总共要经过n-1轮冒泡，第i轮过后，第n-i个元素总是前n-i个数中的最大，所以按如下代码进行内外循环。

int* bubbleSort(int* A, int n) {
        // write code here
        for(int i=n-1;i>=0;i--)
            for(int j=0;j<i;j++)
            {
                if(A[j+1]<A[j])
                {
                    int temp=A[j];
                    A[j]=A[j+1];
                    A[j+1]=temp;
                }
            }
        return A;
    }

 1. 选择排序

　　从i=0开始，内循环先找出第i+1到n-1中最小的数的下标，然后跟a[i]交换，保证每一次大循环后，a[i]都是[i,n-1]中的最小，因此最后一次循环为[i,n-1]只有两个元素的时候。代码如下：

int* selectionSort(int* A, int n) {
        // write code here
        for(int i=0;i<n-1;i++)
        {
            int mini=i;
            for(int j=i+1;j<n;j++)
            {
                mini=A[mini]>A[j]?j:mini;
            }
            if(mini!=i)
            {
                int temp=A[mini];
                A[mini]=A[i];
                A[i]=temp;
            }
        }
        return A;
    }

 3. 插入排序

 　　插入排序思想是，记[0,i]是有序的，则在[0,i]中倒着查找插入第i+1个元素。

 int* insertionSort(int* A, int n) {
        // write code here
        for(int i=1;i<n;i++)
        {
            int temp=A[i];
            int j=i-1;
            while(j>=0&&temp<A[j])
            {
                A[j+1]=A[j];
                j--;
            }
            A[j+1]=temp;
        }
        return A;
    }

4.归并排序

　　归并排序关键点在于把两个有序数组融合起来的merge函数，通过不断划分子问题，用分治的思想，把一个大的数组分成两部分，每一部分再分成两部分，递归直到分到两个子数组都只有一个元素，自然这个子数组就是有序的，再把这样的两个子数组归并起来，自然得到规模为2的有序子数组，以此类推，最后归并成一个大的数组。

class MergeSort {
public:
    int* mergeSort(int* A, int n) {
        // write code here
        mergeSort(A,0,n-1);
        return A;
    }
    
    void mergeSort(int* A, int left, int right)
    {
        if(left==right)
            return;
        int mid=(left+right)/2;
        mergeSort(A,left,mid);
        mergeSort(A,mid+1,right);
        merge(A,left,mid,right);
        return;
    }
    
    void merge(int* A,int left,int mid,int right)
    {
        int* temp=new int[right-left+1];
        int l=left;
        int r=mid+1;
        int k=0;
        while(l<=mid&&r<=right)
        {
            if(A[l]<=A[r])
            {
                temp[k++]=A[l++];
            }
            else
                temp[k++]=A[r++];
        }
        while(l<=mid)
            temp[k++]=A[l++];
        while(r<=right)
            temp[k++]=A[r++];
        for(int i=0;i<k;i++)
            A[left+i]=temp[i];
    }
};

 5. 快排

　　其基本思想是：

　　1. 分治法： 在 quickSort(A, 0,n-1) 中调用 quickSort(A, left,mid-1) 和 quickSort(A, mid+1,right) ，其中mid为枢纽所在的位置。

　　2. 在数组中随机选择一个枢纽作为基准，将其放到数组的最右边后，遍历数组，将比其小的数放在其左边，大于其的数放在其右边。

　　3. mid = partition(A,left,right) 该函数的思想是，用 int pivot = left-1; 指向小于枢纽的数的最后一个元素的位置，然后遍历该数组，最后返回 pivot 表示枢纽所在的位置。

class QuickSort {
public:
    int* quickSort(int* A, int n) {
        // write code here
        if(A==nullptr&&n<2)
            return A;
        srand((unsigned(time(NULL))));
        return quickSort(A, 0,n-1);
    }
    
    int* quickSort(int* A, int left, int right){
        if(left<right)
        {
            int random = left+rand()%(right-left+1);
            int temp=A[random];
            A[random]=A[right];
            A[right]=temp;
            int mid = partition(A,left,right);
            quickSort(A, left,mid-1);
            quickSort(A, mid+1,right);
        }
        return A;
    }
    
    int partition(int* A, int left, int right)
    {
        int pivot = left-1;
        int index = left;
        while(index <= right)
        {
            if(A[index] <= A[right])
            {
                ++pivot;
                int temp = A[index];
                A[index] = A[pivot];
                A[pivot]= temp;
            }
            index++;
        }
        return pivot;
    }
};

 6. 堆排序

 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。其思路如下：

　a.将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;

　b.将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;

　c.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。

参考链接：https://www.cnblogs.com/chengxiao/p/6129630.html

class HeapSort {
public:
    void swap(int* A,int i,int j)
    {
        int temp = A[i];
        A[i] = A[j];
        A[j] = temp;
    }
    
    void adjustHeap(int* A, int n, int left, int right)
    {
        int parent = left;
        int maxChild = 2 * parent + 1;
        int value = A[parent];
        
        while(maxChild <= right)
        {
            maxChild = A[maxChild + 1] > A[maxChild] && maxChild < right ? maxChild + 1: maxChild;
            if( value < A[maxChild])
            {
                A[parent] = A[maxChild];
                parent = maxChild;
                maxChild = 2 * parent + 1;
            }
            else
                break;
        }
        A[parent] = value;
        
    }
    int* heapSort(int* A, int n) {
        // write code here
       for(int i = n/2-1; i>=0; i--)
           adjustHeap(A,n,i,n-1);
        for(int i = n-1; i >0; i--)
        {
            swap(A,i,0);
            adjustHeap(A,n,0,i-1);
        }
        return A;
    }
};

 7. 希尔排序

　　希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

class ShellSort {
public:
    int* shellSort(int* A, int n) {
        // write code here
        if(A==nullptr||n<2)
            return A;
        int inc = n/2;
        int index = 0;
        while(inc > 0)
        {
            for(int i = inc; i < n; i++)
            {
                index = i;
                while(index >= inc)
                {
                    if(A[index - inc] > A[index])
                    {
                        int temp = A[index - inc];
                        A[index - inc] = A[index];
                        A[index] = temp;
                        index -= inc;
                    }
                    else
                        break;
                }
            }
            inc /= 2;
        }
        return A;
    }
};

 8. 桶排序

class CountingSort {
public:
    void max_min(int* A, int n, int& max, int& min)
    {
        max = min = A[0];
        for(int i = 1; i < n; i++)
        {
            if(A[i]<min)
                min = A[i];
            else if(A[i]>max)
                max = A[i];
        }
    }
    
    int* countingSort(int* A, int n) {
        // write code here
        if(A == nullptr||n < 2)
            return A;
        int max, min;
        max_min(A,n,max,min);
        int* tong = new int[max - min + 1];
        for (int i = 0;i < max - min + 1;i++)        //清零
            tong[i] = 0;
        for(int i = 0; i < n; i++)                   //计数
            tong[A[i]-min]++;
        int index = 0;
        for(int i = 0; i< max-min+1; i++)
            while(tong[i] > 0)
            {
                A[index++] = i+min;
                tong[i]--;
            }
        return A;
    }
};