排序算法

#include<iostream>
using namespace std;

/*交换排序--冒泡排序
基本思想：在要排序的一组数中，对当前还未排序的全部数，自上而下对相邻的两个数依次进行比较和调整，
让较大的数往下沉淀，较小的数往上冒

对冒泡排序法的改进方法是加入一标志性变量exhange，用于标志某一趟排序中是否有数据交换，如果进行某一趟排序
没有进行数据交换，则说明数据已经按要求排列好了，可立即结束排序。

//设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位，故
在进行下一趟排序时只要扫描到pos位置即可。
*/
void print(int a[],int n,int i){
cout<<i<<endl;
for(int j=0;j<n;j++){
cout<<a[j]<<"  ";
}
cout<<endl;
}

void bubbleSort(int a[],int n){
int i=n-1;//设置初始时，最后位置保持不变
while(i>0){
int pos=0;//每趟开始无交换记录
for(int j=0;j<i;j++){
if(a[j]>a[j+1]){
pos=j;
int tmp=a[j+1];a[j+1]=a[j];a[j]=tmp;
}
}
i=pos;
print(a,n,i);
}
}

#include<iostream>
using namespace std;

/**************************************
交换排序--快速排序
基本思想：1选择一个基准元素，通常选择第一个元素或者最后一个元素
2通过一趟排序将待排序的记录分割成独立的两部分，其中一
部分元素均比基准值小，另一部分元素的值比基准元素值大。
3此时基准元素在其排好顺序后的正确位置。
4然后分别对这两部分记录用同样的方法继续进行排序，直到
整个序列有序。
***************************************/

void print(int a[],int n,int i){
cout<<i<<endl;
for(int j=0;j<n;j++){
cout<<a[j]<<"  ";
}
cout<<endl;
}

void swap(int &a,int &b){
int tmp;
tmp=a;
a=b;
b=tmp;
}

/***********************************
Function:partition
Describe:
Call:swap
print
Input:int a[] 要排序的数组值
int low 数组左边值，低下标值
int high 数组右边值,高下标值
Return:low 返回基准元素的位置
************************************/
int partition(int a[],int low,int high){
int privotKey=a[low];//基准元素的值
while(low<high){//从表两端交替向中间扫描，当low>=high时完毕
while (low<high&&privotKey<=a[high])--high;
swap(a[low],a[high]);
while(low<high&&privotKey>=a[low])++low;
swap(a[low],a[high]);
}
print(a,8,1);
return low;
}
/*********************************************
Call:partition
Describe:递归调用，划分数组，直到划分至数组长度为1，也就排好序列了
Input：a[] 排序数组
int low 数组的低位坐标
int high 数组的高位坐标
**********************************************/
void quickSort(int a[],int low,int high){
if(low<high){
int privotloc=partition(a,low,high);//将表一分为二
quickSort(a,low,privotloc-1);
quickSort(a,privotloc+1,high);

}
}
//对快排的改进：只对长度大于k的子序列递归调用快速排序法，
//    让原序列基本有序，然后再对整个基本有序序列用插入算法
//排序。实践证明，改进后的算法时间复杂度有所降低，且k取值
//为8左右的时候，改进算法性能最佳。

int main(){
//int a[8]={3,1,5,7,2,4,9,6};
int a[4]={3,1,5,};
quickSort(a,0,2);
}

#include<iostream>
using namespace std;

/*堆排序--初始时把要排序的n个数看做是一颗顺序存储的二叉树（一维数组存储二叉树）
调整它们的存储顺序使之成为一个堆，将堆顶元素输出，得到n个元素中最小或最大的元素，
这时堆的根节点的数最小或最大。然后对前面的n-1个元素重新调整顺序使之成为一个新堆，输出
堆顶端元素，得到n个元素中次小（或次大）元素。依次类推，输出堆顶端元素，直到只有两个节点
的堆，并对它们作交换，最后得到n个节点的有序序列。称这个过程为堆排序。

两个问题：1如何将n个待排序的数建成堆2输出堆顶元素后，怎样调整n-1个元素的位置，使之成为新堆。
*/
void print(int a[],int n,int i){
cout<<i<<endl;
for(int j=0;j<n;j++){
cout<<a[j]<<"  ";
}
cout<<endl;
}

//堆排序的两个过程，一是建立堆，二是堆顶与堆的最后元素交换位置后，建立新堆。
//1建堆渗透函数
void heapAdjust(int h[],int s,int length){
int tmp=h[s];//s根节点位置
int child=2*s+1;//左节点位置孩子
while(child<length){
if(child+1<length&&h[child]<h[child+1]){
//如果右孩子比左孩子大，找到比当前待调整节点大的孩子节点
++child;
}
if(h[s]<h[child]){
//如果较大的孩子节点大于父节点
h[s]=h[child];//把较大子节点与父节点交换位置
s=child;//重设s，即待调整节点的位置
child=2*s+1;
}
else{//如果当前调整的节点大于它的左右孩子则不需要调整直接退出
break;
}
h[s]=tmp;//当前节点放到比它大的孩子节点位置
}
}

//初始堆调整。将h[0...n-1]建成堆
void buildingHeap(int a[],int length){
//最后一个节点的位置i=(length-1)/2
for(int i=(length-1)/2;i>=0;i--)
heapAdjust(a,i,length);
}

void heapSort(int h[],int length){
//初始堆
buildingHeap(h,length);
//从最后一个元素开始对序列进行调整
for(int i=length-1;i>=0;i--){ int tmp=h[i];h[i]=h[0];h[0]=tmp;
//每次交换堆顶元素之后都要对堆进行调整
heapAdjust(h,0,i);}
print(h,8,1);
}

int main(){
int a[8]={3,1,5,7,2,4,9,6};
heapSort(a,8);
}
　　

// InsertSort.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>

using namespace std;
/*插入排序：直接插入排序，希尔排序
选择排序：简单选择排序，堆排序
交换排序：冒泡排序，快速排序
归并排序，基数排序
时间复杂度来说：
1.平方阶(O(n^2)):简单排序，直接插入，直接选择，冒泡排序
2.线性对数阶(O(nlogn)):快速排序，堆排序和归并排序
3.（O(n^1-2)）希尔排序
4.线性排序(O(n)):基数排序
*/

/*直接插入排序，将一个记录插入到已排序好的有序列表中，从而得到一个新的记录数加1的有序表。
要设立哨兵，作为临时存储和判断数组边界之用。
*/

template <class T>
//c++中计算字符串长度用strlen();没有直接计算数组长度的函数
//定义一个模板函数，实现数组计算。
int getArrayLen(T& array)

{//使用模板定义一 个函数getArrayLen,该函数将返回数组array的长度

return (sizeof(array) / sizeof(array[0]));

}

void print(int a[],int n,int i){
cout<<i<<endl;
for(int j=0;j<n;j++){
cout<<a[j]<<"  ";
}
cout<<endl;
}

//a[8]={3,1,5,7,2,4,9,6}
void InsertSort(int a[],int n){
for(int i=1;i<n;i++){
if(a[i]<a[i-1]){ //若第i个数大于第i-1个数，直接插入，小于的话移动有序表后插入
int j=i-1;
int x=a[i];//复制为哨兵
while(x<a[j]){//移动有序表
a[j+1]=a[j];
j--;
}
a[j+1]=x;
}//if
print(a,n,i);
}//for
}

int _tmain(int argc, _TCHAR* argv[])
{
int a[8]={3,1,5,7,2,4,9,6};
int n=getArrayLen(a);
InsertSort(a,n);
print(a,n,n);
return 0;
}