基本算法

1.冒泡排序：

    #include <iostream>

using namespace std;

 

void BubbleSort(int * p,int iLength) // p为数组的地址，iLength为数组的长度

{

for( int i = 0 ; i < iLength ; ++i )

{

for( int j = 0 ; j < iLength -1 - i  ;  ++j )

{

if( p[j] > p[ j+1 ] )

{

int iTemp = p[j];

p[j] = p[j+1];

p[j+1] = iTemp;

}

}

}

}

 

void ShowArray(int * p, int iLength)

{

for(int i = 0 ; i < iLength ; i++)

{

cout<<p[i]<<endl;

}

}

void main()

{

int const iLength = 6;

int a[iLength] = {1,5,9,2,4,8};

 

cout<<"排序前："<<endl;

ShowArray(a,iLength);

BubbleSort(a,iLength);

 

cout<<"排序后："<<endl;

ShowArray(a,iLength);

 

system("pause");

}

2.插入排序：

     #include <iostream>

using namespace std;

 

有不必要的赋值操作

//void InsertSort(int *list,int size)//参数list描述待排序数组的首地址，

////参数size描述待排序数组元素个数

//{

////循环控制变量，i用来控制待排序列下标，j用来控制已排好序列下标

//int i =  0 , j = 0;

//int iTemp = 0;//临时存储区域，用来存中间值

//for ( i=1; i<size; ++i )

//{

//iTemp = list[i];//把将要排序的数据存储在iTemp这个临时变量内

//for (  j=i-1;j>=0;--j )

//{

//if ( list[j]>iTemp )//已拍好序的数组的最后一个元素，也就是说已

////排好序的数组中的最大的元素 > iTemp中的元素

//{

//list[j+1] = list[j];//将最大元素下移一个位置

//}

//else  

//break;//否则跳出内层循环

//}

//list[j+1] = iTemp;//将iTemp插入到已排好序的序列中

//}

//}

 

 

//按照SWF文件的思路

void InsertSort( int _iArray [] , int _iLength)

{

int i = 0 , j = 0;

for( i = 1 ; i < _iLength ; ++i )

{

if( _iArray[i] < _iArray[i-1] )

{

int iTemp = _iArray[i];

for( j = i - 1 ; j >= 0 ; --j )

{

if( iTemp < _iArray[j] )

{

_iArray[j+1] = _iArray[j];

 

}

else

{

_iArray[j+1] = iTemp;

break;

}

if(j==0)

{

_iArray[j] = iTemp;

}

}

}

}

}

void ShowArray(int * pArray , int iLength)

{

for(int i = 0 ; i < iLength ; ++i)

{

cout<<pArray[i]<<endl;

}

}

void main()

{

const int iLength = 7;

int a[iLength] = { 16,-9,73,0,-8,1,123 };

 

cout<<"排序前："<<endl;

ShowArray(a,iLength);

 

InsertSort(a,iLength);

 

cout<<"排序后："<<endl;

ShowArray(a,iLength);

 

system("pause");

}

3.归并排序：针对两个已经排好顺序的数组，组合到一起排序生成新的数组。

代码如下：

//#include <iostream>

//using namespace std;

//

============归并排序=======================

//

//void Merge(int c[], int d[], int l, int m, int r)// 把c[l:m]  和 c[m:r] 归并到d [ l : r ] .

//{

//int iArray1Start = l,// 第一段起始游标

// iArray1End=m,// 第一段结束游标

// iArray2Start = m+1,// 第二段起始游标

// iArray2End=r,// 第二段结束游标

// k = l;// 新数组的下标

//

//while ((iArray1Start <= iArray1End) && (iArray2Start <= iArray2End))//只要两个段中没有段头游标>段尾游标

//{

//if (c[iArray1Start] <= c[iArray2Start])

//d[k++] = c[iArray1Start++];

//else

//d[k++] = c[iArray2Start++];

//}

//

//if (iArray1Start > iArray1End) // 考虑余下的部分

//{

//for (int i = iArray2Start; i <=iArray2End; i++)

//d[k++] = c[i];

//}

//else

//{

