归并排序
现在的归并排序一般都是二路归并,多路归并用在外部排序比较多一点。
归并排序就是从头遍历两个有序的序列,然后放到第三个空列表里,依次放如两个列表头较小的那个元素。
下面是代码:
//
// main.cpp
// MergeSort
//
// Created by Alps on 14-8-2.
// Copyright (c) 2014年 chen. All rights reserved.
//
#include <iostream>
#define ElementType int
using namespace std;
void Merge(int *A, int left, int right, int center, int *TmpArr){
int leftPtr = left, rightPtr = center;
int i = left;
while (leftPtr < center && rightPtr <= right) {
if (A[leftPtr] <= A[rightPtr]) {
TmpArr[i++] = A[leftPtr];
leftPtr++;
}else{
TmpArr[i++] = A[rightPtr];
rightPtr++;
}
}
if (leftPtr >= center) {
while (rightPtr <= right) {
TmpArr[i++] = A[rightPtr];
rightPtr++;
}
}
if (rightPtr > right) {
while (leftPtr < center) {
TmpArr[i++] = A[leftPtr];
leftPtr++;
}
}
for (int j = left; j <= right ; j++) {
A[j] = TmpArr[j];
}
}
void MSort(int *A, ElementType *TmpArr, int left, int right){
if (left < right) {
int center = (left+right)/2;
MSort(A, TmpArr, left,center);
MSort(A, TmpArr, center+1, right);
Merge(A,left, right, center+1, TmpArr);
}
}
void MergeSort(int *A, int length){
ElementType TmpArr[length];
int left = 0,right = length-1;
MSort(A, TmpArr, left, right);
for (int i = 0; i < length; i++) {
printf("%d ",A[i]);
}
printf("\n");
}
int main(int argc, const char * argv[])
{
ElementType A[] = {24, 13, 26, 1, 2, 27, 38, 15};
MergeSort(A, sizeof(A)/sizeof(ElementType));
return 0;
}
快速排序
快速排序是一个用的很多的排序算法,它的时间复杂度平均为O(NlogN),但是重要的是要选择好正确的flag元素。我认为和归并正好相反,归并是先分成很多段,然后把各个段合并起来,快排是把一个长序列不断的有序的分成很多段,直接就排序好了。
下面时代码:
//
// main.cpp
// QuickSort
//
// Created by Alps on 14-8-2.
// Copyright (c) 2014年 chen. All rights reserved.
//
#include <iostream>
#define ElementType int
void QuickSort(ElementType *A, int left, int right){
if (left < right) {
int i = left, j = left;
int mid = right;
for (int k = left; k < right; k++) {
if (A[j] <= A[mid]) {
A[i] += A[j];
A[j] = A[i]-A[j];
A[i] = A[i]-A[j];
i++;
j++;
}else{
j++;
}
}
A[i] = A[i]+A[mid];
A[mid] = A[i]-A[mid];
A[i] = A[i]-A[mid];
mid = i;
QuickSort(A, left, mid-1);
QuickSort(A, mid+1, right);
}
}
int main(int argc, const char * argv[])
{
ElementType A[] = {24, 13, 26, 1, 2, 27, 38, 15};
int length = sizeof(A)/sizeof(ElementType);
QuickSort(A, 0, length-1);
for (int i = 0; i < length; i++) {
printf("%d ",A[i]);
}
printf("\n");
return 0;
}
冒泡排序
这个排序算法是最基础的了,就简单的直接说下,就是每次遍历把最大的数字放到序列最后,这样不断遍历,就可以了,所以时间复杂度比较高是O(N2)。
代码:
//
// main.cpp
// BubbleSort
//
// Created by Alps on 14-8-2.
// Copyright (c) 2014年 chen. All rights reserved.
//
#include <iostream>
#define ElementType int
void BubbleSort(int *A, int length){
for (int i = 0; i < length; i++) {
for (int j = 0; j < length-i-1; j++) {
if (A[j] > A[j+1]) {
A[j] += A[j+1];
A[j+1] = A[j]-A[j+1];
A[j] = A[j] - A[j+1];
}
}
}
}
int main(int argc, const char * argv[])
{
ElementType A[] = {24, 13, 26, 1, 2, 27, 38, 15};
int length = sizeof(A)/sizeof(ElementType);
BubbleSort(A, length);
for (int i = 0; i < length; i++) {
printf("%d ",A[i]);
}
printf("\n");
return 0;
}