20210420-算法学习-程序员常用的10种算法(Algorithm)-二分查找(BinarySearch)-非递归

一.【二分查找法(非递归)】

　　1.二分查找法(非递归)介绍

　　　　1）之前我们学习过了二分查找法，使用的是递归形式，下面我们讲解一下二分查找法(非递归)方式

　　　　2）二分查找法只适用于，从有序的数列中进行查找(比如数字和字母等)，将数列排序后再进行查找

　　　　3）二分查找法的运行时间为对数时间O(log2n)，即查找到需要的目标位置最多只需要log2 n步，假设从[0,99]的队列(100个数，即n = 100)中寻找目标数 30，则需要查找的步数为log2 100，即最多需要查找7次(2^6<100<2^7)

二.【二分查找法(非递归)代码实现】

　　1.给定一组无序数组 int[] arr = {2, 5, 7, 6, 4, 1, 3, 9, 8, 10}; 编写二分查找，要求使用非递归方式完成

　　　　1）要知道二分查找法只适用于有序数组，所以要先给无序数组进行排序，然后再进行二分查找

　　2.代码示例

package com.atProjectCombat;
/**
 * @Author: lisongtao
 * @Date: 2021/4/20 9:30
 */


import java.util.Arrays;

/**
 * @ClassName BinarySearchNoRecur
 * @Description : 二分查找法(非递归)
 * @Author DELL
 * @Date 2021/04/20 09:30
 **/
public class BinarySearchNoRecur {
    public static void main(String[] args) {
        //给定一段无序数组
        int[] arr = {2, 5, 7, 6, 4, 1, 3, 9, 8, 10};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
        int binarySearch = binarySearch(arr, 6);
        System.out.println(binarySearch);
    }

    //先给数组进行排序(这里使用快速排序)
    public static void quickSort(int[] arr, int left, int right) {
        int L = left;//左下标
        int R = right;//右下标

        int pivot = arr[(left + right) / 2];//获取中间轴
        int temp = 0;//作为交换时的临时变量

        while (L < R) {
            //先在左边开始找，找到大于中轴的值才退出
            while (arr[L] < pivot) {
                L += 1;
            }
            //在右边一直找，直到找出大于中轴的值才退出
            while (arr[R] > pivot) {
                R -= 1;
            }
            //如果 L >= R 说明 pivot的左右两边的值，已经按照 左边小于等于 pivot值，而右边全部是大于等于 pivot值
            if (L >= R) {
                break;
            }
            //交换
            temp = arr[L];
            arr[L] = arr[R];
            arr[R] = temp;

            //如果交换完后，发现 arr[L] == pivot 值相等，R--，并后移
            if (arr[L] == pivot) {
                R -= 1;
            }

            //如果交换完后，发现 arr[R] == pivot 值相等，L++，并后移
            if (arr[R] == pivot) {
                L += 1;
            }

        }

        //判断，如果 L==R，必须 L++，R--，否则会出现栈溢出
        if (L == R) {
            L += 1;
            R -= 1;
        }
        //向左递归
        if (left < R) {
            quickSort(arr, left, R);
        }
        //向右递归
        if (right > L) {
            quickSort(arr, L, right);
        }


    }

    /**
     * 二分查找法(非递归实现)
     *
     * @return int 返回对应下标，-1 表示没有找到
     * @Author lisongtao
     * @Description :
     * @Date 2021/4/20 10:02
     * @Param [arr 待查找的数组  arr是升序排序, value 需要查找的数]
     **/
    public static int binarySearch(int[] arr, int value) {
        int left = 0;
        int right = arr.length - 1;

        while (left <= right) {//说明继续查找
            int pivot = (left + right) / 2;
            if (arr[pivot] == value) {
                return pivot;
            } else if (arr[pivot] > value) {
                right = pivot - 1;//需要向左边查找
            } else {
                left = pivot + 1;//需要向右边查找
            }

        }
        return -1;
    }
}