某天發現一個神奇的網站https://visualgo.net/en，對於學習各個算法非常有用，它將算法的步驟可視化，能很好地幫助我們理解。

　　順序為從小到大。

　　1，冒泡排序

　　從頭到尾兩兩比較，如果前者比後者大就交換，重復這個過程，直到不需要交換。

　　visualgo偽代碼：

do

  swapped = false

  for i = 1 to indexOfLastUnsortedElement-1

    if leftElement > rightElement

      swap(leftElement, rightElement)

      swapped 
 
= true

while swapped

　　UE4中C++實現：

void Atest::BubbleSort(TArray<int>& _array)
{
    bool swapped = false;
    do 
    {
        swapped = false;
        for (int i = 0; i < _array.Num() - 1; i++)
        {
            if (_array[i] > _array[i + 1])
            {
                int
 
 temp = _array[i];
                _array[i] = _array[i + 1];
                _array[i + 1] = temp;
                swapped = true;
            }
        }

    } while (swapped);
}

2，選擇排序

　　從待排序序列中選中最小的元素，與待排序序列第一個元素交換，重復n-1次該過程。

　　visualgo偽代碼：

repeat (numOfElements - 1) times

  set the first unsorted element as
 
 the minimum

  for each of the unsorted elements

    if element < currentMinimum

      set element as new minimum

  swap minimum with first unsorted position

　　UE4中C++實現：

void Atest::SelectSort(TArray<int>& _array)
{
    for (int i = 0; i < _array.Num() - 1; i++)
    {
        int min = _array[i];
        int minIndex = i;
        for (int j = i; j < _array.Num(); j++)
        {
            if (_array[j] < min)
            {
                min = _array[j];
                minIndex = j;
            }
        }
        int temp = _array[i];
        _array[i] = _array[minIndex];
        _array[minIndex] = temp;
    }
}

3，快速排序

 //快速排序
    void QuickSort(int[] _sortArray)
    {
        qSort(_sortArray, 0, _sortArray.Length - 1);
    }
    void qSort(int[] _sortArray,int low,int high)
    {
        if (low < high)
        {
            int pivot = partition(_sortArray, low, high);        //將數組分為兩部分
            qSort(_sortArray, low, pivot - 1);                   //遞歸排序左子數組
            qSort(_sortArray, pivot + 1, high);                  //遞歸排序右子數組
        }
    }
    int partition(int[] _sortArray,int low,int high)
    {
        int pivot = _sortArray[low];     //樞軸記錄
        while (low < high)
        {
            while (low < high && _sortArray[high] >= pivot) --high;
            _sortArray[low] = _sortArray[high];             //交換比樞軸小的記錄到左端
            while (low < high && _sortArray[low] <= pivot) ++low;
            _sortArray[high] = _sortArray[low];           //交換比樞軸小的記錄到右端
        }
        //掃描完成，樞軸到位
        _sortArray[low] = pivot;
        //返回的是樞軸的位置
        return low;
    }

4，插入排序

　　插入排序算法有種遞歸的思想在裏面，它由N-1趟排序組成。初始時，只考慮數組下標0處的元素，只有一個元素，顯然是有序的。然後第一趟 對下標 1 處的元素進行排序，保證數組[0,1]上的元素有序；

第二趟 對下標 2 處的元素進行排序，保證數組[0,2]上的元素有序；

    void InsertionSort(int[]  _sortArray)
    {
        for(int i = 1;i < _sortArray.Length;++i)
        {
            int temp = _sortArray[i];
            int j;
            for(j = i;j < _sortArray.Length && temp < _sortArray[j-1];--j)
            {
                _sortArray[j] = _sortArray[j - 1];
            }
            _sortArray[j] = temp;
        }
    }

visualgo 各種算法的具體實現——排序篇