排序算法

A、插入排序

 

一、直接插入排序

void InsertSort(SqList &L)

{

for (i=2; i<L.length; i++)

{

if (L.r[i].key < L.r[i-1].key)

{

L.r[0] = L.r[i];

 

for (j=i; L.r[0].key<L.r[j-1].key; j--)

{

L.r[j] = L.r[j-1];

}

 

L.r[j] = L.r[0];

}

}

}

 

二、折半插入排序

void BInsertSort(SqList &L)

{

for （i=2; i<=L.length; i++）

{

if (L.r[i].key < L.r[i-1].key)

{

L.r[0] = L.r[i];

 

low = 1;

high = i-1;

 

while (low <= high)

{

middle = (low+high)/2;

 

if (L.r[0] < middle)

{

high = middle - 1;

}

else

{

low = middle + 1;

}

}

 

for (j=i; j>high+1; j--)

{

L.r[j] = L.r[j-1];

}

 

L.r[high+1] = L.r[0];

 

}

}

 

}

 

三、2路插入排序

/*

* FileName:          bidir_insertion_sort.c

* Author:            Antigloss at http://stdcpp.cn

* LastModifiedDate:  2005-11-12 12:00

* Purpose:           Bidirection Insertion Sort

*/

 

#include <stdio.h>

#include <stddef.h>

 

#define ARR_SIZE 10

 

/* 函数原型 */

void bidir_insert( int keys[], int temp[], const size_t i );

 

int main(void)

{

    size_t i;

    int keys[ARR_SIZE] = { 1050, 100, 150, 20, 9000, 5110, 3008, 1450, 5220, 500 };

    int temp[ARR_SIZE];  /* 辅助数组 */

 

    /* 进行二路插入排序 */

    bidir_insert(keys, temp, ARR_SIZE);

    /* 输出排序结果 */

    for ( i = 0; i < ARR_SIZE; ++i ) {

        printf("%d ", keys[i]);

    }

 

    printf("/nPress ENTER to quit.../n");

    getchar();

    return 0;

}

 

/* Begin of bidir_insert 05-11-12 12:00 */

void bidir_insert( int keys[], int temp[], const size_t arr_size )

{

size_t i, first, final;

final = first = 0;

 

temp[0] = keys[0]; /* 将第一个元素放入辅助数组 */

/* 利用辅助数组 temp 进行二路插入排序 */

for ( i = 1; i < arr_size; ++i ) 

{

if ( temp[final] <= keys[i] )

{             

temp[++final] = keys[i];

} 

else if ( keys[i] <= temp[first] )

{

first = (first - 1 + arr_size) % arr_size;

temp[first] = keys[i];

} 

else 

{

size_t index;

 

for ( index = (final - 1 + arr_size) % arr_size; ;

index = (index - 1 + arr_size) % arr_size ) 

{

if ( temp[index] <= keys[i] )

{

size_t mid = final++;

/* 元素后移 */

while ( mid != index )

{

temp[(mid + 1) % arr_size] = temp[mid];

mid = (mid - 1 + arr_size) % arr_size;

}

 

temp[(index + 1) % arr_size] = keys[i];

 

break;

}

}

}

}

 

/* 将 temp 的内容按顺序复制到 keys 中 */

for ( i = 0; i < arr_size; ++i ) {

keys[i] = temp[first];

first = (first + 1) % arr_size;

}

}  /* End of bidir_insert */

 

四、表插入排序

#define SIZE 100

struct SLNode;

 

typedef struct{

RcdType rc;

int next;

}SLNode;

 

typedef struct{

SLNode r[SIZE];

int length;

}SLinkListType;

 

void ListInsertSort(SLinkListType &L)

{

L.r[0].rc = MAXINT;

L.r[0].next = 1;

L.r[1].next = 0;

 

for (i=2; i<=L.length; i++)

{

int p = 0；

int q = L.r[0].next;

while ( L.r[i].rc > L.r[q].rc )

{

p = q;

q = L.r[q].next;

}

 

L.r[p].next = i;

L.r[i].next = q;

}

}

 

