常见排序算法(二分,希尔)

活动地址:CSDN21天学习挑战赛

1. 二分查找

算法描述

  1. 前提:有已排序数组 A(假设已经做好)
  2. 定义左边界 L、右边界 R,确定搜索范围,循环执行二分查找(3、4两步)
  3. 获取中间索引 M = Floor((L+R) /2)
  4. 中间索引的值 A[M] 与待搜索的值 T 进行比较
    ① A[M] == T 表示找到,返回中间索引
    ② A[M] > T,中间值右侧的其它元素都大于 T,无需比较,中间索引左边去找,M - 1 设置为右边界,重新查找
    ③ A[M] < T,中间值左侧的其它元素都小于 T,无需比较,中间索引右边去找, M + 1 设置为左边界,重新查找
  5. 当 L > R 时,表示没有找到,应结束循环

算法实现

   public static int binarySearch(int[] a, int t) {
    
    
        int l = 0, r = a.length - 1, m;
        while (l <= r) {
    
    
            m = (l + r) / 2;
            if (a[m] == t) {
    
    
                return m;
            } else if (a[m] > t) {
    
    
                r = m - 1;
            } else {
    
    
                l = m + 1;
            }
        }
        return -1;
    }

测试代码

 public static void main(String[] args) {
    
    
        int[] array = {
    
    1, 5, 8, 11, 19, 22, 31, 35, 40, 45, 48, 49, 50};
        int target = 47;
        int idx = binarySearch(array, target);
        System.out.println(idx);
    }

解决整数溢出问题

当 l 和 r 都较大时,l + r 有可能超过整数范围,造成运算错误,解决方法有两种:

int m = l + (r - l) / 2;

还有一种是:

int m = (l + r) >>> 1;

其它考法

  1. 有一个有序表为 1,5,8,11,19,22,31,35,40,45,48,49,50 当二分查找值为 48 的结点时,查找成功需要比较的次数
  2. 使用二分法在序列 1,4,6,7,15,33,39,50,64,78,75,81,89,96 中查找元素 81 时,需要经过( )次比较
  3. 在拥有128个元素的数组中二分查找一个数,需要比较的次数最多不超过多少次

对于前两个题目,记得一个简要判断口诀:奇数二分取中间,偶数二分取中间靠左。对于后一道题目,需要知道公式:

n = log_2N = log_{10}N/log_{10}2

其中 n 为查找次数,N 为元素个数

2. 希尔排序

算法描述

  1. 首先选取一个间隙序列,如 (n/2,n/4 … 1),n 为数组长度
  2. 每一轮将间隙相等的元素视为一组,对组内元素进行插入排序,目的有二
    ① 少量元素插入排序速度很快
    ② 让组内值较大的元素更快地移动到后方
  3. 当间隙逐渐减少,直至为 1 时,即可完成排序

算法实现

   private static void shell(int[] a) {
    
    
        int n = a.length;
        for (int gap = n / 2; gap > 0; gap /= 2) {
    
    
            // i 代表待插入元素的索引
            for (int i = gap; i < n; i++) {
    
    
                int t = a[i]; // 代表待插入的元素值
                int j = i;
                while (j >= gap) {
    
    
                    // 每次与上一个间隙为 gap 的元素进行插入排序
                    if (t < a[j - gap]) {
    
     // j-gap 是上一个元素索引,如果 > t,后移
                        a[j] = a[j - gap];
                        j -= gap;
                    } else {
    
     // 如果 j-1 已经 <= t, 则 j 就是插入位置
                        break;
                    }
                }
                a[j] = t;
                System.out.println(Arrays.toString(a) + " gap:" + gap);
            }
        }
    }

猜你喜欢

转载自blog.csdn.net/qq_45228323/article/details/126238076