基本排序算法的浅析与实现（c++）

好久没写了，最近恰好有时间，就把简单的排序算法实现一遍，复习一下吧。
1. 插入排序
基本思想：假设有a1,a2,a3,a4;且a4前面的a1

void insert_sort(int a[],int l)
{
    int i,j,temp;
    for(i=1;i<l;i++)
    {
        temp=a[i];
        for(j=i-1;j>=0&&temp<a[j];j--)
        {
            a[j+1]=a[j];//temp小于一次就往后挪一位 
        }
        a[j+1]=temp;//此时temp正好不小于a[j]，则temp找到了该放的位置 
    }
}
完整代码：
#include<iostream>

using namespace std;

void insert_sort(int a[],int l)
{
    int i,j,temp;
    for(i=1;i<l;i++)
    {
        temp=a[i];
        for(j=i-1;j>=0&&temp<a[j];j--)
        {
            a[j+1]=a[j];//temp小于一次就往后挪一位 
        }
        a[j+1]=temp;//此时temp正好不小于a[j]，则temp找到了该放的位置 
    }
}


print_arr(int b[],int length)
{
    for(int k=0;k<length;k++)
    {
        cout<<b[k];
    }
 } 
int main()
{
    int array[]={2,4,1,9,3,8,7,5,6,10,9};
    int len=sizeof(array)/sizeof(0);
    print_arr(array,len);
    cout<<endl;
    insert_sort(array,len);
    print_arr(array,len);
    return 0;
}

1. shell排序
   基本思想：shell排序是在直接插入排序的基础上建立的一种排序算法，插入排序在要排序的元素极多时效率极差，假设要对a10000排序，则它最坏情况下必须和前面的10000个数进行比较，前挪10000次；此时效率是极差的。而shell排序的改进之处在于使用一个分量如1000，先把10000个数分成10组，每组在进行插入排序，这样比较和挪动的次数为原来的1/10，
   然后在减小分量为100，此时10000个数被分成100组，对这100组再进行插入排序。再减小分量，重复之 ，知道分量为1，此时在进行插入排序，与直接插入排序算法不同的是，此时的大部分元素都排好序，而且未排好序的元素需要插入的跨度不是很大，如a10000也许只需和a9999比较一次就可以插入了。

#include<iostream>
using namespace std;

void shell_sort(int a[],int l)
{
    int i,j,temp;
    int h;
    for(h=l/2;h>=1;h=h/2)//处理分量，逐渐减小 注意这里h不能写成h>0,那样会变成死循环 
    {
        for(i=h;i<l;i=i+h)//这里就是插入排序 
        {
            temp=a[i];
            for(j=i-h;j>=0&&temp<a[j];j=j-h)//如果有100个数排序的话，这里插入排序的对象就是a[0],a[50],a[100] 
            {
                a[j+h]=a[j];
            }
            a[j+h]=temp;
        }
    }

}
void print_arr(int b[],int length)
{
    for(int k=0;k<length;k++)
    {
        cout<<b[k];
    }
    cout<<endl;
}
int main()
{
    int array[]={7,3,1,2,4,5,9,8,10,6};
    int len=sizeof(array)/sizeof(0);
    cout<<"shell排序前：\n";
    print_arr(array,len);
    shell_sort(array,len);
    cout<<"shell排序后：\n";
    print_arr(array,len);
    return 0;
}

1. 快速排序
   主要思想：使用一个partition函数处理数组，此函数的作用是选出一个随机数，把数组中小于这个随机数的元素都放到此元素的左边，把数组中大于此元素的值都放到此元素的右边，再把这个元素放到该放的位置。Quick_sort()函数里面递归调用partition()函数。快速排序是不稳定的排序，最好时间复杂度为O(nlogn),最坏时间复杂度为O（n^2）。

#include<iostream>
#include<time.h>
using namespace std;


int RandomInRange(int a,int b)//使用c++ rand()获取随机数必须结合srand(time(NULL)),rand()是依靠初始化值产生随机数
{                             
    if(b>a)
    {
        srand(time(NULL));    //而srand(time(NULL))初始化初始值，使每次产生的随机数不一样
        return a+rand()%(b-a+1);//产生a~b之间的随机数

     } 

}

void swap(int *a,int *b)//交换 
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}

