2020-1-7-各种经典排序算法

#include<iostream>
using namespace std ;
#include<stdlib.h>
#include<time.h>
typedef int datetype ;  // 数据类型
/*****************************************************************************/
            /*  经典排序算法 */
int   insert_sort1( datetype  *Arr,int n ) ;             /*  插入排序  */
void  insert_sort2( datetype *Arr, int n ) ;             /*  插入排序  */
void  select_sort1( datetype *Arr, int n) ;             /*  选择排序  */
void  select_sort2( datetype *Arr,int n ) ;             /*  选择排序2 */
void  Bubblesort(datetype *base ,int n) ;                /*  冒泡排序  */
void Merger_sort(datetype *Arry,int left ,int right)  ;  /*  递归排序  */
int fold_find(datetype *Arr,int low ,int high,int date); /*  折半查找  */
void  quick_sort(datetype *base,int len) ;               /*   快速排序  */


/*****************************************************************************/
 /* 
            插入排序 （从小到大）
    思想：    Arr[ 0 -n ]
         1）： 从数组第二个位置Arr[i]开始： 与前面元素比较，如果比前一个元素大 ，结束 。   i++ ，继续 1） 否则进入2）
         2) :   数组元素依次后移 a[i++]=aa[i] , 直到 遇到比它小的元素结束 。 然后 到1) ,直到 i =n结束 
  
 */
int insert_sort1(datetype  *base,int n)
{
  int i, j;
  datetype flag ;         // 标志位
  for(i=1;i<n;i++)
  {
     flag=base[i];     
     j=i-1;
     while(flag<base[j]&&j>=0)    //   j>=0 这个条件一定要加上， 这个bug ，我查了很久才发现
     {
       base[j+1]=base[j];
       j--;
     }
     base[j+1]=flag;
  }
}

/*   
        插入排序 (优化 ：减少元素位置移动)
*/

void  insert_sort2( datetype *Arr, int n)  
{
   int i,j;
   for(i=1;i<n;i++)
   {
     int flag=Arr[i] ;  
	 int pos=0;     
     while(flag>Arr[pos])       // 减少向前搜索 ，主要是数组的移动 。 确定要移动多少位置 
        pos++;
     for(j=i;j>pos;j--)
     {
        Arr[j]=Arr[j-1];
     }
        Arr[pos]=flag ;
   }
}
/*  

    选择排序 :
        思想：   
            每次排序确定一个元素的位置
*/
void  select_sort1( datetype *card, int n)     
{
  int i,j ;
  for(i=0;i<n;i++)
  {
    for(j=i+1;j<n;j++)
    {
       if(card[j]<card[i])
       {
         int t ;
         t=card[j];
         card[j]=card[i];
         card[i]=t;
       }
    }
  }
}
/*  
        选择排序2（改进）
*/
void  select_sort2(datetype *card,int n)  
{
   int i,j ,k；
   datetypet t;
   for(i=0;i<n-1;i++)
   {
       k=i;
       for(j=i+1;j<n;j++)
        if(card[j]<card[i])
            k=j;
        if(k!=i)
        {
          t=card[k];
          card[k]=card[i];
          card[i]=t;
        }
   }
}
/*
    递归排序 :
    思想： 
    1）将数组分成相同两段， Arr1[] ,Arr2[] ,然后 两个数组进行比较， 每比较依次，选出最小的保存到temp []  , 直到一个数组结束，然后把另一个
    数组剩下的元素，直接添加到 temp[] 后。
     2） 对 Arr1 []  Arr2[] 依次进行 1  。
*/
void Merger_sort(datetype *Arry,int left ,int right)                  
{
   if(left==right-1)
    return ;
   int mid=(left+right)/2 ;
   Mergersort(Arry,left,mid);                                     // 递归排序 
   Mergersort(Arry,mid,right);
   int *temp=new int[right-left];                                  //开辟临时数组
   int left_idx=left;
   int right_idx=mid ;
   int  i=0;
   while(left_idx<mid&&right_idx<right)                            //合并 ，依次比较大小 ， 选择 小的
   {
     if(Arry[left_idx]<Arry[right_idx])
        temp[i++]=Arry[left_idx++];
     else 
	 	temp[i++]=Arry[right_idx++];
   }
   while(left_idx<mid)                                   // 数组剩下的元素直接添加到temp [] 后
    temp[i++]=Arry[left_idx++];
   while (right_idx<right)
   temp[i++]=Arry[right_idx++];
   for(int i= 0,idx=left;i<right-left;i++,idx++)
   Arry[idx]=temp[i];
   delete []temp ;
}

int fold_find(datetype *Arr,int low ,int high,int date)       /*折半查找 */
{
   int id=-1;
  while(low<=high)
   {
     int middle=(low + high)/ 2 ;
    if(Arr[middle]==date)
    {
        id=middle ;
       return id +1;
    }
       else if(Arr[middle]>date)
    {
       high=middle -1 ;
   }
     else low=middle + 1 ;
   }

}
 /*   快速排序  */
void quick_sort(datetype *base,int len)  
 {
    if(len<=1)                     /*  递归终止条件 */
    return ;
    int left_id=0,right_id=0;
    srand((unsigned)time(0));					 //	为rand( )函数初始化随机发生器的启动状态，以产生伪随机数
    int rand_num;
    rand_num=rand()%len ;                        /* 随机选择一个数组作为比较元素 */
    int key = base[rand_num];                   /*关键性元素 ，可以从数组中任意选择 */
    int *left ,*right;
    left = new int [len];
    right =  new int [len];
    for(int i=0;i<len;i++)                      /*拆分 */
    {
       if(base[i]<key)
        left[left_id++]=base[i];
      if(base[i]>key)
      right[right_id++]=base[i];
    }
    quick_sort(left,left_id);                /*1递归  */
    quick_sort(right,right_id);
    int id = 0;
    for(int i=0;i<left_id;i++)
        base[id++]=left[i];
    base[id++]=key ;
    for(int i=0;i<right_id;i++)
       base[id++]=right[i];
    delete [] left ;
    delete [] right ;


 }
 void Bubblesort(datetype *base ,int n)  /*冒泡排序 */
 {
   int i, j;
   for(i=0;i<n;i++)
   {
     for(j=0;j<n-i;j++)
     {
       if(base[j]>base[j+1])
       {
         int t ;
         t= base [j];
         base[j]=base[j+1];
         base[j+1]=t ;
       }
     }
   }
 }