排序技术

#include<iostream>
using namespace std;
class B{
   void InsertSort()//直接插入排序，将第一个作为O点，往里面插入，小的插入到大的后面,一种稳定的排序方法，
   //最好情况正序排列，比较n-次（每次比较一次停止循环），记录的移动次数为2（n-1），即数据的转移temp=data[i],data[i]=temp
   //最坏逆序，比较n*(n-1)/2；数据移动（n+4）（n-1）/2;平均是最坏的情况/2；
   //时间复杂度O（n*n）
   {
    int temp;
    for(int i=0;i<length;i++)
    {
        data[i]=temp;
        for(int j=i-1;j>=0&&temp<data[j];j--)
        {
                data[j+1]=data[j];
        }
        data[j+1]=temp;
    }
   }

   B(int r[],int n);
   ~B();
   void print();
   int *data;
   int length;
   void ShellSort()//希尔排序，对直接插入排序的优化，对于基本有序的数据效率很高，对于排序记录个数较少的效率也很高。方法：对数据进行分组，每组进行直接插入排序
   //排序过程记录是跳跃的，所以是不稳定的。
   {
        int temp;
    for(int d=length/2;d>=1;d=d/2)
    {
        for(int i=d;i<length;i++)
        {
            for(int j=i-d;j>=0&&temp<data[j];j=j-d)
            {
                data[j-d]=data[j];
            }
            data[j+d]=temp;
        }
    }
   }

   //交换排序
   void BubbleSort()//起泡排序，反序向前提，最好正序，比较n-1次，不需要移动。最坏逆序，比较n*（n-1）/2，移动3n倍的比较次数
   {
       int temp,exchang,bound;//exchang记载记录交换的位置，避免重复的出现。
       exchang=length-1;
      while(exchang!=0)
      {
          bound=exchang;
          exchang=0;
          for(int j=0;j<bound;j++)
          {
              if(data[j]>data[j+1])
              {
                  temp=data[j];
                  data[j]=data[j+1];
                  data[j+1]=data[j];
                  exchang=j;
              }
          }
      }
   }//这是一种稳定的排序方式。
   int  Partition(int first,int last)//快速排序，求轴值，对起泡排序的优化，比较和移动都是从两端开始的,
   {
       int i=first,j=last,temp;
       while(i<j)
       {
           while(i<j&&data[i]<=data[j])j--;
           if(i<j)
           {
               temp=data[i];
               data[i]=data[j];
               data[j]=data[i];
               i++;
           }
           while(i<j&&data[i]>=data[j])i++;
           if(i<j)
           {
               temp=data[i];
               data[i]=data[j];
               data[j]=data[i];
               j--;
           }
       }
       return i;
   }
   void QuickSort(int first,int last)//快速排序的实现，使用递归，为不稳定的
   {
       if(first>=last)
        return;
       else
       {
           int pivot=Partition(first,last);//给予轴值位置
           QuickSort(first,pivot-1);//左侧进行快速排序
           QuickSort(pivot+1;last);//右侧进行快速排序
       }
   }
   void SelectSort()//简单选择排序 ,选中每一次最小的往前提，是不稳定的
   {
       int i,j,index,temp;
       for(int i=0;i<length-1;i++)
       {
           index=i;
           for(j=i+1;j<length;j++)
           {
               if(data[j]<data[index])
                index=j;
           }
           if(index!=i)
           {
               temp=data[i];
               data[i]=data[index];
               data[index]=temp;
           }
       }

   }
   //堆排序法,着眼与如何减少比较次数，堆排序实现了在找出最小数据的同时，也找出较少数据
   //以下一步是对数据的调整，使其满足堆的排序。
   void Sift(int k,int last)
   {
       int temp
       int i=k,j=2*i+1;//j先指向左孩子
       while(j<=last)
       {
           if(j<last&&data[j]<data[j+1])j++;//指向左右孩子的较大者
           if(data[i]>data[j])break;//已经是堆，代表节点处的值比它的左右孩纸都大，已经是大根堆的形式
           else{
            temp=data[i];
            data[i]=data[j];
            data[j]=temp;
            i=j;
            j=2*j+1;
           }
       }
   }
   void HeapSort()//先建立大根堆，，大根堆为无序区，建立完后将树根放入有序区里面，然后在重建堆。
   {
       int temp
       for(int i=ceil(length/2)-1;i>=0;i--)//重最低层开始建堆，防止顶层出现改变引起底层的改变
       {
           Sift(i,length-1);
       }
       for(int i=1;i<length;i++)//建完堆以后，树根就是最大值，放到有序区保存，然后再次建堆，将下一个最大值提到树根的位置
       {
           temp=data[0];
           data[0]=data[length-i];
           data[length-i]=temp;
           Sift(0,length-i-1)
       }
   }

   //归并排序，将若干个有序数列归并成一个有序数列
   //二路归并排序,将两个已经排序好的数组，再次排序到另外一个数组中，从小的开始。
   void Merge(int first1,int last1,int last2)
   {
       int *temp=new int[length];
       int i=first1,j=last1+1,k=first1;
       while(i<=last&&j<=last2)
       {
           if(date[i]<data[j])
           {
               temp[k]=data[i];
               k++;
               i++;
           }
           else
           {
               temp[k]=data[j];
               k++;
               j++;
           }
        }
        //由于结束的条件是i<=last1&&j<=last2,所以总有i或j没有到last1或last2，所以要进行收尾处理。
        while(i<=last1)
        {
            temp[k]=data[i];
            k++;
            i++;
        }
        while(j<=last2)
        {
            temp[k]=data[j];
            k++;
            j++;
        }
        for(int i=first1;i<=last2;i++)//合并结果的返回
        {
            data[i]=temp[i];
        }
        delete temp;
    }
    //处理一个乱序的数组时,进行递归排序
    void MergeSort(int first,int last)
    {
        if(first>=last)
        {
            return ;
        }
        else{
            int mid=(first+last)/2;
            MergeSort(first,mid);//对前半部分进行归并排序
            MergeSort(mid+1,last);//对后半部分进行归并排序
            Merge(first,mid,last);//将两个已经排序号的部分进行归并排序
        }
    }
    //二路合并的非递归实现
    //分成若干组分别进行归并排序
    //第一步进行每组的归并排序，知道数组所有长h的序列归并完成。
    void MergePass(int h)
    {
        int i=0;
        while(i+2*h<=length)
        {
            Merge(i,i+h-1,i+2*h-1);
            i=i+2*h;
        }
        if(i+h<length)
        {
            Merge(i,i+h-1,length-1);
        }
    }
    //第二步，进行分组，进行所有长h的序列，然后以二倍的增长，实现h的不断合并
    void MergeSort2()
    {
        int h=1;
        while(h<=length)
        {
            MergePass(h);
            h=2*h;
        }
    }

}



};
B::B(int r[],int n)
{
    data=new int[n];
    for(int i=0;i<n;i++)
    {
        data[i]=r[i];
    }
    length=n;
}
void B::print()
{
    for(int i=0;i<n;i++)
    {
       cout<<data[i]<<"\t";
    }
    cout<<endl;

}





int main()
{

}