排序算法记录

// 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;
}