排序算法及分析

排序算法小合集：冒泡排序、快速排序、堆排序、合并排序、插入排序

相关知识：

假设：含n个记录的序列为：{R₁，R₂，…，R_n}

         相应的关键字序列为：{K₁，K₂，…，K_n}

需确定1,2，…，n的一种排列p₁，p₂，…，p_n，使其相应的关键字满足如下的非递减（或非递增）关系：                                     K_p1 <=K_p2<= … <=K_pn

使得记录的序列成为一个按关键字有序的序列：

                                            {R_p1，R_p2，…，R_pn}

这样的一种操作称为排序。

假设K_i=K_j（1<=i<=n,1<=j<=n,i!=j），且在排序前序列中Ri领先于Rj（及i<j）。若在排序后的序列中Ri仍领先于 R_j，则称所用的排序方法是稳定的；反之，排序方法是不稳定的。

冒泡排序：Time（O（n²））

/************************************************************************/
/* 函 数 名: BubbleSort()
/* 输入参数: int iArr[], int n //n为数组长度
/* 输出参数: 无
/* 返 回 值: int*
/* 功能描述: 输入一个数组，使用冒泡排序，将其排序（从小到大），返回数组指针
/* 日    期: 2012-10-2
/***********************************************************************/

int* BubbleSort(int iArr[], int n)
{
    for (int i=0; i<n; i++)
    {
        for (int j=i+1; j<n; j++)
        {
            if (iArr[i]>iArr[j])
            {
                int temp = iArr[i];
                iArr[i] = iArr[j];
                iArr[j] = temp;
            }
        }
    }
    return iArr;
}

快速排序：(Time（O（nlogn））)

/************************************************************************/
/* 函 数 名: Partition()
/* 输入参数: int iArr[], int low, int higt 
/* 输出参数: 无
/* 返 回 值: int
/* 功能描述: 完成一次快排
/* 日    期: 2012-10-5
/***********************************************************************/

int Partition(int iArr[], int low, int high)
{
    int pivotkey = iArr[low];  //存储枢轴值
    
    while(low < high)          //从表两端交替地向中间扫描
    {
        //把比枢轴值小的值移到前面
        while(low<high && iArr[high]>=pivotkey)
        {
            --high;
        }

        iArr[low] = iArr[high];
        //把比枢轴值大的值移到前面
        while(low<high && iArr[low]<=pivotkey)
        {
            ++low;
        }

        iArr[high] = iArr[low];
    }

    iArr[low] = pivotkey;  

    return low;               //返回枢轴位置
}

/************************************************************************/
/* 函 数 名: QSort()
/* 输入参数: int iArr[], int low, int higt //low为第一个数的位置，
             high为最后一个数的位置（数组长度减1）
/* 输出参数: 无
/* 返 回 值: int*
/* 功能描述: 输入一个数组，使用快速排序，将其排序（从小到大），返回数组指针
/* 日    期: 2012-10-5
/***********************************************************************/

int* QSort(int iArr[], int low, int high)
{
    if (low<high)
    {
        int pivotloc = Partition(iArr, low, high); //将数组一分为二
        QSort(iArr, low, pivotloc-1);
        QSort(iArr, pivotloc+1, high);
    }
    return iArr;
}

堆排序：(Time（O（nlogn））)

/************************************************************************/
/* 函 数 名: HeapAdjust()
/* 输入参数: int iArr[], int s, int m //
/* 输出参数: 无
/* 返 回 值: void
/* 功能描述: 已知iArr[s...m]中记录的关键字除iArr[s]外均满足堆的定义，
             本函数调整iArr[s...m]的关键字，使得其成为一个大顶堆
             （对其中记录的关键字而言）
/* 日    期: 2012-10-5
/***********************************************************************/

void HeapAdjust(int iArr[], int s, int m)
{//已知iArr[s...m]中记录的关键字除iArr[s]外均满足堆的定义，本函数调整
 //iArr[s...m]的关键字，使得其成为一个大顶堆（对其中记录的关键字而言）

    int rc = iArr[s];
    //沿较大孩子结点向下筛选
    for (int j=2*s; j<=m; j*=2)
    {
        //j为值较大的下标
        if (j<m && iArr[j]<iArr[j+1])
        {
            j++;
        }
        //rc应插入在s处
        if (rc>=iArr[j])
        {
            break;
        }

        iArr[s] = iArr[j];
        s = j;
    }

    iArr[s] = rc;
}

/************************************************************************/
/* 函 数 名: HeapSort()
/* 输入参数: int iArr[]， int n //n为数组长度减1（参与排序元素的个数）
/* 输出参数: 无
/* 返 回 值: int*
/* 功能描述: 大顶堆排序，返回升序  ！！注意：iArr中的iArr[0]不存值，或是说这个值不参与排序。
/* 日    期: 2012-10-5
/***********************************************************************/

int* HeapSort(int iArr[], int n)
{//注意：iArr中的iArr[0]不存值，或是说这个值不参与排序。
    for (int i=n/2; i>0; i--)
    {
        HeapAdjust(iArr, i, n);
    }

    for (int i = n; i>1; i--)
    {
        int temp = iArr[1];
        iArr[1] = iArr[i];
        iArr[i] = temp;

        HeapAdjust(iArr, 1, i-1);
    }
    return iArr;
}

合并排序：

/************************************************************************/
/* 函 数 名: MergeSort()
/* 输入参数: int iArr[], int begin, int end //end为数组下标最大值
/* 输出参数: 无
/* 返 回 值: int*
/* 功能描述: 输入一个数组，使用合并排序，将其排序（从小到大），返回数组指针
/* 日    期: 2012-9-18
/***********************************************************************/

void Merge(int* iArr, int begin, int mid, int end);

int * MergeSort(int iArr[], int begin, int end)
{
    if (begin < end)
    {
        int mid = (begin + end)/2;

        MergeSort(iArr, begin, mid);
        MergeSort(iArr, mid+1, end);
        Merge(iArr, begin, mid, end);
    }

    return iArr;
}

void Merge(int* iArr, int begin, int mid, int end)
{
    int n1 = mid - begin + 1;
    int n2 = end - mid;

    int* LArr = new int[n1+1];
    int* RArr = new int[n2+1];

    int i=0;
    int j=0;
    for (; i<n1; i++)
    {
        LArr[i] = iArr[begin+i];
    }
    for (; j<n2; j++)
    {
        RArr[j] = iArr[mid+j+1];
    }

    LArr[n1] = 1000;
    RArr[n2] = 1000;

    i = 0;
    j = 0;

    for (int k=begin; k<=end; k++)
    {
        if (LArr[i] <= RArr[j])
        {
            iArr[k] = LArr[i++];
        } 
        else
        {
            iArr[k] = RArr[j++];
        }
    }

    delete[] LArr;
    delete[] RArr;
}

插入排序：

/************************************************************************/
/*内容：本源代码主要为排序函数
/*
/************************************************************************/

/************************************************************************/
/* 函 数 名: InsertionSort()
/* 输入参数: int[], int
/* 输出参数: 无
/* 返 回 值: int*
/* 功能描述: 输入一个数组，使用插入排序，将其排序（从小到大），返回数组指针
/* 日    期: 2012-9-18
/***********************************************************************/

int* InsertionSort(int iArr[], int n)
{
    for (int j=1; j<n; j++)
    {
        int key = iArr[j];
        int i = j-1;
        while(i>=0 && iArr[i]>key)
        {
            iArr[i+1] = iArr[i];
            i--;
        }
        iArr[i+1] = key;
    }

    return iArr;
}