數據結構排序算法——冒泡排序，插入排序，希爾排序，堆排序，歸併排序

排序算法

#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using namespace std;

typedef int ElementType;

// 冒泡排序
//N爲數組元素個數
void baboSort(ElementType A[], int N) {
     for (int i = 0; i <N; i++) {
        int flag = 0;
        for (int j = i; j < N; j++) {
            if (A[i] > A[j]) {
                swap(A[i], A[j]);
                flag = 1;
            }
        }
        if (flag == 0) break;  // 如果沒有執行交換，說明已經有序
    }
}
//插入排序
void InsertionSort(ElementType A[], int N){ 
    int P, i;
    ElementType Tmp;
    for (P = 1; P < N; P++) {
        Tmp = A[P];                              /* 取出未排序序列中的第一個元素*/
        for (i = P; i > 0 && A[i - 1] > Tmp; i--)
            A[i] = A[i - 1];                      /*依次與已排序序列中元素比較並右移*/
        A[i] = Tmp;                              /* 放進合適的位置 */
    }
}

/* 希爾排序 - 用Sedgewick增量序列 */
void ShellSort(ElementType A[], int N)
{ 
    int Si, D, P, i;
    ElementType Tmp;
    /* 這裏只列出一小部分增量 */
    int Sedgewick[] = { 929, 505, 209, 109, 41, 19, 5, 1, 0 };

    // 希爾排序的第一個排序間隔不能超過數組的長度
    for (Si = 0; Sedgewick[Si] >= N; Si++); /* 初始的增量Sedgewick[Si]不能超過待排序列長度 */

    for (D = Sedgewick[Si]; D > 0; D = Sedgewick[++Si])
        for (P = D; P < N; P++) { /* 插入排序*/
            Tmp = A[P];
            for (i = P; i >= D && A[i - D] > Tmp; i -= D)
                A[i] = A[i - D];
            A[i] = Tmp;
        }
}

void Swap(ElementType* a, ElementType* b)
{
    ElementType t = *a; *a = *b; *b = t;
}

void PercDown(ElementType A[], int p, int N)
{ /* 改編代碼4.24的PercDown( MaxHeap H, int p )    */
  /* 將N個元素的數組中以A[p]爲根的子堆調整爲最大堆 */
    int Parent, Child;
    ElementType X;

    X = A[p]; /* 取出根結點存放的值 */
    for (Parent = p; (Parent * 2 + 1) < N; Parent = Child) {
        Child = Parent * 2 + 1;
        if ((Child != N - 1) && (A[Child] < A[Child + 1]))
            Child++;  /* Child指向左右子結點的較大者 */
        if (X >= A[Child]) break; /* 找到了合適位置 */
        else  /* 下濾X */
            A[Parent] = A[Child];
    }
    A[Parent] = X;
}

void HeapSort(ElementType A[], int N)
{ /* 堆排序 */
    int i;

    for (i = N / 2 - 1; i >= 0; i--)/* 建立最大堆 */
        PercDown(A, i, N);

    for (i = N - 1; i > 0; i--) {
        /* 刪除最大堆頂 */
        Swap(&A[0], &A[i]); /* 見代碼7.1 */
        PercDown(A, 0, i);
    }
}

/* 歸併排序 - 遞歸實現 */

/* L = 左邊起始位置, R = 右邊起始位置, RightEnd = 右邊終點位置*/
void Merge(ElementType A[], ElementType TmpA[], int L, int R, int RightEnd)
{ /* 將有序的A[L]~A[R-1]和A[R]~A[RightEnd]歸併成一個有序序列 */
    int LeftEnd, NumElements, Tmp;
    int i;

    LeftEnd = R - 1; /* 左邊終點位置 */
    Tmp = L;         /* 有序序列的起始位置 */
    NumElements = RightEnd - L + 1;

    while (L <= LeftEnd && R <= RightEnd) {
        if (A[L] <= A[R])
            TmpA[Tmp++] = A[L++]; /* 將左邊元素複製到TmpA */
        else
            TmpA[Tmp++] = A[R++]; /* 將右邊元素複製到TmpA */
    }

    while (L <= LeftEnd)
        TmpA[Tmp++] = A[L++]; /* 直接複製左邊剩下的 */
    while (R <= RightEnd)
        TmpA[Tmp++] = A[R++]; /* 直接複製右邊剩下的 */

    for (i = 0; i < NumElements; i++, RightEnd--)
        A[RightEnd] = TmpA[RightEnd]; /* 將有序的TmpA[]複製回A[] */
}