int partition(int data[],int length,int start,int end)//关键算法，使得元素按a1,a2,a3,a4...small...an-2,an-1,an排列，返回small的位置small大于之前的元素，小于之后的元素 
{
    if(data==NULL||length<=0||start<0||end>length)
    {
        cout<<"输入错误!"<<endl;
    }
    int index=RandomInRange(start,end);//产生随机数 
    swap(&data[index],&data[end]);
    int small=start-1;
    for(int i=start;i<end;i++)
    {

        if(data[i]<data[end])
        {
            ++small; 
            if(small!=i)//i走到small前面的时候，i>small,需要交换，使得small依次排列 
            {
                swap(&data[i],&data[small]);
            }   
        } 
    }
    ++small;
    swap(&data[small],&data[end]);
    return small;
}
void quick_sort(int data[],int length,int start,int end)//递归排序 
{
    if(start==end)//递归结束条件 
    {
        return;
    }
    int index=partition(data,length,start,end);
    if(index>start)
    {
        quick_sort(data,length,start,index-1);  
    }
    if(index<end)
    {
        quick_sort(data,length,index+1,end);
     } 


}


print_arr(int b[],int len)//打印 
{
    for(int k=0;k<len;k++)
    {
        cout<<b[k];
    }
    cout<<endl;
}
int main()
{
    int array[]={2,3,1,4,5,10,9,7,8,6};
    int len=sizeof(array)/sizeof(array[0]);
    int start=0;
    int end=start+len-1;
    cout<<"快速排序前的元素为："<<endl;
    print_arr(array,len);
    quick_sort(array,10,0,9);
    cout<<"快速排序后的元素为："<<endl; 
    print_arr(array,len);
    return 0;
}

四．选择排序
基本思想：先假设第一个元素有序，然后把2到n-1个元素依次和第一个元素比较，如果小于第一个元素则交换之，此时第一个元素已经排好序了，然后在排第二个元素，把3到n-1个元素和第二个元素比较，如果小于则交换之。个人感觉这种方法比较笨，时间复杂度为O（n^2）,但是比较稳定。

#include<iostream>
using namespace std;

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

void select_sort(int a[],int l)
{
    for(int i=0;i<l;i++)
    {
        int temp=a[i];
        for(int j=i+1;j<l;j++)
        {
            if(a[j]<temp)
            swap(a[j],temp);

         }
         a[i]=temp; 
    }
 } 

 void print_arr(int array[],int length)
 {
    for(int k=0;k<length;k++)
    {
        cout<<array[k];
     }
     cout<<endl;
 }
int main()
{
    int array[]={6,4,2,3,1,11,7,8,5,10,9};
    int len=sizeof(array)/sizeof(array[0]);
    cout<<"选择排序前的元素：\n";
    print_arr(array,len);
    select_sort(array,len);
    cout<<"选择排序后的元素：\n";
    print_arr(array,len); 
    return 0;
 }

五．冒泡排序
相邻的两个数比较，如a[j+1]

#include<iostream>
using namespace std;


void swap(int &a,int &b)
{
    a=a^b;
    b=b^a;
    a=a^b;
}
void bubble_sort(int a[],int l)
{
    for(int i=0;i<l;i++)
    {
        for(int j=0;j<l;j++)
        {
            if(a[j+1]<a[j])
            {
                swap(a[j+1],a[j]);
            }
        }
    }
}


print_arr(int b[],int length)
{
    for(int k=0;k<length;k++)
    {
        cout<<b[k];
     }
     cout<<endl; 
}
int main()
{

    int array[]={2,1,3,5,4,6,8,7,9,10};
    int len=sizeof(array)/sizeof(array[0]);
    cout<<"冒泡排序前的元素：\n";
    print_arr(array,len);
    bubble_sort(array,len);
    cout<<"冒泡排序后的元素为：\n";
    print_arr(array,len);

    return 0;
}

6.归并排序
主要思想：对于一个给定序列进行归并排序，借助一个数组temp[]，先把这个序列递归地分成两两一组（二路归并），比较之，小的结果存放在temp[]中，再递归回到上一层，再比较。也许这样说你还是不懂，那就别看上面的，来看下面这个图。结合代码来看这个图更容易理解。

#include<iostream>
#define N 100
using namespace std;
typedef int DataType;

//合并data[begin...mid]和data[mid+1.end]到temp[begin,end]中,然后复制到data[begin,end]中
void merge(DataType *data,DataType *temp,int begin,int mid,int end)
{
    int i,j,k;
    for(i = begin,j=mid+1,k = begin;i<=mid&&j<=end;k++)
    {
        if(data[i]<=data[j]) 
            temp[k] = data[i++];
        else
            temp[k] = data[j++];
    }
    if(i<=mid)
        while(i<=mid)
        temp[k++] = data[i++];
    else
        while(j<=end)
        temp[k++] = data[j++];
    for(i=begin;i<=end;i++)
        data[i] = temp[i];
}