//for (int i = iArray1Start; i <= iArray1End; i++)

//d[k++] = c[i];

//}

//}

//

//void MergePass(int x[], int y[], int s, int n)

//{

//int i = 0;// 归并大小为s的相邻段

//while (i <= n - 2 * s)// 若数组中元素个数能分成大小为s的两段儿

//{

//Merge(x, y, i, i+s-1, i+2*s-1);// 归并两个大小为s的相邻段

//i = i + 2 * s;//之前的都归并完了，让i = 后面的元素，继续以s为段，去归并

//}

//if (i + s < n)// 剩下不足2个元素

//{

//Merge(x, y, i, i+s-1, n-1);

//}

//else

//{

//for (int j = i; j <= n-1; j++)

//y[j] = x[j];// 把最后一段复制到y

//}

//}

//

//

//void MergeSort(int a[], int n)// 使用归并排序算法对a[0:n-1] 进行排序

//{

//int *b = new int [n];//动态分配一个具有n个数据的数组

//int s = 1; // 数组将被分成若干小数组，我们称之为一"段"的大小

//while (s < n)

//{

//MergePass(a, b, s, n); // 从a归并到b

//s += s;

//memcpy(a, b, n*4);//将a按上一次的s段排好序之后，我们存到了b中，并把b赋值给a

//}

//delete b;

//b=NULL;

//}

//

//void PrintList(int *pArray, int size)

//{

//for(int index = 0; index < size; index++)

//{

//cout << pArray[index] << ',';

//}

//cout << endl;

//}

//

//void main()

//{

//const int iLength = 9;

//int iArray[iLength] = { 110, 44,36, 34, 28, 222, 115, 7,9 };

////int iArray[iLength] = {-2,3,52,1,-4,22,12,0,-1,76};

//

//cout << "排序前序列为:" ;

//PrintList(iArray, iLength);

//

//MergeSort(iArray, iLength);// 进行归并排序

//

//cout << "排序后序列为:";

//PrintList(iArray, iLength);

//

//system("pause");

//}

 

 

#include <iostream>

using namespace std;

 

//======归并排序，通常对两个已经有序的数组进行，

//      归并为一个有序数组======

#define _out   //宏,用来描述函数参数的传递方向

#define _in    //

 

void Merge( _out int* & pOutArray,

    _out int & _OutArrayLength,

    _in int _iArray1[], _in const int & _iLength1 ,

    _in int _iArray2[], _in const int & _iLength2 )

{

_OutArrayLength = _iLength1+_iLength2;

pOutArray = new int[_OutArrayLength];

memset(pOutArray,0,_OutArrayLength*sizeof(int));

 

//-----补全函数体-----

int i = 0 , j = 0; //控制变量

int index = 0; //新数组下标

while(true)

{

//归并完毕

if( i == _iLength1 && j == _iLength2 )

break;

 

//第一个数组没有元素了

if( i >= _iLength1 && j < _iLength2 )

{

pOutArray[index] = _iArray2[j];

index++;

j++;

continue;

}

 

//第二个数组没有元素了

if( j >= _iLength2 && i < _iLength1 )

{

pOutArray[index] = _iArray1[i];

index++;

i++;

continue;

}

 

 

//

if( _iArray1[i] <= _iArray2[j] )

{

pOutArray[index] = _iArray1[i];

i++;

index++;

}

else

{

pOutArray[index] = _iArray2[j];

j++;

index++;

}

 

}

 

}

 

void main()

{

const int iLength1 = 5;

const int iLength2 = 7;

int iArray1[iLength1] = {1,13,15,17,19};

int iArray2[iLength2] = {2,13,17,28,30,42,84};

 

int * pResult = NULL;

int iOutArrayLength = 0;

Merge(pResult,iOutArrayLength,iArray1,iLength1,iArray2,iLength2);

 

for(int i = 0 ; i < iOutArrayLength ; ++i)

cout<<pResult[i]<<endl;

 

system("pause");

}

4.基数排序：排序个位十位百位。

5.希尔排序：比较特殊，处理步骤少。

其它排序算法将文件直接拖入浏览器中即可查看。