关于常用排序等算法的例子整理

#include <algorithm>
#include <functional>
#include <vector>
#include <iostream>
using namespace std;
void printArray(int a[], int n);


/**插入排序**/
void InserSort(int a[], int n)  //效率O(n*n)
{
int temp = 0;
for (int i = 1; i < n; ++i)
{
if (a[i] < a[i-1])
{
temp = a[i];
int x = i - 1;
while (temp < a[x])
{
a[x + 1] = a[x]; 
x--;
}
a[x + 1] = temp;
}
printArray(a, n);
}
}


/*选择排序*/
void selectInsort(int a[], int n)
{
for (int i = 0; i < n; ++i)
{
for (int j = i +1 ; j < n;j++)
{
if (a[j] < a[i] )
{
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
printArray(a, n);
}
}


/*堆排序*/
// 时间复杂度： O(nlogn )。
//curIndex :当前调整的位置
//n         :整个长度
void adjustHeap(int a[], int curIndex, int n)
{
int temp = a[curIndex];
int right = 2 * curIndex + 1;
while (right < n)
{
if (right + 1 < n && a[right] < a[right + 1])
{
++right;
}
if (a[curIndex] < a[right])
{
a[curIndex] = a[right];
curIndex = right;
right = 2 * right + 1;
}
else
{
break;
}
a[curIndex] = temp;
}
printArray(a, n);
}
void buildHeap(int a[], int n)
{
for (int i = (n -1)/ 2 - 1; i >= 0; --i)
{
adjustHeap(a, i, n);
}
}
void heapSort(int a[], int n) 
{
buildHeap(a, n);
for (int j = n - 1; j > 0; --j)
{
int temp = a[j];
a[j] = a[0];
a[0] = temp;
adjustHeap(a, 0, j);
}
}


/*交换排序---> 冒泡*/
void bubbleSort(int a[], int n)
{
for (int i = 0; i < n -1; ++i)
{
for (int j = 0; j < n -i -1; ++j)
{
if (a[j] > a[j+1])
{
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}


/*交换排序---> 冒泡改进算法1*/
void bubbleSortNew1(int a[], int n)
{
int i = n - 1;
while (i > 0)
{
int pos = 0;
for (int j = 0; j < i; ++j)
{
if (a[j] > a[j + 1])
{
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;


pos = j;
}
}
i = pos; //位下一趟做准备
printArray(a, n);
}


}


/*找出最大和最小，冒泡法*/
void bubbleSortNew2(int a[], int n)
{
int low = 0;
int high = n - 1;
int temp, j;
while (low < high)
{
/*for (j = low; j < high;++j)
{
if (a[j] > a[j+1])
{
temp = a[j + 1];
a[j + 1] = a[j];
a[j] = temp;
}
}
printArray(a, n);
--high;*/
for (j = high; j > low; --j)
{
if (a[j] < a[j - 1])
{
temp = a[j - 1];
a[j - 1] = a[j];
a[j] = temp;
}
}
++low;
printArray(a, n);
}
}


/**快速排序  （O(nlog2n)）*/
void swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
int biaryPart(int a[], int low, int high)
{
int temp = a[low];
while (low < high)
{
while (low < high && temp > a[high])
{
--high;
}
swap(&a[high], &temp);
while (low < high && temp < a[low])
{
++low;
}
swap(&a[low], &temp);
}
printArray(a, 6);
return low;
}
void quickSort(int a[], int low, int high)
{
if (low < high)
{
int midIndex = biaryPart(a, low, high);
quickSort(a, low, midIndex);
quickSort(a, midIndex + 1, high);
}
}


/*归并排序*/
// 合并
void merge(int a[], int start, int mid, int end)
{
int n1 = mid - start + 1;//第一个数组长度
int n2 = end - mid;//第二个
int *left;
left =(int *)malloc(sizeof(int)*n1);
if (NULL == left)
{
return;
}
memset(left, 0, n1);
int *right;
right = (int *)malloc(sizeof(int)*n2);
if (NULL == right)
{
return;
}
memset(right, 0, n2);
///
int i  = 0, j = 0;
for (i = 0; i < n1; i++)
{
left[i] = a[start + i];
}
for (j = 0; j < n2; j++)
{
right[j] = a[mid + j + 1];
}
i = j = 0;
int k = start;
while (i < n1 && j < n2)
{
if (left[i] > right[j])
{
a[k++] = left[i++];
}
else
{
a[k++] = right[j++];
}
}
while (j < n2)
{
a[k++] = right[j++];
}
while (i < n1)
{
a[k++] = left[i++];
}
}
void mergeSort(int a[], int start, int end)
{
int mid;
if (start < end)
{
//分解
mid = (end + start) / 2 ; //mid = 2
mergeSort(a, start, mid);
mergeSort(a, mid + 1, end);
//合并
merge(a, start, mid, end);
printf("----------\n");
printArray(a, end - start + 1);
}
}


/*基数排序*/


/*打印输出*/
void printArray(int a[], int n)
{
for (int i = 0; i < n; ++i)
{
printf("%ld,", a[i]);
}
printf("\n");
}
int main()
{
int a[] = { 2, 4, 6, 1, 8, 7 };
mergeSort(a, 0, 5);
printArray(a, sizeof(a) / sizeof(a[0]));
return 0;
}