1.直接插入排序:基本算法:将第i个记录插入到前面第i-1个已经排好序的记录中。当插入第i(i>.=1)个元素时,前面的元素已经排好序,此时用array[i]与前面的元素进行比较,找到插入位置之后将array[i]插入,原来的位置上的元素顺序后移。
具体代码实现为:
#include<iostream>
using namespace std;
void InsertSort(int *array, size_t size)
{
//每一趟
for (int i = 1; i < size; i++)//依次插入元素
{
int key = array[i];
int end = i - 1;
while (end>=0 && key < array[end])
{
array[end + 1] = array[end];
end--;
}
array[end + 1] = key;//插入元素
}
}
int main()
{
int array[] = { 8, 2, 6, 7, 9, 10 };
int sz = sizeof(array) / sizeof(array[0]);
InsertSort(array, sz);
for (size_t i = 0; i < sz; i++)
{
cout << array[i] << endl;
}
system("pause");
return 0;
}
2.二分查找排序
具体的代码实现为:
void Insert_BinarySearchSort(int *array, size_t size)
{
for (int i = 1; i < size; i++)
{
int left = 0;
int right = i - 1;
int key = array[i];
int mid = 0;
while (left <= right)
{
mid = left + ((right - left) >> 1);
if (key < array[mid])
{
right = mid - 1;
}
else
{
left = mid + 1;
}
}
//搬移元素
int end = i - 1;
while (end >= left)//将left当前位置的元素搬走
{
array[end + 1] = array[end];
end--;
}
//插入元素
array[left] = key;
}
}
int main()
{
int array[] = { 8, 2, 6, 7, 9, 10 };
int sz = sizeof(array) / sizeof(array[0]);
Insert_BinarySearchSort(array, sz);
for (int i = 0; i < sz; i++)
{
cout << array[i] << endl;
}
system("pause");
return 0;
}
3.希尔排序(Shell 排序)
希尔排序是插入排序的一种又称“缩小增量排序”,是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。
方式1:基于直接插入排序进行修改,分组进行。
具体的代码实现为:
void ShellSort(int *array, size_t size)
{
int gap = 3;
while (gap)
{
for (int i = gap; i < size; i++)
{
int end = i - gap;
int key = array[i];
while (end>=0 && key < array[end])//end>0避免end越界
{
array[end + gap] = array[end];
end-=gap;
}
array[end + gap] = key;
}
gap--;
}
}
int main()
{
int array[] = { 8, 2, 6, 7, 9, 10 };
int sz = sizeof(array) / sizeof(array[0]);
ShellSort (array, sz);
for (int i = 0; i < sz; i++)
{
cout << array[i] << endl;
}
system("pause");
return 0;
}
2.方式二:
void ShellSort(int *array, size_t size)
{
int gap = size;
while (gap>1)
{
gap = gap / 3 + 1;
for (size_t i = gap; i < size; i++)
{
int key = array[i];
int end = i - gap;
//找当前元素需要插入的位置
while (end >= 0 && key < array[end])//end>0避免end越界
{
array[end + gap] = array[end];//往后搬移
end -= gap;
}
array[end + gap] = key;
}
}
}
int main()
{
int array[] = { 8, 2, 6, 7, 9, 10 };
int sz = sizeof(array) / sizeof(array[0]);
ShellSort (array, sz);
for (int i = 0; i < sz; i++)
{
cout << array[i] << endl;
}
system("pause");
return 0;
}
4.选择排序:
基本算法思想:第i趟(i=0,1,2…)在n-i个待排序的数据元素集合中选出关键码最小的数据元素 ,作为有序元素序列的第i个元素,待到第n-2趟做完,待排序元素集合中只剩下1个元素,排序结束。
(1)、直接选择排序:
先从第一个元素给予maxpos,依次进行比较,若后面元素比其大,则maxpos后移。
void SelectSort(int *array, size_t size)
{
for (size_t i = 0; i < size-1; i++)//从第0个位置开始
{
size_t maxpos = i;
for (size_t j = i+1; j < size ; j++)
{
if (array[j]<array[maxpos])
maxpos = j;
}
if (maxpos != i)
{
swap(array[maxpos], array[i]);
}
}
}
int main()
{
int array[] = { 8, 2, 6, 7, 9, 10 };
int sz = sizeof(array) / sizeof(array[0]);
Insert_BinarySearchSort(array, sz);
for (int i = 0; i < sz; i++)
{
cout << array[i] << endl;
}
system("pause");
return 0;
}
(2)、堆排序
a.创建堆:升序排序创建大堆,降序创建小堆。
b.循环执行的过程:1>将堆顶元素和当前堆的最后一个元素进行交换。
2>将堆的元素个数减1
3>向下进行调整。
代码实现如下:
void AdjustDown(int* array, size_t size, size_t parent)
{
size_t child = parent * 2 + 1;
while (child < size)
{
if (child + 1 < size&&array[child + 1] >array[child])
{
child+=1;
}
if (array[child]>array[parent])
{
std::swap(array[child], array[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void HeapSort(int* array, size_t size)
{
建大堆
for (int i = (size - 2) / 2; i >= 0; --i)
{
AdjustDown(array, size, i);
}
int end = size - 1;
while (end)
{
swap(array[0], array[end]);
AdjustDown(array, end, 0);
end--;
}
}
int main()
{
int array[] = { 10, 11, 12, 14, 12, 1, 2, 3, 4, 15, 19 };
int len = sizeof(array) / sizeof(array[0]);
HeapSort(array, len);
for (size_t i = 0; i < len; ++i)
{
cout << array[i] << " ";
}
system("pause");
return 0;
}
交换排序:
(1)、冒泡排序:较简单,不做详细说明。代码如下:
void BubbleSort(int *array, size_t size)
{
for (int i = 0; i < size; i++)
{
bool exchange = false;
for (int j = 0; j < size - i - 1; j++)
{
if (array[j]>array[j + 1])
{
swap(array[j], array[j + 1]);
exchange = true;
}
}
}
}
int main()
{
int array[] = { 10, 11, 12, 14, 12, 1, 2, 3, 4, 15, 19 };
int len = sizeof(array) / sizeof(array[0]);
HeapSort(array, len);
for (size_t i = 0; i < len; ++i)
{
cout << array[i] << " ";
}
system("pause");
return 0;
}
(2)、快速排序:(一种二叉树结构的交换排序方法)
方法一:划分—>基准值—>左右两半部分。、
一趟排序如下:(这组数据代表性不强)
size_t postion1(int *array, size_t left, size_t right)
{
size_t begin = 0;
size_t end = right - 1;
int key = array[end];
while (begin < end)
{
while (begin < end&&array[begin]<=key)
{
begin++;
}
while (begin<end&&array[end]>=key)
{
end--;
}
if (begin < end)
{
swap(array[begin], array[end]);
}
}
swap(array[begin], array[right-1]);//交换array[begin]与最后一个元素。
return begin;//返回基准记录的位置
}
void quickSort(int *array, int left, int right)
{
if (left < right)
{
int div = postion1(array, 0,right);
quickSort(array, left, div);//左侧排序
quickSort(array, div +1, right);//右侧排序
}
}
int main()
{
int array[] = { 10,11,5,9,8,6};
int sz= sizeof(array) / sizeof(array[0]);
quickSort(array,0,sz);
for (size_t i = 0; i <sz; ++i)
{
cout << array[i] << " ";
}
system("pause");
return 0;
}
(2)、挖坑法:
具体代码如下:
size_t postion2(int *array, size_t left,size_t right)//挖坑法
{
size_t begin = left;
size_t end = right - 1;
int key = array[end];
while (begin < end)
{
while (begin<end&&array[begin]<=key)
{
begin++;
}
if (begin < end)
{
array[end] = array[begin];
}
while (begin < end&&array[end] >= key)
{
end--;
}
if (begin < end)
{
array[begin] = array[end];
}
}
array[begin] = key;
return begin;
}
void quickSort(int *array, int left, int right)
{
if (left < right)
{
int div = postion2(array, 0, right);
quickSort(array, left, div);//左侧排序
quickSort(array, div + 1, right);//右侧排序
}
}
int main()
{
int array[] = { 10, 11, 5, 9, 8, 6 };
int sz = sizeof(array) / sizeof(array[0]);
quickSort(array, 0, sz);
for (size_t i = 0; i <sz; ++i)
{
cout << array[i] << " ";
}
system("pause");
return 0;
}
归并排序:
具体步骤:1.将数据分为左右相等的两半部分。
2.再进行归并。
代码:
外部排序---归并排序
1.递归
void Merge(int *array, int left, int mid, int right, int*temp)
{
int begin1 = left;
int end1 = mid;
int begin2 = mid;
int end2 = right;
int index = left;
while (begin1 <end1&&begin2 < end2)
{
if (array[begin1] < array[begin2])
{
temp[index++] = array[begin1++];
}
else
{
temp[index++] = array[begin2++];
}
}
while (begin1 < end1)
{
temp[index++] = array[begin1++];
}
while (begin2 < end2)
{
temp[index++] = array[begin2++];
}
将temp中的数据拷进array中
memcpy(array+left , temp+left , (right - left)*sizeof(int));//最后一个参数是字节个数
}
void MergeSort(int *array, int left, int right,int *temp)
{
if (right - left <= 1)
{
return;
}
if (left < right)
{
int mid = left + ((right - left) >> 1);
MergeSort(array, left, mid, temp);//左侧有序
MergeSort(array, mid , right, temp);//右侧有序
Merge(array, left, mid, right, temp);//再将两个有序序列合并
}
}
int main()
{
int array[] = { 2,0,4,9,3,6,8,7,1,5 };
int sz = sizeof(array) / sizeof(array[0]);
int *temp = new int[sz];
MergeSort(array, 0, sz, temp);
for (size_t i = 0; i <sz; ++i)
{
cout << array[i] << " ";
}
delete[] temp;
system("pause");
return 0;
}
//非递归版本:
void MergeSortNorR(int *array, int size,int*temp)
{
int gap = 1;
while (gap < size)//总的组数
{
for (int i = 0; i < size; i += 2 * gap)
{
int left = i;
int mid =i+gap;
int right = mid + gap;
if (mid>size)
{
mid = size;
}
if (right > size)
{
right = size;
}
Merge(array, left, mid, right, temp);
}
gap = gap * 2;
}
}
int main()
{
int array[] = { 2,0,4,9,3,6,8,7,1,5};
int sz = sizeof(array) / sizeof(array[0]);
int *temp = new int[sz];
MergeSortNorR(array, sz, temp);
for (size_t i = 0; i <sz; ++i)
{
cout << array[i] << " ";
}
delete[] temp;
system("pause");
return 0;
}