排序整理

对于无序数组R[1...n]排序
1、插入算法
------直接插入 
从R[1]开始作为有序队列，从其余剩余元素中取第一个(R[i])放入有序队列区域，放在哪里？就需要用R[i]和有序队列的数据比较，插入适当的位置。

void sort(int* R,int n)
{
    for(int i= 2;i<=n;i++)
    {
        /我的代码
         //如果数据大于等于前面有序队列最后一个，则插入位置即为当前位置
        if(R[i]>=R[i-1])
        {
            continue;
        }
         int InsertKey= R[i];
        //插入数据放入前面1...i-1中找一个合适位置
         for(int j=i-1;j>=0;j--)
        {
            if(j==0)
            {
                R[1] = InsertKey;
            }
            if(R[j]>InsertKey)
            {
                //大数据向后移动
                R[j+1]=R[j];
            }
            else
            {
                 //把当前位置数据不变，插入的数据放后一个位置
                 R[j+1]=InsertKey;
                 break;
            }

        }
     }
}

//        /参考的代码
//        if(R[i]<R[i-1])
//        {
//             R[0]= R[i];
//            int j;
//            for(j = i-1;R[0] < R[j];j--)
//                R[j+1]=R[j];
//            R[j+1]=R[0];
//        }

//    }
//}

时间复杂度 O(n*n)

-----希尔排序
从R[1]开始，每个元素报数1，2...K，循环。报1为一组，报2为一组，其它依次为一组，各组分别用插入算法整理；接着继续报数和整理，不过报数的K一直减少，减少到1时便排完了整个序列。
为什么这样做？
希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。
有人通过大量的实验，给出了较好的结果：当n较大时，比较和移动的次数约在nl.25到1.6n1.25之间。

//希尔排序
void sort2(int R[],int n,int len)
{
    //选取len间距的序列 全部报数为1 1+x*len
    for(int startiidex = 0;startiidex <len;startiidex++)
    {

        //对每个序列排序
         for(int iidex= (startiidex+len);iidex<=n;iidex+= len)
        {
                    if(R[iidex] < R[iidex-len])
                     {
                          R[0]= R[iidex];
                         int j=0;
                         for(j=iidex-len;R[0]<R[(j<0?0:j)];j=j-len)
                            {
                             int jdex = (j<0?0:j);
                             R[j+len]=R[jdex];
                            }
                         //当比较到比第一个元素还要小，那么 j的值应该是第一个元素的前一个位置，数据可能是负数
                         R[j+len]=R[0];
                     }

        }

    }
    cout<<endl<<len<<endl;

}

//void sort(int R[],int n)
//{
//    //5 3 1即为分组长度的队列
//    cout<<endl;
//    for(int i = 1;i<10;i++)
//    {
//        cout<<R[i]<<" ";
//    }
//    sort2(R,n,5);
//    for(int i = 1;i<10;i++)
//    {
//        cout<<R[i]<<" ";
//    }
//     sort2(R,n,3);
//     for(int i = 1;i<10;i++)
//     {
//         cout<<R[i]<<" ";
//     }
//      sort2(R,n,1);
//      for(int i = 1;i<10;i++)
//      {
//          cout<<R[i]<<" ";
//      }
//      cout<<endl;
//}


//参考版本
//void ShellInsert(SeqList R[],int dk)
//  {//希尔排序中的的一趟插入排序，dk为当前增量
//   for(i=dk+1；i<=n；i++)//将R[dk+1..n]分别插入有序区
//    if(R[i].key<R[i-dk].key)
//    { R[0]=R[i]； //暂存在R[0]中
//     j=i-dk；
//     while(j>0 && R[0].key<R[j].key)
//      { R[j+dk]=R[j]；//记录后移，查找插入位置
//       j=j-dk； //查找前一记录
//      }
//     R[j+dk]=R[0]； //插入R[i]到正确位置
//    }
//  }

//void ShellSort(SeqList R,int d[],int t)
// { //按增量序列d[0..t-1]对顺序表R作希尔排序
//   for(k=0；k<t；k++)
//    ShellInsert(R,d[k])；
// }

2、交换排序算法
-----冒泡排序（最简单容易实现）
从末尾元素开始，R[n] R[n-1]比较，重放后面，轻的放前面，一直比较到R[1] R[2]，一次比较结束就找到R[1]为最小元素，即为有序部分，第二次从R[n] R[n-1]比较，依据原则比较到R[2]，二次比较结束找到R[2]为无序部分最小的元素，如此重复，比较n-1次。
时间复杂度O(n*n)

//冒泡排序
//void sort(int R[], int n)
//{
//    for(int i= 1;i<n;i++)
//    {
//        for(int j=n-1;j>i;j--)
//        {
//            if(R[j]<R[j-1])
//            {
//                int tmp = R[j];
//                R[j]=R[j-1];
//                R[j-1]=tmp;
//            }
//        }
//    }
//}
//参考版本
//void BubbleSort(SeqList R[ ])
//　　{//采用自下而上扫描数组R[1..n]做起泡排序
//　　 int i,j,flag；
//　　 for(i=1；i<n；i++) //最多做n-1趟排序
//　　　 { flag=0； //flag表示每一趟是否有交换，先置0
//　　　　　for(j=n-1；j>=i；j--)//进行第i趟排序
//　　　　　　if(R[j].key<R[j-1].key)
//　　　　　 　{ R[0]=R[j+1]；
//　　　　　　　　//R[0]作为交换时的暂存单元
//　　　　　　　 R[j+1]=R[j]；
//　　　　　　　 R[j]=R[0]；flag=1；//有交换，flag置1
//　　　　　　　}
//　　　　　　if(flag==0) return；
//　　　　 }
//　　}

