数据结构C语言描述 第七章 算法开始 排序

堆排序

使用堆排序 将一个数组变成堆 出队后成为一个有序数组

分而治之

#include "sort.h"

void MergeSort(int arr[], int n)
{
    int* tmpArr = new int[n];
    int Boundary = n/2;
    int startNumber = 0;
    int endValue = Boundary;
    for (int z = 2; z !=0; z--)
    {
        for (int i = startNumber; i != endValue; i++)
        {
            for (int j = i; j!=startNumber; j--) {
                if (arr[j] < arr[j - 1])
                {
                    std::swap(arr[j], arr[j - 1]);
                }
            }

        }
        startNumber = Boundary;
        endValue = n;
    }
    //for (int i = 0; i < n; i++)
    //{
    //    std::cout << arr[i] << std::endl;
    //}
    startNumber = 0;
    for (int i = 0; i < n; )
    {
        if (startNumber == n / 2)
        {
            tmpArr[i++] = arr[Boundary++];

            continue;
        }
        else if (Boundary == n) {
            tmpArr[i++] = arr[startNumber++];
            continue;
        }
        int a = arr[startNumber];
        int b = arr[Boundary];
        if (a < b)
        {
            tmpArr[i] = a;
            startNumber++;
        }
        else if(a == b)
        {
            tmpArr[i++] = a;
            tmpArr[i++] = b;
            startNumber++;
            Boundary++;
            continue;
        }
        else
        {
            tmpArr[i] = b;
            Boundary++;
        }
     
        i++;
    }
    for (int i = 0; i < n; i++)
    {
        std::cout << tmpArr[i] << std::endl;
    }
    

    

}
void insertionSort(int* arr, int n)
{
    int i, p, tmp;
    for (p = 1; p<n ; p++)
    {
        tmp = arr[p];
        for (i = p; i > 0 && arr[i - 1] > tmp; i++)
        {
            arr[i] = arr[i - 1];
        }
        arr[i] = tmp;
    }
    
}


void Intswap(int* arr, int left, int right) {
    if (arr[right] < arr[right-1])
    {
        std::swap(arr[right], arr[right - 1]);
    }if (arr[right-1] < arr[right - 2])
    {
        std::swap(arr[right - 1],arr[right - 2]);
    }
}
void Qsort(int* arr, int left, int right)
{
    if (right - left == 2)
    {
        Intswap(arr, left, right-1);
        return;
    }
    else {
        int end = right;
        int hinge = threeSwap(arr, left, right - 1);
        int pivot = --right - 1;
        while (true)
        {
            while (arr[++left] < hinge) {}
            while (arr[--right] > hinge) {}
            if (left < right) {
                std::swap(arr[left], arr[right]);
            }
            else {
                std::swap(arr[pivot], arr[right]);
                break;
            }
        }

        Qsort(arr, 0, right + 1);
        Qsort(arr, right,end);
    }
    
}
int threeSwap(int* arr,int left,int right) {
    int center = (left+right)/2;
    
    if (arr[center] > arr[right])
    {
        std::swap(arr[center], arr[right]);
    }
    if (arr[left] > arr[center])
    {
        std::swap(arr[left], arr[center]);
    }
    if (arr[center] > arr[right])
    {
        std::swap(arr[center], arr[right]);
    }
    int centerValue = arr[center];
    std::swap(arr[center], arr[right - 1]);
    //for (int i = 0; i <= right; i++)
    //{
    //    std::cout << arr[i] << std::endl;
    //}
    return centerValue;
}
//void ShellSort(int* arr, int n) {
//    int i, j, Increment;
//    int tmp;
//    for (Increment = n/2;  Increment> 0; Increment/=2)
//    {
//        tmp = arr[i];
//        for ( i = 0; i < n; i++)
//        {
//            if (tmp <arr[j - Increment])
//            {
//                arr[j] = arr[j - Increment];
//            }
//            else
//            {
//                break;
//            }
//            arr[j] = tmp;
//        }
//    }
//}
//void Heapsort(int* arr, int n){
//    int temp;
//    int nodeNum = n / 2 ;
//    int i;
//    bool end = true;
//    while (end)
//    {
//        for (i = nodeNum; i >= 0; i--)
//        {
//            if (i == 0)
//            {
//                int max = arr[2] > arr[0] ? arr[2] : arr[0];
//                max = arr[1] > max ? arr[1] : max;
//                if (arr[2] == max)
//                {
//                    arr[2] = arr[0];
//                    arr[0] = max;
//                }
//                else if (arr[1] == max)
//                {
//                    arr[1] = arr[0];
//                    arr[0] = max;
//                };
//                break;
//            }
//            int max = arr[i] > arr[i * 2] ? arr[i] : arr[i * 2];
//            max = arr[i * 2 + 1] > max ? arr[i * 2 + 1] : max;
//            if (arr[i * 2] == max)
//            {
//                arr[i * 2] = arr[i];
//                arr[i] = max;
//            }
//            else if(arr[i * 2+1] == max)
//            {
//                arr[i * 2 + 1] = arr[i];
//                arr[i] = max;
//            };
//        }
//        nodeNum = n / 2;
//        for (i = nodeNum; i>=0; i--)
//        {
//            if (i ==0)
//            {
//                if (arr[0] > arr[1] || arr[0] > arr[2])
//                {
//                    nodeNum = i;
//                    i = -1;
//                }
//                end = false;
//
//            }
//            if ((i*2 < n && i*2+1 < n ) && (arr[i] < arr[i*2] || arr[i] < arr[i * 2+1]))
//            {
//                nodeNum = i;
//                i = -1;
//            }
//        }
//    }
//
//    
//
//}
void heapify(int arr[], int n, int i) {
    int largest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;

    if (left < n && arr[left] > arr[largest])
        largest = left;

    if (right < n && arr[right] > arr[largest])
        largest = right;

    if (largest != i) {
        std::swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}
void heapSort(int arr[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(arr, n, i);
    for (int i = n - 1; i >= 0; i--) {
        std::swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}
void printArray(int* arr, int n)
{
}