冒泡 快速 堆排序 归并排序学习示例

// SortTest.cpp : 定义控制台应用程序的入口点。
//
 
#include "stdafx.h"
#include <iostream>
 
 
using namespace std;
 
 
 
void swap(int& a, int& b) {
    int c = a;
    a = b;
    b = c;
}
 
void BubbleSort(int arr[],int length) {
    for (int i = 0; i < length-1; i++) {
        for (int j = 0; j < length - i-1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j+ 1]);
                //此处可增加是否跳出标记 标记为真
            }
        }
        //此处检测跳出标记 若标记为假 则说明此次循环数据已无变动
        //排序结束 可跳出循环
    }
}
 
void PrintArray(int arr[], int length) {
    for (int i = 0; i < length; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}
 
void TestBubbleSort() {
    int testArr1[] = { 12,76,12,18,99,12,12,35,12,12 };
    int testArr2[] = { 1,2,3,8,7,4,5,6,7,8,9,0 };
    int testArr3[] = { 0,9,3,4,8,7,99,6,7,88,5,33,66,4,3,2,1 };
 
#define TESTARR(ARR)                                \
do{                                                 \
    BubbleSort(ARR, sizeof(ARR) / sizeof(ARR[0]));  \
    PrintArray(ARR, sizeof(ARR) / sizeof(ARR[0]));  \
}while(0)
 
    TESTARR(testArr1);
    TESTARR(testArr2);
    TESTARR(testArr3);
    std::cout << std::endl;
}
 
//=============================================================
void QuickSort(int arr[], int left, int right) {
    int i = left;
    int j = right;
    if (left >= right)
        return;
    int temp = arr[left];
    while (i != j) {
        while (j != i && arr[j] >=  temp)
            j--;
        while (j != i && arr[i] <=  temp)
            i++;
        if (i < j) {
            swap(arr[i],arr[j]);
        }
    }
    arr[left] = arr[i];
    arr[i] = temp;
 
    QuickSort(arr,left,i-1);
    QuickSort(arr, i+1,right);
 
}
 
void TestQuickSort() {
    int testArr1[] = { 12,76,12,18,99,12,12,35,12,12 };
    int testArr2[] = { 1,2,3,8,7,4,5,6,7,8,9,0 };
    int testArr3[] = { 0,9,3,4,8,7,99,6,7,88,5,33,66,4,3,2,1 };
 
#define TESTQUICKARR(ARR)                               \
do{                                                 \
    QuickSort(ARR, 0,sizeof(ARR) / sizeof(ARR[0])-1);   \
    PrintArray(ARR, sizeof(ARR) / sizeof(ARR[0]));  \
}while(0)
 
    TESTQUICKARR(testArr1);
    TESTQUICKARR(testArr2);
    TESTQUICKARR(testArr3);
    std::cout << std::endl;
}
 
 
//=======================================
struct HeapArray {
    int heapArr[100];
    int heapSize;
    HeapArray() {
        heapSize = 0;
        for (int i = 0; i < 100; i++) {
            heapArr[i] = -1;
        }
    }
};
 
HeapArray heapA;
 
void HeadpAdjustTopDown(int index) {
    while(index*2+1 <= heapA.heapSize-1){
        if (index * 2 + 2 <= heapA.heapSize - 1) {
            if (heapA.heapArr[index] > heapA.heapArr[index * 2 + 1] &&
                heapA.heapArr[index * 2 + 1] <= heapA.heapArr[index * 2 + 2]) {
                swap(heapA.heapArr[index], heapA.heapArr[index * 2 + 1]);
                index = index * 2 + 1;
                continue;
            }
            else if (heapA.heapArr[index] > heapA.heapArr[index * 2 + 2] &&
                heapA.heapArr[index * 2 + 2] <= heapA.heapArr[index * 2 + 1]) {
                swap(heapA.heapArr[index], heapA.heapArr[index * 2 + 2]);
                index = index * 2 + 2;
                continue;
            }
        }
        else { // 仅有左儿子情况
            if (heapA.heapArr[index] > heapA.heapArr[index * 2 + 1]) {
                swap(heapA.heapArr[index], heapA.heapArr[index * 2 + 1]);
                index = index * 2 + 1;
                continue;
            }
        }
        break;
    }
}
 
void HeadpAdjustDownTop(int index) {
    int i = index;
    while (i != 0) {
        if (heapA.heapArr[i] < heapA.heapArr[(i - 1) / 2]) {
            swap(heapA.heapArr[i], heapA.heapArr[(i - 1) / 2]);
            i = (i-1) / 2;
        }
        else {
            break;
        }
    }
}
 
void HeapInsert(int in) {
    heapA.heapArr[heapA.heapSize] = in;
    HeadpAdjustDownTop(heapA.heapSize);
    heapA.heapSize++;
}
 
void HeapSort(int arr[],int length) {
 
    heapA.heapSize = 0;
    for (int i = 0; i < 100; i++) {
        heapA.heapArr[i] = -1;
    }
 
    for (int i = 0; i < length; i++) {
        HeapInsert(arr[i]);
    }
}
 
 
 
void PrintHeap() {
    int j = heapA.heapSize;
    for (int i = 0; i < j; i++) {
        std::cout << heapA.heapArr[0] << " ";
 
        heapA.heapArr[0] = heapA.heapArr[heapA.heapSize - 1];
        heapA.heapSize--;
        HeadpAdjustTopDown(0);
    }
 
    std::cout << std::endl;
}
 
void TestHeapSort() {
    int testArr1[] = { 12,76,12,18,99,12,12,35,12,12 };
    int testArr2[] = { 1,2,3,8,7,4,5,6,7,8,9,0 };
    int testArr3[] = { 0,9,3,4,8,7,99,6,7,88,5,33,66,4,3,2,1 };
 
#define TESTHEAPARR(ARR)                                \
do{                                                 \
    HeapSort(ARR, sizeof(ARR) / sizeof(ARR[0]));    \
    PrintHeap();    \
}while(0)
 
    TESTHEAPARR(testArr1);
    TESTHEAPARR(testArr2);
    TESTHEAPARR(testArr3);
    std::cout << std::endl;
}
 
//=================================================
 
void MergeArr(int arr[], int lbegin, int lend, int rbegin, int rend, int tmp[]) {
    int i = lbegin,j = lend,m = rbegin, n = rend,k = 0;
 
    while (i <= j && m <= n) {
        if (arr[i] <= arr[m]) {
            tmp[k++] = arr[i++];
        }
        else {
            tmp[k++] = arr[m++];
        }
    }
 
    while (i <= j)
        tmp[k++] = arr[i++];
    while (m <= n)
        tmp[k++] = arr[m++];
 
    for (int i = 0; i < k; i++) {
        arr[lbegin + i] = tmp[i];
    }
}
 
void MergeSort(int a[], int first, int last, int temp[]) {
    if (first < last) {
        int mid = (first + last) / 2;
        MergeSort(a, first, mid, temp);   
        MergeSort(a, mid + 1, last, temp);
        MergeArr(a,first,mid, mid + 1,last,temp);
    }
}
 
bool MergeSort(int arr[], int n)
{
    int *tmp = new int[n];
    MergeSort(arr, 0, n - 1, tmp);
    delete[] tmp;
    return true;
}
 
void TestMergeSort() {
    int testArr1[] = { 12,76,12,18,99,12,12,35,12,12 };
    int testArr2[] = { 1,2,3,8,7,4,5,6,7,8,9,0 };
    int testArr3[] = { 0,9,3,4,8,7,99,6,7,88,5,33,66,4,3,2,1 };
 
#define TESTMERGEARR(ARR)                               \
do{                                                 \
    MergeSort(ARR, sizeof(ARR) / sizeof(ARR[0]));   \
    PrintArray(ARR, sizeof(ARR) / sizeof(ARR[0]));  \
}while(0)
 
    TESTMERGEARR(testArr1);
    TESTMERGEARR(testArr2);
    TESTMERGEARR(testArr3);
    std::cout << std::endl;
}
 
//=============================================
int main()
{
    TestQuickSort();
    TestBubbleSort();
    TestHeapSort();
    TestMergeSort();
 
    return 0;
}