void Msort(ElementType A[], ElementType TmpA[], int L, int RightEnd)
{ /* 核心遞歸排序函數 */
    int Center;

    if (L < RightEnd) {
        Center = (L + RightEnd) / 2;
        Msort(A, TmpA, L, Center);              /* 遞歸解決左邊 */
        Msort(A, TmpA, Center + 1, RightEnd);     /* 遞歸解決右邊 */
        Merge(A, TmpA, L, Center + 1, RightEnd);  /* 合併兩段有序序列 */
    }
}

void MergeSort(ElementType A[], int N)
{ /* 歸併排序 */
    ElementType* TmpA;
    TmpA = (ElementType*)malloc(N * sizeof(ElementType));

    if (TmpA != NULL) {
        Msort(A, TmpA, 0, N - 1);
        free(TmpA);
    }
    else printf("空間不足");
}

/* 歸併排序 - 循環實現 */
/* 這裏Merge函數在遞歸版本中給出 */

/* length = 當前有序子列的長度*/
void Merge_pass(ElementType A[], ElementType TmpA[], int N, int length)
{ /* 兩兩歸併相鄰有序子列 */
    int i, j;

    for (i = 0; i <= N - 2 * length; i += 2 * length)
        Merge(A, TmpA, i, i + length, i + 2 * length - 1);
    if (i + length < N) /* 歸併最後2個子列*/
        Merge(A, TmpA, i, i + length, N - 1);
    else /* 最後只剩1個子列*/
        for (j = i; j < N; j++) TmpA[j] = A[j];
}

void Merge_Sort(ElementType A[], int N)
{
    int length;
    ElementType* TmpA;

    length = 1; /* 初始化子序列長度*/
    TmpA =(ElementType*) malloc(N * sizeof(ElementType));
    if (TmpA != NULL) {
        while (length < N) {
            Merge_pass(A, TmpA, N, length);
            length *= 2;
            Merge_pass(TmpA, A, N, length);
            length *= 2;
        }
        free(TmpA);
    }
    else printf("Space is not enough");
}

int main() {
	int N=5;
	ElementType A[100]={10,8,5,9,2};
	/*
	cout<<"輸入數組個數："<<endl;
	cin>>N;
	for(int i=0;i<N;i++){
		cin>>A[i];
	}
	*/
	cout<<"冒泡排序結果爲："<<endl;
	baboSort(A,N);
	for(int i=0;i<N;i++){
		cout<<A[i]<<' ';
	}
	cout<<endl;
	cout<<"插入排序結果爲："<<endl;
	InsertionSort(A,N);
	for(int i=0;i<N;i++){
		cout<<A[i]<<' ';
	}
	cout<<endl;
	cout<<"希爾排序結果爲："<<endl;
	ShellSort(A,N);
	for(int i=0;i<N;i++){
		cout<<A[i]<<' ';
	}
	cout<<endl;
	cout<<"堆排序結果爲："<<endl;
	HeapSort(A,N);
	for(int i=0;i<N;i++){
		cout<<A[i]<<' ';
	}
	cout<<endl;
	cout<<"遞歸實現歸併排序排序結果爲："<<endl;
	MergeSort(A,N);
	for(int i=0;i<N;i++){
		cout<<A[i]<<' ';
	}
	cout<<endl;
	cout<<"循環實現歸併排序排序結果爲："<<endl;
	Merge_Sort(A,N);
	for(int i=0;i<N;i++){
		cout<<A[i]<<' ';
	}
	cout<<endl;
	
	return 0; 
}