//归并排序
void Msort(DataType *data,DataType *temp,int begin,int end)
{
    if(begin==end)
        data[begin] = data[begin];
    else
    {
        int mid = (begin+end)/2;
        Msort(data,temp,begin,mid);
        Msort(data,temp,mid+1,end);
        merge(data,temp,begin,mid,end);
    }
}
print_arr(DataType arr[],DataType len)
{
    for(int k=0;k<len;k++)
    {
        cout<<arr[k];
    }
    cout<<endl;
}

int main()
{

    //data存储原数据和排序后的数据，temp为辅助数据
    DataType data[N],temp[N];
    int n;
    cout<<"请输入元素个数：";
    cin>>n;
    int i;
    cout<<"请输入待排序的元素："<<endl;
    for(i=0;i<n;i++)
    cin>>data[i];
    cout<<"归并排序前的元素："<<endl;
    print_arr(data,n);
    Msort(data,temp,0,n-1);
    cout<<"归并排序后的元素："<<endl;
    print_arr(data,n);
system("pause");
return 0;
}

7.关于对的理解和堆排序
关于队的理解这篇博客写的很详细：http://blog.csdn.net/morewindows/article/details/6709644/
我总结关于堆主要有以下几点需要注意：
1. 一般都用数组来表示堆，i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。
2. 结点插入，插入结点的时先把瑶插入的结点插入到堆的最下面（数组最后一个元素），然后就是一个向上调整的过程，涉及函数是MinHeapFixup（）。
3. 结点删除，结点删除时，规定总是删除堆顶元素，所以删除a[0]，然后把最后一个元素放到a[0]，后面就是一个向下的调整过程，对应的函数MinHeapFixdown（）。
例如要把数组a[]={9,12,17,30,50,20,60,65,4,49}，堆化，从第一个非叶子结点向下调整。

#include<iostream>
using namespace std;

swap(int *a,int *b)
{
    *a=*a^*b;
    *b=*b^*a;
    *a=*a^*b;
}
//建立堆结点 

//新加入i结点，其父结点为（i-1）/2

//插入一个结点，总是先把他放到最后，所以他是一个向上调整的过程

void MinHeapFixup(int a[],int i) 
{
    int j,temp;
    temp=a[i];
    j=(i-1)/2;    //父结点
    while(j>=0&&i!=0)
    {
        if(a[j]<temp)   //如果父结点小于当前结点，则此节点不用调整 
            break;
        a[i]=a[j];      //父结点大于当前结点，把父结点和当前结点交换 
        i=j;            //更新当前结点的位置 
        j=(i-1)/2;     //更新当前结点的父结点的位置 
     } 
     a[i]=temp;
 } 

 void MinHeapAddNumber(int a[],int n,int nNum)
 {
    a[n]=nNum;             //插入一个结点，先把他放到最后，然后再向上调整 
    MinHeapFixup(a,n);
  } 

 //删除堆结点 
 //  从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2 
 //堆的删除总是删除a[0],然后把最偶一个结点放到a[0]，最后就向下调整就行了 
 void MinHeapFixdown(int a[],int i,int n)
 {
    int j,temp;
    temp=a[i];
    j=2*i+1;
    while(j<n)
    {
        if(j+1<n&&a[j+1]<a[j]) //再左右孩子中找到最小的 
            j++;
        if(a[j]>temp)
            break;
        a[i]=a[j]; //向下调整 
        i=j;
        j=2*i+1; 
     }
     a[i]=temp; 
  } 

  void MinHeapDeleteNumber(int a[],int n)
  {
        swap(a[0],a[n-1]);          //删除第一个元素 ，把最后一个元素放到第一个元素的位置 
        MinHeapFixdown(a,0,n-1);  //向下调整 
   } 

//建立最小堆
void MakeMinHeap(int a[],int n)  //a[]数组已经是模拟好的堆， 
{
    for(int i=n/2-1;i>=0;i--) //从第一个非叶子结点开始向下调整 
    {
        MinHeapFixdown(a,i,n);
    }
 } 

//堆排序
void heap_sort(int a[],int len)
{
    for(int i=len-1;i>=1;i--)
    {
        swap(a[i],a[0]);
        MinHeapFixdown(a,0,i);
    }
 } 

print_arr(int a[],int len)
{
    for(int i=0;i<len;i++)
    {
        cout<<a[i]<<',';
    }
    cout<<endl;
}
int main()
{
    int array[]={9,12,17,30,50,20,60,65,4,49};
    int len=sizeof(array)/sizeof(array[0]);
    cout<<"堆排序前的元素是："<<endl;
    print_arr(array,len);
    MakeMinHeap(array,len); 
    heap_sort(array,len);
    cout<<"堆排序后的元素是："<<endl;
    print_arr(array,len);

    return 0;
 }