数据结构之排序算法
排序算法
1.冒泡排序（Bubble Sort）
1)算法伪代码
for i = 1 : n swapped = false for j = n : i + 1 if a[j] < a[j - 1] 交换a[j]和a[j - 1] swapped = true 排好序的数列：a[1...i] break if not swapped end
2)算法原理过程
初始数列：5, 3, 2, 4, 1 i = 1 [ 5, 3, 2, 1, 4 5, 3, 1, 2, 4 5, 1, 3, 2, 4 1, 5, 3, 2, 4 ] i = 2 [ 1, 5, 3, 2, 4 1, 5, 2, 3, 4 1, 2, 5, 3, 4 ] i = 3 [ 1, 2, 5, 3, 4 1, 2, 3, 5, 4 ] i = 4 [ 1, 2, 3, 4, 5 ]
3)代码实现
代码实现一：
#include <stdio.h>
#include <stdlib.h>
void bubble_sort(int arr[], int length)
{
int i, j;
int temp;
for(i = 0; i < length - 1; ++i)
{
for(j = length - 1; j > i; --j)
{
if(arr[j] < arr[j - 1])
{
temp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = temp;
}
}
}
}
void print_array(int arr[], int length)
{
int i = 0;
for(i = 0; i < length; ++i)
{
printf("%d ", arr[i]);
}
printf("\n\n");
}
int main(void)
{
int arr[] = {4, 3, 6, 1, 7, 2, 10, 5, 8, 9};
int length = 10;
printf("Before sorting, the array is:");
print_array(arr, length);
printf("After Bubble Sorting, the ordered array is:");
bubble_sort(arr, length);
print_array(arr, length);
return 0;
}
对于上述代码可以进行如下优化（swapped变量的作用是：当初始要排序的数列已经是有序的时候，只遍历一遍数列，就退出遍历循环）
#include <stdio.h>
#include <stdlib.h>
void bubble_sort(int arr[], int length)
{
int i, j;
int temp;
int swapped = 1;
for(i = 0; swapped && i < length - 1; ++i)
{
swapped = 0;
for(j = length - 1; j > i; --j)
{
if(arr[j] < arr[j - 1])
{
temp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = temp;
swapped = 1;
}
}
}
}
void print_array(int arr[], int length)
{
int i = 0;
for(i = 0; i < length; ++i)
{
printf("%d ", arr[i]);
}
printf("\n\n");
}
int main(void)
{
int arr[] = {4, 3, 6, 1, 7, 2, 10, 5, 8, 9};
int length = 10;
printf("Before sorting, the array is:");
print_array(arr, length);
printf("After Bubble Sorting, the ordered array is:");
bubble_sort(arr, length);
print_array(arr, length);
return 0;
}
4)复杂度分析
稳定的
空间复杂度O(1)
时间复杂度:比较和交换的操作次数，O(n^2)
冒泡排序和插入排序有很多相似的地方。但是比插入排序有稍多的开销。
2.插入排序（Insert Sort）
1)伪代码实现
for i = 2 : n
for(k = i; k > 1 and a[k] < a[k - 1]; k--)
swap a[k, k-1]
->排好序的前i个元素：a[1...i]
end
2)算法原理过程
初始无序元素：5, 3, 4, 9, 7, 2, 1, 6, 8
k = 2
3, 5, 4, 9, 7, 2, 1, 6, 8
k = 3
3, 4, 5, 9, 7, 2, 1, 6, 8
k = 4
3, 4, 5, 9, 7, 2, 1, 6, 8
k = 5
3, 4, 5, 7, 9, 2, 1, 6, 8
k = 6
3, 4, 5, 7, 2, 9, 1, 6, 8
3, 4, 5, 2, 7, 9, 1, 6, 8
3, 4, 2, 5, 7, 9, 1, 6, 8
3, 2, 4, 5, 7, 9, 1, 6, 8
2, 3, 4, 5, 7, 9, 1, 6, 8
k = 7
2, 3, 4, 5, 7, 1, 9, 6, 8
2, 3, 4, 5, 1, 7, 9, 6, 8
2, 3, 4, 1, 5, 7, 9, 6, 8
2, 3, 1, 4, 5, 7, 9, 6, 8
2, 1, 3, 4, 5, 7, 9, 6, 8
1, 2, 3, 4, 5, 7, 9, 6, 8
k = 8
1, 2, 3, 4, 5, 7, 6, 9, 8
1, 2, 3, 4, 5, 6, 7, 9, 8
k = 9
1, 2, 3, 4, 5, 6, 7, 8, 9
3)代码实现
#include <stdio.h>
void insert_sort(int arr[], int length)
{
int i, j;
int temp;
for(i = 1; i < length; ++i)
for(j = i; j > 0 && arr[j] < arr[j - 1]; --j)
{
temp = arr[j - 1];
arr[j - 1] = arr[j];
arr[j] = temp;
}
}
void print_array(int arr[], int length)
{
int i;
for(i = 0; i < length; ++i)
{
printf("%d ", arr[i]);
}
printf("\n\n");
}
int main(void)
{
int arr[] = {4, 3, 6, 1, 7, 2, 10, 5, 8, 9};
int length = 10;
printf("Before sorting, the array is:");
print_array(arr, length);
printf("After Insert Sorting, the ordered array is:");
insert_sort(arr, length);
print_array(arr, length);
return 0;
}
4)算法复杂度分析
时间复杂度：
最好情况为O(n)：即序列已经是升序排列，只需要进行比较操作n-1即可
最坏情况为O(n^2):即序列原来是降序排列，在进行升序排序时，需要n(n-1)/2次的比较，赋值操作是比较操作的次数加上(n-1)次，平均来说插入排序算法的时间复杂度为O(n^2)
空间复杂度：
额外空间O(1）
该算法是排序算法中非常基础的算法，在最坏情况下，算法复杂度为O(n^2),
当数据量比较小，或已接近排好序的情况，该算法是个比较好的选择
3 选择排序（Select Sort）
1)伪代码
for i = 1 : n
k = i
for j = i + 1 : n,
if a[j] < a[k]
k = j
->a[k]是a[i...n]中最小的元素
交换a[i], a[k]
-> 排好序的元素：a[1...i]
end
2）算法原理过程
初始无序数列：5, 2, 3, 1, 4
i = 1
[
k = 1
j = 2
因为 a[j] < a[k]
所以 k = j
k = 2
j = 3
因为 a[j] > a[k]
所以 k不变
k = 2
j = 4
因为 a[j] < a[k]
所以 k = j
k = 4
j = 5
因为 a[j] > a[k]
所以k不变
]
a[i]与 a[k]交换
最后结果为：1, 2, 3, 5, 4
i = 2
[
过程和上面类似
]
3)代码实现
#include <stdio.h>
#include <stdlib.h>
void select_sort(int arr[], int length)
{
int i, j, k;
int temp;
for(i = 0; i < length - 1; ++i)
{
k = i;
for(j = i + 1; j < length; ++j)
{
if(arr[j] < arr[k])
k = j;
}
temp = arr[i];
arr[i] = arr[k];
arr[k] = temp;
}
}
void print_array(int arr[], int length)
{
int i;
for(i = 0; i < length; ++i)
{
printf("%d ", arr[i]);
}
printf("\n\n");
}
int main(void)
{
int arr[] = {4, 3, 6, 1, 7, 2, 10, 5, 8, 9};
int length = 10;
printf("Before sorting, the array is:");
print_array(arr, length);
printf("After Insert Sorting, the ordered array is:");
select_sort(arr, length);
print_array(arr, length);
return 0;
}
4)算法复杂度分析
非稳定的，
空间复杂度：O(1)
时间复杂度：比较的次数,O(n^2)；交换的次数O(n)
选择排序算法的优点是交换的次数是最小的，因此对于交换的操作复杂度非常高的情况下，可以选择使用选择排序算法。
4 快速排序（Quick Sort）
1)算法原理
初始数列：A[0],A[1],......,A[N-1]
首先任意选取一个数据（通常选用第一个数据）作为关键数据(key)，
然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。
值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
1）设置两个变量I、J，排序开始的时候：I=0，J=N-1；
2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]；
3）从J开始向前搜索，即由后开始向前搜索（J=J-1即J--），找到第一个小于key的值A[j]，A[j]与A[i]交换；
4）从I开始向后搜索，即由前开始向后搜索（I=I+1即I++），找到第一个大于key的A[i]，A[i]与A[j]交换；
5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。
另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。
一趟快速排序的算法是：
2)算法实现过程
待排序的数组A的值分别是：49 38 65 97 76 13 27
（初始关键数据：key=49） 注意关键key永远不变，永远是和key进行比较，无论在什么位置，最后的目的就是把key放在中间，小的放前面大的放后面。
A[0] A[1] A[2] A[3] A[4] A[5] A[6]
49 38 65 97 76 13 27
进行第一次交换后：27 38 65 97 76 13 27 ( 按照算法的第三步从后面开始找，此时：J=6，A[i] = A[j])
进行第二次交换后：27 38 65 97 76 13 65 ( 按照算法的第四步从前面开始找>key的值，65>49,两者交换，此时：I=2 ,A[j] = A[i])
进行第三次交换后：27 38 13 97 76 13 65 ( 按照算法的第五步将又一次执行算法的第三步从后开始找,此时:J=5,A[i] = A[j])
进行第四次交换后：27 38 13 97 76 97 65 ( 按照算法的第四步从前面开始找大于key的值，97>49，两者交换，此时：I=3,J=5, A[j] = A[i] )
此时再执行第三步的时候就发现I=J=4，从而结束一趟快速排序，然后把A[i] = key后:27 38 13 49 76 97 65
那么经过一趟快速排序之后的结果是：27 38 13 49 76 97 65，即所有大于key=49的数全部在49的后面，所有小于key=49的数全部在49的前面。
3)代码实现
#include <stdio.h>
#include <stdlib.h>
int partition(int arr[], int low, int high)
{
int key = arr[low];
while(low < high)
{
while(low < high && arr[high] >= key)
{
high--;
}
arr[low] = arr[high];
while(low < high && arr[low] <= key)
{
low++;
}
arr[high] = arr[low];
}
arr[low] = key;
return low;
}
void __quick_sort(int arr[], int low, int high)
{
int mid = partition(arr, low, high);
if(mid - 1 > low)
{
__quick_sort(arr, low, mid - 1);
}
if(mid + 1 < high)
{
__quick_sort(arr, mid + 1, high);
}
}
void quick_sort(int arr[], int length)
{
__quick_sort(arr, 0, length - 1);
}
void print_array(int arr[], int length)
{
int i;
for(i = 0; i < length; i++)
{
printf("%d ", arr[i]);
}
printf("\n\n");
}
int main()
{
int arr[] = {49 ,38, 65, 97, 76, 13, 27};
int length = 7;
printf("Before sorting, the array is:");
print_array(arr, length);
printf("After Quick Sorting, the ordered array is:");
quick_sort(arr, length);
print_array(arr, length);
return 0;
}
4)算法复杂度分析
非稳定的算法
空间复杂度：O(lg(n))
时间复杂度：O(n.lg(n))
归并排序（Merge Sort）
1)算法原理
归并排序就是将两个（或者两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的，
然后再把有序的子序列合并为整体有序序列。
初始数列为：A[0],A[1],...,A[n-1]
算法实现的步骤如下：
1) 把0~n-1的数组分为左数组A[0,...,n/2]和右数组A[n/2 + 1,..., n-1];
2) 对左数组和右数组进行迭代排序
3) 将排好序的左数组和右数组进行合并，那么最后的整个数组就是有序的数组序列。
2)算法实现过程
算法实现过程示意图如下：
3)代码实现
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void merge(int arr[], int low, int mid, int high)
{
int length = high - low + 1;
int *pData = NULL;
int left = low;
int right = mid + 1;
int all = 0;
//分配空间给pData；
pData = (int*)malloc(sizeof(int) * length);
// assert(NULL != pData);
memset(pData, 0, length);
//把排好序的左数组和右数组合并后放入pData中；
while(left <= mid && right <= high)
{
if(arr[left] <= arr[right])
{
pData[all] = arr[left];
left++;
all++;
}
else
{
pData[all] = arr[right];
right++;
all++;
}
}
//移动剩下的数据
if(left <= mid)
{
memmove(&pData[all], &arr[left], sizeof(int) * (mid - left + 1));
}
if(right <= high)
{
memmove(&pData[all], &arr[right], sizeof(int) * (high - right + 1));
}
//把排好序的数列移动到原始数组中
memmove(&arr[low], pData, sizeof(int) * (high - low + 1));
free(pData);
}
void __merge_sort(int arr[], int low, int high)
{
int mid = 0;
if(low < high)
{
mid = low + (high -low) / 2;
__merge_sort(arr, low, mid);
__merge_sort(arr, mid + 1, high);
merge(arr, low, mid, high);
}
}
void merge_sort(int arr[], int length)
{
__merge_sort(arr, 0, length - 1);
}
void print_array(int arr[], int length)
{
int i;
for(i = 0; i < length; i++)
{
printf("%d ", arr[i]);
}
printf("\n\n");
}
int main(void)
{
int arr[] = {49 ,38, 65, 97, 76, 13, 27};
int length = 7;
printf("Before sorting, the array is:");
print_array(arr, length);
printf("After Merge Sorting, the ordered array is:");
merge_sort(arr, length);
print_array(arr, length);
return 0;
}
4)算法复杂度分析
归并排序算法可选择用于各种场合，
稳定的排序。即相等的元素的顺序不会改变
时间复杂度为O(nlogn) 这是该算法中最好、最坏和平均的时间性能。
空间复杂度为 O(n) 。
比较操作的次数介于(nlogn) / 2和nlogn - n + 1。
赋值操作的次数是(2nlogn)
归并排序比较占用内存，但却效率高且稳定的算法。
引自http://baike.baidu.com/view/19000.htm