------快速排序
第一次，用R[1]的值Value作为参考，把R[1..N]大小分成两个区间，中间位置为m，R[m]=Value
第二次，在R[1...m]中用R[1]的值Value作为参考，把R[1...m]大小分成两个区间，中间位置为i，R[i]=Value
在R[m...N]同样方法，用R[m]分成大小两个区间
不断的把整个序列分成大小两个区间，知道最后每个区间只有一个元素为止

最好O(n*logn) 最差O(n*n)

//快速排序
void sort3(int R[], int n,int start ,int end)
{
    if(start <end)
    {
        int m= sortQuick(R,n,start,end);
        sort3(R,n,start,m-1);
        sort3(R,n,m+1,end);
    }

}
int sortQuick(int R[],int n,int start ,int end)
{
    if(start <end)
    {
         R[0]=R[start];
        bool isLeft =true;
        int i = start,j = end;
        while(i<j)
       {
           if(isLeft)
           {
               if(R[j]<R[0])
               {
                   R[i]=R[j];
                   i++;
                   isLeft = false;
               }
               else
               {
                   j--;
               }
           }
           else
           {
               if(R[i]>R[0])
                {
                   R[j]=R[i];
                   j--;
                   isLeft = true;
               }
               else
               {
                   i++;
               }
           }


       }
        R[i]=R[0];
       return i;
    }
    return start;

}

//参考代码
//int Partition(SeqList R,int i,int j)
//{//对R[i]…R[j]区间内的记录进行一次划分排序
// x=R[i]； //用区间的第一个记录为基准
// while(i<j){
//  while(i<j&&R[j].key>=x.key)
//   j--； //从j所指位置起向前(左)搜索
//  if(i<j){R[i]=R[j]；i++；}
//  while(i<j&&R[i].key<=x.key)
//   i++； //从i所指位置起向后(右)搜索
//  if(i<j){R[j]=R[i]；j--；}
// }
// R[i]=x； //基准记录x位于最终排序的位置i上
// return i；
//}

3、选择排序
-----直接选择排序
类似冒泡排序，每次循环把最小的选择出来，但是不用每次比较都进行交换
时间复杂度O(N*N)

//直接选择排序
void sortSelect(int R[],int n)
{
    for(int i = 1;i<n;i++)
    {
        int min = i;
        for(int j = i;j<n;j++)
        {
            if(R[j]<R[min])
            {
                min = j;
            }
        }
        //选择出最小的，排在前面
        int tmp = R[i];
        R[i]= R[min];
        R[min]=tmp;
    }
}
//参考程序
//void SelectSort(SeqList R)
// {//对R作直接选择排序
//  int i,j,k；
//   for(i=1；i<n；i++){//做n-1趟排序
//   k=i； //设k为第i趟排序中关键字最小的记录位置
//   for(j=i+1；j<=n；j++)
//    //在无序区R[i..n]选择关键字最小的记录
//    if(R[j].key<R[k].key)
//      k=j；//若有比R[k].key小的记录，记住该位置
//   if(k!=i) { //与第i个记录交换
//     R[0]=R[i]；R[i]=R[j]；R[j]=R[0]；
//   }
//   }
//  }

-----堆排序
建立一棵满树，大根树，之后把根和最后一个子节点交换，然后整理这颗大根树，当比较了log(n-2)次之后找到最大的根值，又和最后一个节点交换，不断循环知道最后一个节点

//堆排序
void  BuildBigRootTree(int R[],int n)
{
    for(int i=n/2;i>0;i--)
    {
        //遍历所有的根节点
        //把最大数放在根节点
        int max = i;
        if(R[2*i]>R[2*i+1])
        {
            max = 2*i;
        }
        else
            max = 2*i+1;
        if(R[i]<R[max])
        {
            int tmp = R[i];
            R[i]=R[max];
            R[max]= tmp;
        }
    }
}

void Heapsort(int R[],int endIndex)
{

    if(endIndex >= 1)
    {
        //大根 排列整棵树
        ReSortTree(R,endIndex,1);
        //第一个和最后一个交换
        int tmp = R[endIndex];
         R[endIndex] = R[1];
         R[1] = tmp;
         cout<<"====";
         cout<<R[endIndex]<<" "<<tmp;
         cout<<"====";
         //把剩余的无序树继续排列
         Heapsort(R, endIndex-1);
    }


}

void ReSortTree(int R[],int endIndex,int rootIdex)
{
    //整理R[1...endIndex]的节点rootIdex
    if(rootIdex <= endIndex/2)
    {
        // 如果树只有一个节点,
        int max = rootIdex*2;
       // 如果树有2个节点,
        if((rootIdex*2+1)<=endIndex )
        {
            if(R[rootIdex*2]<R[rootIdex*2+1])
            {
                max = rootIdex*2+1;
            }
            else
                max = rootIdex*2;
        }

        if(R[rootIdex]<R[max])
        {
            int tmp = R[rootIdex];
            R[rootIdex]=R[max];
            R[max]= tmp;
            ReSortTree(R,endIndex,max);
        }

    }

}

4、归并排序
从R[1...N]分成R[2k-1],R[2k]排序，之后合并成一组，总共有N/2次比较
第二次 R[4k] R[4k+1] R[4k+2] R[4k+3]排序，之后合并为一组，总共有N/4次比较
一直到N个数据为一组


时间复杂度O(N*logN)