# 排序算法总结

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>

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

2010年03月24日 14KB 下载

#### 黄海安-八大排序算法总结

2018年03月31日 520KB 下载

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

2016-03-06 23:03:54

#### [数据结构复习]八大内排序算法总结

2015-04-11 10:18:53

#### 各类常用排序算法的总结

2017-02-26 21:58:23

#### 面试常用算法总结——排序算法（java版）

2015-08-06 15:57:19

#### 九种基本排序算法总结

2016-04-29 14:23:38

#### 排序算法总结.doc

2010年09月18日 77KB 下载

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

2016-07-19 19:56:57

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

2013-10-09 21:23:11