【基础算法】-- 折半插入排序

最新推荐文章于 2022-08-10 20:03:36 发布

破晓狂客

最新推荐文章于 2022-08-10 20:03:36 发布

阅读量742

点赞数

分类专栏：基础算法文章标签：插入排序算法二分查找优化

本文链接：https://blog.csdn.net/su83362368/article/details/78539550

版权

基础算法专栏收录该内容

2 篇文章 0 订阅

订阅专栏

0001 算法描述

折半插入排序是直接插入排序的一种优化，在直接插入排序中待排序的元素需要与有序数列的每个元素从后往前逐个进行比较，直接插入排序对基本有序数列具有很高的排序效率，但是当乱序情况下，其比较次数会很多。折半插入排序在直接排序的基础上在位置查找部分采用折半（二分查找）算法进行插入位置的确定，进而节省查找时间。

0010 算法分析

最差时间复杂度：\(O(n^2)\)
最好时间复杂度：\(O(nlogn)\)
平均时间复杂度：\(O(n^2)\)
空间复杂度：　　\(O(1)\)
稳定性：　　　　稳定

0011 算法伪码

INSERTION-SORT(A)
for j=2 to A.length
    key = A[j]
    //Insert A[j] into the sorted sequence A[1..j-1].
    left = 0
    right = i-1
    while left <= right // 采用二分法定位新牌的位置
        mid = (left+right)/2

        if A[mid] > key
            right = mid - 1
        else 
            left = mid + 1

    for j=i-1 to left   // 将欲插入新牌位置右边的牌整体向右移动一个单位
        A[j+1] = A[j]

    A[left] = key       // 将抓到的牌插入手牌

0100 算法步骤

缓存当前要排序的元素的值，以便找到正确的位置进行插入；
计算 0 ~ i-1 的中间点，用 i 索引处的元素与中间值进行比较，如果 i 索引处的元素大，说明要插入的这个元素应该在中间值和刚加入i索引之间，反之，就是在刚开始的位置到中间值的位置，这样很简单的完成了折半；
在相应的半个范围里面找插入的位置时，不断的用（1）步骤缩小范围，不停的折半，范围依次缩小为 1/2 1/4 1/8 …….快速的确定出第i个元素要插在什么地方；
确定位置之后，将整个序列后移，并将元素插入到相应位置。

0101 java实现

/**
 * 折半插入排序
 *
 * @author tonysu,
 * @version 1.0v.
 * @Create 2017/11/12 下午9:13,
 */
public class BinaryInsertSort{

    /**
     * 排序函数
     *
     * @param data  输入数组
     * @param order 排序方式：
     *              true为升序
     *              false为降序
     * @return
     */
    public int[] sort(int[] data, boolean order){

        if(data.length == 0 || data == null){
            throw new NullPointerException("数组为空");
        }

        if(data.length == 1){
            return data;
        }

        for(int i=1; i<data.length; i++){

            int key = data[i];
            int left = 0;
            int right = i - 1;
            if(order){
                while(left <= right){
                    int mid = (left+right)/2;
                    if(data[mid] > key){
                        right = mid - 1;
                    }else{
                        left = mid + 1;
                    }
                }

            }else{
                while(left <= right){
                    int mid = (left+right)/2;
                    if(data[mid] < key){
                        right = mid - 1;
                    }else{
                        left = mid + 1;
                    }
                }
            }

            for(int j=i-1; j>=left; j--){
                data[j+1] = data[j];
            }

            data[left] = key;

        }

        return data;
    }
}

0110 python实现

class InsertSort(object):

    """折半插入排序类"""
    def __init__(self):
        super(InsertSort, self).__init__()

    def sort(self, datas, order):
        """对传入的数值数组datas进行折半插入排序.

          Args:
            datas: 待排序数值数组 e.g. [12, 3, 24, 11, 34, 33, 42, 9, 4]
            order: 排序顺序 e.g. True为升序， False为降序

          Returns:
            datas: 排好序的数值数组.
          """

        for i in range(1, len(datas)):
            left = 0
            right = i-1
            key = datas[i]
            if order:
                while left <= right:
                    mid = (left + right)/2
                    if datas[mid] > key:
                        right = mid - 1
                    else:
                        left = mid + 1
            else:
                while left <= right:
                    mid = (left + right)/2
                    if datas[mid] < key:
                        right = mid - 1
                    else:
                        left = mid + 1

            for j in range(i-1, left-1, -1):
                datas[j+1] = datas[j]

            datas[left] = key
        return datas


def main():

    data = [12, 3, 24, 11, 34, 33, 42, 9, 4]
    print data
    order = True
    insert_sort = InsertSort()
    result = insert_sort.sort(data, order)
    print result


if __name__ == '__main__':
    main()