void Arrage(SLinkListType &SL)

{

p = SL.r[0].next;

 

for (i=1; i<SL.length; i++)

{

while (p<i)

{

p = SL.r[p].next;

}

 

q = SL.r[p].next;

 

if (p != i)

{

SL.r[i] <-> SL.r[p];

SL.r[i].next = p;

  }

 

p = q;

}

}

 

五、shell排序

void ShellInsert(SqList &L, int dk)

{

for (i=dk+1; i<=L.length; i++)

{

if (L.r[i].key < L.r[i-dk].key)

{

L.r[0] = L.r[i];

 

for (j=i-dk; j>0 && L.r[0].key<L.r[j].key; j-=dk )

{

L.r[j+dk] = L.r[j];

}

L.r[j+dk] = L.r[0];

}

}

}

 

void ShellSort(SqList &L, int dlta[], int t)

{

for (k=0; k<t; t++)

ShellInsert(L, dlta[k]);

}

 

B、快速排序

一、起泡排序

void BubbleSort(SqList &L)

{

for (i=L.length, change=TRUE; i>=2 && change; i--)

{

change = FALSE;

 

for (j=1; j<i; j++)

{

if (L.r[j]>L.r[j+1])

{

L.r[j] <-> L.r[j+1]

change = TRUE;

}

}

}

}

 

二、快速排序

int Partition(SqList &L, int low, int high)

{

L.r[0] = L.r[low]; 

pivotkey = L.r[low].key;

 

while (low<high)

{

while (low<high && L.r[high].key >= pivotkey) --high;

L.r[low] = L.r[high];

while (low<high && L.r[low].key <= pivotkey) ++low;

L.r[high] = L.r[low];

}

 

L.r[low] = L.r[0];

return low;

}

 

void QSort(SqList &L, int low, int high)

{

if (low < high)

{

pivotLoc = Partition(L, low, high);

QSort(L, low, pivotLoc-1);

QSort(L, pivotLoc+1, high);

}

}

 

void QuickSort(SqList &L)

{

QSort(L, 1, L.length);

}

 

C、选择排序

一、简单选择排序

void SelectSort(SqList &L)

{

for (i=1; i<L.length; ++i)

{

j = SelectMinKey(L, i);

if (i != j)

{

L.r[i]<->L.r[j];

}

}

}

 

二、树形选择排序（锦标赛排序）

 

胜者树数据结点类的定义

　

template <class Type>

class DataNode {

public:

    Type data;    //数据值

    int index;      //结点在满二叉树中顺序号

    int active;     //参选标志：=1, 参选, =0, 不参选

}

　

锦标赛排序的算法

　

template <class Type>

void TournamentSort ( Type a[ ], int n )

{

    DataNode<Type> *tree;

    DataNode<Type>  item;    

　

    int bottomRowSize = PowerOfTwo ( n );  //乘幂值

    int TreeSize = 2*bottomRowSize-1; //总结点个数

    int loadindex = bottomRowSize-1;   //内结点个数

    tree = new DataNode<Type>[TreeSize];

    int j = 0;         //从 a 向胜者树--外结点复制数据

    for ( int i = loadindex; i < TreeSize; i++) 

    {

        tree[i].index = i;

        if ( j < n )

  { 

tree[i].active = 1;  

tree[i].data = a[j++]; 

}

        else 

{

tree[i].active = 0;

     }

    }

    

    i = loadindex;     //进行初始比较选择最小的项

    while ( i ) 

   {　

j = i;

while ( j < 2*i ) 

{

if ( !tree[j+1].active||           //胜者送入双亲

                     tree[j].data <= tree[j+1].data )

        tree[(j-1)/2] = tree[j];

    else

tree[(j-1)/2] = tree[j+1];

    

j += 2;

        }

        i = (i-1)/2;         // i 退到双亲, 直到 i==0为止

    }     

    for ( i = 0; i < n-1; i++) 

    {  //处理其它n-1个数据

        a[i] = tree[0].data;                   //送出最小数据

        tree[tree[0].index].active = 0;  //失去参选资格     

　

UpdateTree ( tree, tree[0].index );    //调整

    }

    a[n-1] = tree[0].data;      

}

　

