数据结构与算法

基础数据结构篇

初识算法

二分查找

算法描述

需求：在有序数组 A 内，查找值 target

• 如果找到返回索引
• 如果找不到返回 -1

算法 描述	方法一	方法二
前提	给定一个内含 n 个元素的有序数组 A，满足 $A_0$ $\le$ $A_1$ $\le$ $A_2$ $\le$ . . . $\le$ $A_{n-1}$ ,一个待查值 target	给定一个内含 n 个元素的有序数组 A，满足 $A_0$ $\le$ $A_1$ $\le$ $A_2$ $\le$ . . . $\le$ $A_{n-1}$ ,一个待查值 target
1	设置 i = 0, j = n - 1 (索引 i 和 j 指向的元素都参与运算)	设置 i = 0, j = n (索引 j 指向的元素不参与运算)
2	如果 i > j ,结束查找，没找到	如果 i >= j ,结束查找，没找到
3	设置 m = floor($\frac{i+j}{2}$) , m为中间索引，floor 是向下取整	设置 m = floor($\frac{i+j}{2}$) , m为中间索引，floor 是向下取整
4	如果 target $<$ $A_m$ 设置 j = m - 1, 跳到第 2 步	如果 target $<$ $A_m$ 设置 j = m , 跳到第 2 步
5	如果 $A_m$ $<$ target 设置 j = m +1, 跳到第 2 步	如果 $A_m$ $<$ target 设置 j = m +1, 跳到第 2 步
6	如果 $A_m$ = target 结束查找，找到了	如果 $A_m$ = target 结束查找，找到了

**总结：**方法一和方法二的不同主要是因为索引 j 指向的元素是否参与运算

代码实现

package Just.binary;

import java.util.Scanner;

public class BinarySearch {
    public static void main(String[] args) {
        //待查找的目标值——target,手动输入
        Scanner sc = new Scanner(System.in);
        System.out.println("输入待查找值：");
        int target = sc.nextInt();
        //待查找的升序数组
        int [] arr = {7,13,21,30,38,44,52,53};
        //定义变量，用来接收返回值
        //调用方法一
        //int num = binarySearchBasic1(arr,target);
        //调用方法二
        int num = binarySearchBasic2(arr,target);
        if(num == -1){
            System.out.println("未找到");
        }else{
            System.out.println("成功找到，索引为" + num);
        }
    }

    //二分查找
    //方法一：
    public static int binarySearchBasic1(int [] arr,int target){
        //定义数组的开头元素索引
        int i = 0;
        //定义数组的结尾元素索引
        int j = arr.length - 1;
        //while循环对数组进行遍历
        while(i <= j){

            //定义数组中索引i和索引j之间的中间索引
            int m = (i + j)/2;
            //把待查值target与中间索引对应的值相比较，确定待查值target所在区间
            if(target < arr[m]){
                //target值小于arr[m],说明如果target存在，在m索引左边，让j = m - 1，继续循环判断
                j = m - 1;
            }else if(target > arr[m]){
                //target值大于arr[m],说明如果target存在，在m索引右边，让j = m + 1，继续循环判断
                i = m + 1;
            }else{
                //target既不大于也不小于，说明target等于arr[m],返回索引
                return m;
            }
        }
        //如果在数组中不存在，返回-1
        return -1;
    }

    //方法二：
    public static int binarySearchBasic2(int [] arr,int target){
        //定义数组的开头元素索引
        int i = 0;
        //定义数组的结尾元素索引
        int j = arr.length;
        //while循环对数组进行遍历
        while(i < j){

            //定义数组中索引i和索引j之间的中间索引
            int m = (i + j) >>> 1;
            //把待查值target与中间索引对应的值相比较，确定待查值target所在区间
            if(target < arr[m]){
                //target值小于arr[m],说明如果target存在，在m索引左边，让j = m - 1，继续循环判断
                j = m;
            }else if(target > arr[m]){
                //target值大于arr[m],说明如果target存在，在m索引右边，让j = m + 1，继续循环判断
                i = m + 1;
            }else{
                //target既不大于也不小于，说明target等于arr[m],返回索引
                return m;
            }
        }
        //如果在数组中不存在，返回-1
        return -1;
    }
}
------------------------------------------------------------------------------------------
运行结果：
输入待查找值：
7
成功找到，索引为0

