排序算法整理

参考书籍：算法设计与分析基础（第二版） Anany Levtin著，潘彦译，清华大学出版社

编译环境VC++2010

1. 选择排序

   每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数，选择排序是在位不稳定的排序方法。

#include "stdafx.h"
#include <iostream>
using std::cout;
using std::endl;
#include <iomanip>
using std::setw;
#include <cstdlib>
using std::system;
int* SelectionSort(int *array,int len);
/*使用模板定义一个函数getArrayLen,该函数将返回数组array的长度*/
template <class T>
int getArrayLen(T& array)
{
    return (sizeof(array) / sizeof(array[0]));
}
      
int _tmain(int argc, _TCHAR* argv[])
{
    int FormerArray[]={89,45,68,90,29,34,17};   
    int len=getArrayLen(FormerArray);//参数是数组名时返回的是数组所占字节数
    int *SortArray;
    SortArray=SelectionSort(FormerArray,len);
    for(int i=0;i<len;i++)
        cout<<setw(5)<<SortArray[i];
    cout<<endl;
    system("pause");
    return 0;
}
      
/*选择排序函数*/
int* SelectionSort(int *array,int len)
{
    int min,swap;
    //int len=getArrayLen(array);这个返回的是指针字节的大小，不是数组所占的字节数。数组长度最好传递过来！
    for(int i=0;i<len-1;i++)
    {
        min=i;
        for(int j=i+1;j<len;j++)
            if(array[min]>array[j])
                min=j;  
        swap=array[i];
        array[i]=array[min];
        array[min]=swap;
    }
    return array;
}

2. 冒泡排序

#include "stdafx.h"
#include <iostream>
using std::endl;
using std::cout;
#include <iomanip>
using std::setw;
#include<cstdlib>
using std::system;  
int* BubbleSort(int *,int);
     
template <class T>
int getArrayLen(T& array)
{
    return (sizeof(array)/sizeof(array[0]));
}
     
int _tmain(int argc, _TCHAR* argv[])
{
    int FormerArray[]={89,45,68,90,29,34,17};
    int *SortArray;
    int length=getArrayLen(FormerArray);
    SortArray=BubbleSort(FormerArray,length);
    for (int i=0;i<length;i++)
        cout<<setw(5)<<SortArray[i];
    cout<<endl;
    system("pause");
    return 0;
}
     
int* BubbleSort(int *array,int length)
{
    int temp;
    for (int i=0;i<length-1;i++)
    {
        int flag=0;//如果一次遍历没有顺序改变，就说明这个数组已经有序，不需要再遍历了
        for (int j=length-1;j>i;j--)
        {
            if(array[j]<array[j-1])
            {
                temp=array[j];
                array[j]=array[j-1];
                array[j-1]=temp;
                flag=1;
            }
        }
        if(flag==0)
            break;
    }
    return array;
     
}

3.  合并排序

#include<iostream>
#include <iomanip> 
using namespace std;

void MergeSort(int *array, int begain, int end);//递归函数
void Merge(int *array, int begain, int middle, int end);//合并排序函数

template <class T> //获得字符串常数的模板方法
int GetArrayLen(T& array)
{
	return (sizeof(array)/sizeof(array[0]));
}

void main()
{
	int i;
	int array[] = {5,6,2,3,1,4,8,9,7,0};
	int length = GetArrayLen(array);
	for (i = 0; i < length; i++)
		cout<<setw(3)<<array[i];
	cout<<endl;
	MergeSort(array, 0, length - 1);
	for (i = 0; i < length; i++)
		cout<<setw(3)<<array[i];
	cout<<endl;
	system("pause");
}

void MergeSort(int *array, int begain, int end)
{
	int middle;
	if (begain >= end)
		return ;
	else
	{
		middle = (begain + end) / 2;
		MergeSort(array, begain, middle);
		MergeSort(array, middle + 1, end);
		Merge(array, begain, middle, end);
	}
}

void Merge(int *array, int begain, int middle, int end)
{
	int i  = 0, j = 0, k = 0, count = 0;
	int lenL = middle-begain+1;
	int lenR = end-middle; 
	int *arrayL = new int[lenL];
	int *arrayR = new int[lenR];
	array += begain;
	//分别将两个合并数组复制给另外两个数组
	for (i = 0; i<lenL; i++)
		arrayL[i]= array[i];
	for (j = 0; j<lenR; j++)
		arrayR[j]= array[j + lenL];
	i = 0;
	j = 0;
	//比较两个有序数组
	while (i < lenL && j < lenR)
	{
		if(*(arrayL+i) < *(arrayR+j))
			* array++  = * ( arrayL + i++ ); 
		else
			* array++  = * (arrayR + j++ );
	}	
	//处理剩余的数
	if ( i == lenL)
	{
		for(k = j; k < lenR; k++)
			* array++ = * (arrayR + k) ; 
	}
	else
	{
		for(k = i; k < lenL; k++)
			* array++  = * (arrayL + k) ; 
	}
	//释放内存
	delete [] arrayL;
	delete [] arrayR;
}