排序算法記錄

// sort.cpp : 定義控制檯應用程序的入口點。
//


#include "stdafx.h"
#include <iostream>
#include <queue>
using namespace std;


//插入排序
//a 指向數組第一個元素指針； n數組元素個數
void InsertSort(int* a, int n)
{
for (int i = 1; i < n; ++i) //從a[1]開始與a[0]進行比較
{
if (a[i] < a[i - 1])
{
int temp;
for (int j = i - 1; j>-1 && a[j]>a[j + 1]; --j) //j最小爲0，且a[j]滿足大於a[j+1]才交換a[j]與a[j+1]的值
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
//希爾排序
//a 指向數組第一個元素指針； n數組元素個數
void ShellSort(int* a, int n)
{
int d = n / 2; //將數組劃分爲d個部分進行插入排序
while (d > 0)
{
for (int i = d; i < n; ++i) //從a[d]開始與a[0]進行比較，其餘部分依次對應
{
if (a[i] < a[i - d])
{
int temp;
for (int j = i - d; j>-1 && a[j] > a[j + d]; j -= d) //j最小爲0，且a[j]滿足大於a[j+d]才交換a[j]與a[j+d]的值
{
temp = a[j];
a[j] = a[j + d];
a[j + d] = temp;
}
}
}
d /= 2; //當然d的值不一定用這種方法取
}
}
//冒泡排序
//a 指向數組第一個元素指針； n數組元素個數
void BubleSort(int* a, int n)
{
int temp;
for (int i = 0; i < n - 1; ++i) //a[n-1]爲最後一個元素，其位置至少在a[n-2]冒泡時確定
{
for (int j = 0; j < n - i; ++j) //每次應該從a[0]開始冒泡因而j=0，每次確定的剛好是a[n-i-1]
{
if (a[j] > a[j + 1])
{
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
//選擇排序
//a 指向數組第一個元素指針； n數組元素個數
void SelectSort(int* a, int n)
{
int temp, min;
for (int i = 0; i < n; ++i)
{
min = i;
for (int j = i + 1; j < n; ++j) //每次選出最小的放到數組前
{
if (a[min] > a[j])
{
min = j;
}
if (min != i)
{
temp = a[min];
a[min] = a[i];
a[i] = temp;
}
}
}
}
//快速排序
//a 指向數組第一個元素指針； m第一個元素下標； n最後一個元素下標
void QuickSort(int* a, int m, int n)
{
if (m < n) //m<n時執行
{
int min = m, max = n, temp, now = a[m];
while (m < n) //m>=n時，當前now的位置已確定      小  now  大
{
while (m<n && a[n]>now) //將比now大的數移至now的右邊
--n;
temp = a[n];
a[n] = a[m];
a[m] = temp;
while (m < n && a[m] < now) //將比now小的數移至now的左邊
++m;
temp = a[m];
a[m] = a[n];
a[n] = temp;
}
QuickSort(a, min, m - 1); //遞歸排序剩下的值
QuickSort(a, m + 1, max);
}
}
//歸併排序
//a 指向數組第一個元素指針； low最小下標； mid中間下標； high最大下標
void Merge(int* a, int low, int mid, int high)
{
queue<int>* V = new queue<int>(); //創建一個隊列存儲當前歸併的結果
int indexA = low, indexB = mid; //比較兩部分的大小，將較小的存入隊列，並向後移一位
while (indexA < mid && indexB < high + 1) //mid屬於後部分，high+1保證最大下標值也加入比較
{
if (a[indexA] < a[indexB])
{
V->push(a[indexA]);
++indexA;
}
else
{
V->push(a[indexB]);
++indexB;
}
}
while (indexA < mid)
{
V->push(a[indexA]);
++indexA;
}
while (indexB < high + 1)
{
V->push(a[indexB]);
++indexB;
}
int index = 0;
while (V->size()>0) //將排序了的數據寫入原數組中
{
a[low + index] = V->front();
V->pop();
++index;
}
}
//a 指向數組第一個元素指針； m第一個元素下標； n最後一個元素下標
void MergeSort(int* a, int m, int n)
{
if (m < n)
{
int mid = (m + n + 1) / 2; //獲取當前中點

MergeSort(a, m, mid - 1); //以中點分界繼續遞歸（向左）

MergeSort(a, mid, n); //以中點分界繼續遞歸（向右）
Merge(a, m, mid, n); //歸併
}
}
//堆排序
//調整堆
//a 指向數組第一個元素指針； now根節點； n節點數
void AdjustHeap(int* a, int now, int n)
{

int leftChild = 2 * now + 1; //now的左孩子

int rightChild = 2 * now + 2; //now的右孩子
int max = now, temp; //max記錄當前根節點下標
if (now < n / 2) //如果根節點是葉節點就不需要調整（大於等於n/2是葉節點）
{
if (leftChild<n && a[leftChild]>a[max]) //leftChild<n保證節點存在，子節點大於根節點則改變max的值，讓其記錄最大值下標
{
max = leftChild;
}
if (rightChild<n && a[rightChild]>a[max]) //rightChild<n保證節點存在，子節點大於a[max]則改變max的值，讓其記錄最大值下標
{
max = rightChild;
}
if (max != now) //max值改變則把大值移至根節點
{
temp = a[max];
a[max] = a[now];
a[now] = temp;
AdjustHeap(a, max, n); //避免調整以後以max爲父節點的子樹不是堆
}
}
}
//創建堆
void BuildHeap(int* a, int n)
{
for (int i = n / 2 - 1; i >= 0; --i) //非葉節點的最大序號爲n/2-1，從非葉節點最大序號一直調整到序號爲0的節點（根節點）
{
AdjustHeap(a, i, n); //調整堆
}
}
//a 指向數組第一個元素指針； n數組元素個數
void HeapSort(int* a, int n)
{
BuildHeap(a, n); //創建堆
int temp;
for (int i = n - 1; i >0 ; --i) //i>0因爲i=1時排序已確定
{
temp = a[0]; //交換堆頂和最後一個元素，即每次將剩餘元素中最大者放到後面
a[0] = a[i];
a[i] = temp;
AdjustHeap(a, 0, i); //重新調整堆頂節點成爲最大堆
}
}
//桶排序
//a 指向數組第一個元素指針； n數組元素個數
int GetBuketSize(int* a, int n) //獲取桶的個數，根據需要可以採用其他取值方法，此處浪費空間
{
int size = 0;
for (int i = 0; i < n; ++i)
{
if (a[size] < a[i])
{
size = i;
}
}
return a[size]+1; //最大元素值+1（包含0）
}
//a 指向數組第一個元素指針； n數組元素個數
void BuketSort(int* a, int n)
{
int size = GetBuketSize(a, n), index = 0;
int* b = new int[size]; //分配size個桶
for (int i = 0; i <= size; ++i) //初始化每個桶中數據爲0，即沒有數據
{
b[i] = 0;
}
for (int i = 0; i < n; ++i) //對應的元素存入相應的桶中，桶中數據個數加1
{
++(b[a[i]]);
}
for (int i = 0; i <= size; ++i) //從裝最小值的桶開始取數據
{
if (b[i] != 0) //判斷桶中是否有數據
{
while (b[i]-- != 0) //將有數據的桶中的所有數據存入原數組中，從index爲0開始
{
a[index] = i;
++index;
}
}
}

}

int _tmain(int argc, _TCHAR* argv[])
{
int a[] = { 4, 5, 6, 1, 2, 3, 4, 6, 9, 23, 32, 654, 34, 234, 56, 43};
//HeapSort(a, 16);
BuketSort(a, 16);
for (int i = 0; i < 16; ++i)
{
cout << a[i] << endl;
}
return 0;
}