输入待查找值：
66
未找到

注意：

• 求中间值索引：m = ( i + j )/2 ;可以使用 无符号右移运算符 >>> 1

​ m = ( i + j ) >>> 1;

衡量算法好坏

时间复杂度

计算机科学中，时间复杂度是用来衡量：一个算法的执行，随数据规模增大，而增长的时间成本

• 不依赖于环境

如何表示时间复杂度呢？

• 假设算法要处理的数据规模是n，代码总的执行行数 f(n) 来表示，例如：
  • 线性查找算法的函数 f(n) = 3*n + 3
  • 二分查找算法的函数 f(n) = ( floor( $lo{g}_2$(n) ) + 1) * 5 + 4
• 为了对 f(n) 进行化简，应当抓住主要矛盾，找到一个变化趋势与之相近的表示方法

大 O 表示法

其中

• $c$ , $c_1$ , $c_2$ 都是一个常数
• $f(n)$ 是实际执行代码行数与$n$ 的函数
• $g(n)$ 是经过简化，变化趋势与$f(n)$ 一致的$n$ 的函数

asymptotic upper bound

**渐进上界：**从某个常数$n_0$ 开始，$c\ast g(n)$ 总是位于$f(n)$ 上方，那么记作$O(g(n))$

• 举例：$f(n)=n^2+100$ ,从$n_0=10$ 时，$g(n)=2\ast n^2$ 是它渐进上界，记作$O(n^2)$

例1：

• $f(n)=3\ast n+3$
• $g(n)=n$
• 取$c=4$ , 在$n_0=3$ 之后，$g(n)$ 可以作为$f(n)$ 的渐进上界，因此表示法写作$O(n)$

例2：

• $f(n)=5\ast floor(lo{g}_2(n))+9$
• $g(n)=lo{g}_2(n)$
• $O(lo{g}_2(n))$

已知$f(n)$来说，求$g(n)$

• 表达式中相乘的常量，可以省略，如

  • $f(n)=100\ast n^2$中的$n$

• 多项式中数量规模较小（低次项）的表达式可以省略，如

  • $f(n)=n^2+n$中的$n$
  • $f(n)=n^3+n^2$中的$n$

• 不同底数的对数，渐进上界可以用一个对数函数$lo{g}_n$表示

  • 例如：$lo{g}_2(n)$可以替换为$lo{g}_{1}0(n)$

• 类似的，对数的常数次幂可以省略

  • 如：$log(n^c)=c\ast log(n)$

常见大$O$表示法

按时间复杂度从低到高

• $O(1)$ ，常量时间，意味着算法时间并不随数据规模而变化
• $O(log(n))$ ，对数时间
• $O(n)$ ，线性时间，算法时间与数据规模成正比
• $O(n\ast log(n))$，拟线性时间
• $O(n^2)$ ，平方时间
• $O(2^n)$ ，指数时间
• $O(n!)$

空间复杂度

与时间复杂度类似，一般也使用大$O$表示法来衡量：一个算法执行随数据规模增大，而增长的额外空间成本

举例：

public static int binarySearchBasic1(int [] arr,int target){
        int i = 0,int j = arr.length - 1;      //设置指针和初值
        while(i <= j){                         //i~j 范围内有东西
            int m = (i + j)/2;
            if(target < arr[m]){               // 目标在左边
                j = m - 1;
            }else if(target > arr[m]){         // 目标在右边
                i = m + 1;
            }else{                             // 找到了
                return m;
            }
        }       
        return -1;
    }

空间复杂度——额外空间成本

​ 在本例中，额外的空间成本是 i、j 和 m 占用的空间，由于其三个都是整形，所以占12个字节，空间复杂度：$O(1)$

二分查找性能

下面分析二分查找算法的性能

时间复杂度

• 最坏情况：$O(lo{g}_2(n))$
• 最好情况：如果待查找元素恰好在数组中央，只需要循环一次$O(1)$

空间复杂度

• 需要常数个指针 i ，j，m，因此额外暂用的空间是$O(1)$