# 排序算法总结

1.插入排序

a.直接插入排序

void InsertSort(int *arr, int n)
{
int end = 0;
int tmp = 0;
for (int i = 0; i < n - 1; i++)
{
end = i;
tmp = arr[end + 1];
while (end >= 0 && tmp < arr[end])
{
arr[end + 1] = arr[end];
--end;
}
//此处由于已经减出范围所以需要++
if (tmp < arr[++end])
arr[end] = tmp;
}
}
b.希尔排序

void ShellSort(int *arr, int n)
{
int end = 0;
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1;
for (int i = 0; i < n - gap; i++)
{
end = i;
int tmp = arr[end + gap];
while (end >= 0 && tmp < arr[end])
{
arr[end + gap] = arr[end];
end -= gap;
}
arr[end + gap] = tmp;
}
}
}

2.选择排序

a.直接选择排序

void SelectSort(int *arr, int n)
{
int left = 0;
int right = n - 1;
int max = 0;
int min = 0;
while (left < right)
{
for (int i = left; i <= right; i++)
{
if (arr[i] > arr[max])
max = i;
if (arr[i] < arr[min])
min = i;
}
swap(arr[left], arr[min]);
if (max == left)
max = min;
swap(arr[right], arr[max]);
left++;
right--;
}
}
3.堆排序

void AdjustDown(int *arr,int parent, int n)
{
int child = parent * 2 + 1;
while (child < n)
{
if (child + 1 < n && arr[child] < arr[child + 1])
child++;
if (arr[parent] < arr[child])
{
swap(arr[parent], arr[child]);
parent = child;
child = parent * 2 + 1;
}
else
break;
}
}
void HeapSort(int *arr, int n)
{
int index = (n - 2) / 2;
for (int i = index; i >= 0; i--)
{
}
int end = n - 1;
while (end > 0)
{
swap(arr[0], arr[end]);
--end;
}
}

4.交换排序

a.冒泡排序

void BubbleSort(int *arr,int n)
{
//chage用于优化
bool chage = false;
int end = n - 1;
for (int i = 0; i < n; i++)
{
chage = false;
for (int j = 0; j < end-i; j++)
{
if (arr[j] > arr[j + 1])
{
swap(arr[j], arr[j + 1]);
chage = true;
}
}
if (chage = false)
break;
}

}

b.快速排序

1）标准快排

void SelectMid(int *arr,int left,int right)
{
int mid = (left + right) / 2;
if (left < right)
{
if (arr[left] < arr[mid] && arr[mid] < arr[right])
swap(arr[left], arr[left]);
else if (arr[right] < arr[mid])
swap(arr[left], arr[right]);
}
else
{
if (arr[mid] > arr[right] && arr[mid] <arr[left])
swap(arr[left], arr[mid]);
}
}
void QuikSort(int *arr, int left, int right)
{
SelectMid(arr, left, right);
if (right < left)
{
return;
}
int j = right;
int i = left;
//设置比较的基准值
int base = arr[left];
//一次交换必须直到相遇即停
while (i != j)
{
//找从右边开始小于key值得数
while (arr[j] >= base && i < j)
j--;
//从左起找第一个大于key值的数
while (arr[i] <= base && i < j)
i++;

if (i < j)
{
swap(arr[i], arr[j]);
}
}
//将key值归位
swap(arr[left], arr[i]);
QuikSort(arr, left, i - 1);
QuikSort(arr, i + 1, right);
}
2）挖坑法快排

void QuikSort_OP1(int *arr, int start, int end)
{
SelectMid(arr, start, end);
if (start >=  end)
return;
int key = arr[end];
int hoop = end;
int left = start;
int right = end;

while (left < right)
{
while (right >left && arr[left] < key)
++left;
if (right >left)
{
arr[hoop] = arr[left];
hoop = left;
}
while (right > left && arr[right] > key)
--right;
if (right > left)
{
arr[hoop] = arr[right];
hoop = right;
}
}
arr[hoop] = key;

QuikSort_OP1(arr, start, hoop-1);
QuikSort_OP1(arr, hoop+1,  end);
}

3）prev&cur快排

key时就会发现cur会连续的走若干步，prev总是指向了比key大的数的前一个。大家可以在纸上画一画

<span style="font-size: 14px;">void QuikSort_OP2(int *arr, int start, int end)
{
SelectMid(arr, start, end);
int  prev = start -1;
int cur = start;
while (cur < end)
{
while (arr[cur] > arr[end])
cur++;
if (cur < end )
swap(arr[++prev], arr[cur++]);
}
swap(arr[end], arr[++prev]);
QuikSort(arr, start, prev);
QuikSort(arr, prev, end);
</span><span style="font-size:12px;">}</span>

• 本文已收录于以下专栏：

## 几种常见排序算法总结（java版）

• zgrjkflmkyc
• 2013年09月13日 12:50
• 13460

## [数据结构]七种排序算法小结

• u010536377
• 2016年02月20日 12:21
• 1459

## C++常用排序算法总结

• fanyun_01
• 2016年05月31日 15:51
• 2608

## 排序算法总结与C代码

• yyme411
• 2013年10月09日 21:23
• 7176

## 十种常见的排序算法总结(java版)

• canot
• 2016年03月06日 23:03
• 2701

## 七大常见排序算法总结

• lutianfeiml
• 2016年07月19日 19:56
• 5039

## Java数据结构与算法之常见排序算法总结

• qq_28057577
• 2016年10月08日 15:54
• 587

## 排序算法大汇总

• u014536527
• 2016年03月30日 01:23
• 1946

## 十大经典排序算法总结——Java实现

• WangQYoho
• 2016年09月19日 12:12
• 2211

## 【算法】－8大排序算法总结－Python

8大排序算法总结－Python
• aliceyangxi1987
• 2016年03月16日 14:52
• 1109

举报原因： 您举报文章：排序算法总结 色情 政治 抄袭 广告 招聘 骂人 其他 (最多只允许输入30个字)