锦标赛排序中的调整算法

　

template <class Type>

void UpdateTree ( DataNode<Type> *tree, int i ) 

{

    if ( i % 2 == 0 )

        tree[(i-1)/2] = tree[i-1];    //i偶数, 对手左结点

    else 

tree[(i-1)/2] = tree[i+1]; //i奇数, 对手右结点

    

    i = (i-1) / 2;                            //向上调整   

　

    while ( i )  //直到 i==0

   {                            

         if ( i %2 == 0) //继续向上调整

j = i-1;

         else 

j = i+1;

         

if ( !tree[i].active || !tree[j].active )

    {

     if ( tree[i].active )

         tree[(i-1)/2] = tree[i];       //i可参选, i上

   else  

tree[(i-1)/2] = tree[j];   //否则, j上

 }

        else //两方都可参选

{

   if ( tree[i].data < tree[j].data )

      tree[(i-1)/2] = tree[i];        //关键码小者上

   else  

tree[(i-1)/2] = tree[j];

 

i = (i-1) / 2;      // i上升到双亲

    }

    }

}

 

 

 

 

typedef SqList HeapType;    //堆采用顺序表存储表示

 

void HeapAdjust(HeapType &H, int s, int m)

{

    //已知H.r[s..m]中记录的关键字除H.r[s].key之外满足堆的定义，本函数调整H.r[s]

    //的关键字，使H.r[s..m]成为一个大顶堆（对其中记录的关键字而言）

    rc = H.r[s];

    for (j=2*s; j<=m; j*=2)

    {

        if (j<m && H.r[j].key <= H.r[j+1].key) 

            ++j;    //j为key较大的记录的下标

 

        if (!(rc.key <= H.r[j].key))

            break;

 

        H.r[s] = H.r[j];

        s = j;        

    }

 

    H.r[s] = rc;

}

 

void HeapSort(HeapType &H)

{

    //对顺序表H进行堆排序

    for (i=H.length/2; i>0; --i)    //把H.r[1..H.length]建成大顶堆

        HeapAdjust(H, i, H.length);

 

    for (i=H.length; i>1; --i)

    {

        H.r[1]<->H.r[i];        //将堆顶记录和当前未经排序子序列H.r[1..i]中

                                //最后一个记录相互交换

        HeapAdjust(H, 1, i-1);  //将H.r[1..i-1]重新调整为大顶堆                     

    }    

}

 

Merging Sort

 

void Merge(RcdType SR[], RcdType &TR[], int i, int m, int n)

{

    //将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]

    for (j=m+1, k=i; i<=m && j<=n; ++k)

    {

        if (SR[i].key <= SR[j].key)

        {

            TR[k] = SR[i++];

        }

        else

        {

            TR[k] = SR[j++];

        }       

    }

 

    if (i <= m)

    {

        TR[k..n] = SR[i..m];        //将剩余的SR[i..m]复制到TR

    }

 

    if (j <= n)

    {

        TR[k..n] = SR[j..n];        //将剩余的SR[j..n]复制到TR

    }   

}//Merge

 

void MSort(RcdType SR[], RcdType &TR1[], int s, int t)

{

    //将SR[s..t]归并排序为TR1[s..t].

    if (s == t)

    {

        TR1[s] = SR[s];

    }

    else

    {

        m = (s + t)/2;              //将SR[s..t]平分为SR[s..m]和SR[m+1..t]

        MSort(SR, TR2, s, m);       //递归地将SR[s..m]归并为有序的TR2[s..m]

        MSort(SR, TR2, m+1, t);     //递归地将SR[m+1..t]归并为有序的TR2[m+1..t]

        Merge(TR2, TR1, s, m, t);   //将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]

    }

}//MSort

 

void MergeSort(SqList &L)

{

    MSort(L.r, L,r, 1, );

}