算法学习01：二分查询，选择法、插入法、分治法排序

查询与排序是使用的再频繁不过的两个功能，算法学习系列实现语言为C#。

一般情况下的查询

Int32 Search(Int32[] source, Int32 task)
{
    var index = 0;
    while (index < source.Length)
        if (source[index++] == task)
            return index - 1;

    //返回值为Length则说明未找到
    return source.Length;
}

时间复杂度为O(n)，在检索源没有排序的情况下，这即为最高的检索方法。

二分查询

当检索源为顺序排列时，我们可以使用二分查询进行检索。

可将时间复杂度提升至O(lgn).

非递归实现：

Int32 BinarySearch(Int32[] source, Int32 targetVal)
{
    Int32 leftPointer = 0;
    Int32 rightPointer = source.Length - 1;
    while (leftPointer <= rightPointer)
    {
        Int32 pos = (rightPointer + leftPointer) / 2;
        if (source[pos] == targetVal)
            return pos;
        if (source[pos] < targetVal)
            leftPointer = pos + 1;
        else
            rightPointer = pos - 1;
    }
    return source.Length;
}

递归实现：

Int32 BinarySearch(Int32[] source, Int32 startIndex, Int32 endIndex, Int32 targetVal)
{
    if (startIndex > endIndex)
        return source.Length;
    Int32 pos = (startIndex + endIndex) / 2;
    if (source[pos] == targetVal)
        return pos;
    if (source[pos] < targetVal)
        return BinarySearch(source, pos + 1, endIndex, targetVal);
    else
        return BinarySearch(source, startIndex, pos - 1, targetVal);
}

测试结果：

//输出均为8
Console.WriteLine(BinarySearch(new Int32[10] { 4, 3, 2, 1, 3, 8, 9, 19, 88, 57 }, 0, 10, 88));
Console.WriteLine(BinarySearch(new Int32[10] { 4, 3, 2, 1, 3, 8, 9, 19, 88, 57 }, 88));

接下来是一些常用的排序方法。

选择法

时间复杂度O（n*n）。

Int32[] SelectionSort(Int32[] source)
{
    for (int i = 0; i < source.Length; i++)
    {
        var smallestValIndex = i;
        for (int j = i + 1; j < source.Length; j++)
        {
            if (source[smallestValIndex] > source[j])
                smallestValIndex = j;
        }
        var temp = source[i];
        source[i] = source[smallestValIndex];
        source[smallestValIndex] = temp;
    }
    return source;
}

插入法

时间复杂度O（n*n），与选择法相比，适合在链表结构中使用。

Int32[] InsertSort(Int32[] source)
{
    var resultArray = new Int32[source.Length];
    for (int i = 0; i < source.Length; i++)
    {
        var index = 0;
        while (index++ < i)
        {
            if (resultArray[index - 1] > source[i])
                break;
        }
        for (int j = index - 1; j < i; j++)
            resultArray[j + 1] = resultArray[j];
        resultArray[index - 1] = source[i];
    }
    return resultArray;
}

分治排序之合并法

时间复杂度O(n * lgn)。

分治原理例图：

Int32[] DevideAndConquerSort(Int32[] source, Int32 startIndex, Int32 endIndex)
{
    //子数组只有一个元素时，是无需排序的
    if (startIndex + 1>= endIndex)
        return source;
    var middleIndex = (startIndex + endIndex) / 2;
    DevideAndConquerSort(source, startIndex, middleIndex);
    DevideAndConquerSort(source, (startIndex + endIndex) / 2, endIndex);
    MergeSort(source, startIndex, (startIndex + endIndex) / 2, endIndex);
    return source;
}

void MergeSort(Int32[] source, Int32 startIndex, Int32 middleIndex, Int32 endIndex)
{
    var arrayAPointer = startIndex;
    var arrayBPointer = middleIndex;
    var loopLength = endIndex - startIndex;
    var resultArray = new Int32[loopLength];
    for (int i = 0; i < loopLength; i++)
    {
        if (arrayBPointer != endIndex && source[arrayAPointer] > source[arrayBPointer])
            resultArray[i] = source[arrayBPointer++];
        else if (arrayAPointer != middleIndex)
            resultArray[i] = source[arrayAPointer++];
        else
            resultArray[i] = source[arrayBPointer++];
    }
    for (int i = 0; i < loopLength; i++)
    {
        source[startIndex + i] = resultArray[i];
    }
}

分支排序之快速排序法

与合并法相比，适合在n不是很大，又不是很小的时候使用。

分治原理例图：

Int32[] QuickSort(Int32[] source, Int32 startIndex, Int32 endIndex)
{
    if(startIndex >= endIndex)
        return source;
    var index = Partition(source, startIndex, endIndex);
    QuickSort(source, startIndex, index - 1);
    QuickSort(source, index + 1, endIndex);
    return source;
}

Int32 Partition(Int32[] source, Int32 startIndex, Int32 endIndex)
{
    Int32 index = 0;
    while ((index++) < endIndex - startIndex)
    {
        if (source[startIndex + index - 1] >= source[endIndex - 1])
            break;
    }
    if(startIndex + index - 1 != endIndex)
    {
        var temp = source[startIndex + index - 1];
        source[startIndex + index - 1] = source[endIndex - 1];
        source[endIndex - 1] = temp;
    }
    return startIndex + index - 1;
}

总结