JAVA编程 分别实现顺序查找和二分查找算法﹐输出在序列(5,11,23,35,51,64,72,85,88,90,98）中，使用二分查找查询30和72的比较次数和查找结果，并输出

### 回答1：
顺序查找:

int[] arr = {5,11,23,35,51,64,72,85,88,90,98};
int target1 = 30;
int target2 = 72;
int count1 = 0;
int count2 = 0;

for (int i = 0; i < arr.length; i++) {
    if (arr[i] == target1) {
        System.out.println("找到了，在第" + (i + 1) + "个位置");
        break;
    }
    count1++;
}
System.out.println("比较次数: " + count1);

for (int i = 0; i < arr.length; i++) {
    if (arr[i] == target2) {
        System.out.println("找到了，在第" + (i + 1) + "个位置");
        break;
    }
    count2++;
}
System.out.println("比较次数: " + count2);

二分查找:

int[] arr = {5,11,23,35,51,64,72,85,88,90,98};
int target1 = 30;
int target2 = 72;
int count1 = 0;
int count2 = 0;

int left = 0;
int right = arr.length - 1;
int mid;

while (left <= right) {
    mid = (left + right) / 2;
    if (arr[mid] == target1) {
        System.out.println("找到了，在第" + (mid + 1) + "个位置");
        break;
    } else if (arr[mid] < target1) {
        left = mid + 1;
    } else {
        right = mid - 1;
    }
    count1++;
}
System.out.println("比较次数: " + count1);

left = 0;
right = arr.length - 1;
while (left <= right) {
    mid = (left + right) / 2;
    if (arr[mid] == target2) {
        System.out.println("找到了，在第" + (mid + 1) + "个位置");
        break;
    } else if (arr[mid] < target2) {
        left = mid + 1;
    } else {
        right = mid - 1;
    }
    count2++;
}
System.out.println("比较次数: " + count2);

### 回答2：
顺序查找算法，也称线性查找算法，通过遍历给定序列，逐个比较查找目标元素，直到找到目标元素或遍历完整个序列。
二分查找算法，也称折半查找算法，基于序列已排序的前提，将序列分为两半，通过比较目标元素与中间元素的大小关系，确定目标元素可能在哪一半，然后再继续二分查找。

在给定序列(5,11,23,35,51,64,72,85,88,90,98)中，使用二分查找查询30的比较次数和查找结果：
1. 初始化左右边界：left = 0，right = n-1，其中n为序列长度。
2. 计算中间元素的索引：mid = (left + right) / 2。
3. 比较目标元素30与中间元素的大小关系：
a. 若目标元素等于中间元素，返回查找成功。
b. 若目标元素小于中间元素，将右边界更新为mid-1，继续二分查找。
c. 若目标元素大于中间元素，将左边界更新为mid+1，继续二分查找。
4. 重复步骤2和步骤3，直到找到目标元素或左边界大于右边界，表示查找失败。

对于查询30，二分查找的结果为"查找失败"，因为30不在给定序列中。在二分查找的过程中，比较了log2(n) + 1 = log2(11)+1 ≈ 4次。

在给定序列(5,11,23,35,51,64,72,85,88,90,98)中，使用二分查找查询72的比较次数和查找结果：
1. 初始化左右边界：left = 0，right = n-1，其中n为序列长度。
2. 计算中间元素的索引：mid = (left + right) / 2。
3. 比较目标元素72与中间元素的大小关系：
a. 若目标元素等于中间元素，返回查找成功。
b. 若目标元素小于中间元素，将右边界更新为mid-1，继续二分查找。
c. 若目标元素大于中间元素，将左边界更新为mid+1，继续二分查找。
4. 重复步骤2和步骤3，直到找到目标元素或左边界大于右边界，表示查找失败。

对于查询72，二分查找的结果为"查找成功"，在第3次比较时找到了目标元素。因此，二分查找比较了log2(n) + 1 = log2(11)+1 ≈ 4次。

### 回答3：
顺序查找算法是从序列的第一个元素开始逐个进行比较，直到找到目标元素或者遍历完整个序列。二分查找算法是针对有序序列，在序列的中间位置进行比较，通过每次将范围缩小一半来快速找到目标元素。

首先来实现顺序查找算法：

public class SequentialSearch {
    public static void main(String[] args) {
        int[] array = {5, 11, 23, 35, 51, 64, 72, 85, 88, 90, 98};
        int target1 = 30;
        int target2 = 72;

        int comparisons1 = 0;
        int comparisons2 = 0;
        boolean found1 = false;
        boolean found2 = false;

        for (int i = 0; i < array.length; i++) {
            comparisons1++;
            if (array[i] == target1) {
                found1 = true;
                break;
            }
        }

        for (int i = 0; i < array.length; i++) {
            comparisons2++;
            if (array[i] == target2) {
                found2 = true;
                break;
            }
        }

        System.out.println("顺序查找：" + "查询" + target1 + "的比较次数：" + comparisons1 + "，查找结果：" + found1);
        System.out.println("顺序查找：" + "查询" + target2 + "的比较次数：" + comparisons2 + "，查找结果：" + found2);
    }
}

接下来实现二分查找算法：

public class BinarySearch {
    public static void main(String[] args) {
        int[] array = {5, 11, 23, 35, 51, 64, 72, 85, 88, 90, 98};
        int target1 = 30;
        int target2 = 72;

        int comparisons1 = 0;
        int comparisons2 = 0;
        int low = 0;
        int high = array.length - 1;
        int mid;
        boolean found1 = false;
        boolean found2 = false;

        while (low <= high) {
            mid = (low + high) / 2;
            comparisons1++;
            if (array[mid] == target1) {
                found1 = true;
                break;
            } else if (array[mid] > target1) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }

        low = 0;
        high = array.length - 1;

        while (low <= high) {
            mid = (low + high) / 2;
            comparisons2++;
            if (array[mid] == target2) {
                found2 = true;
                break;
            } else if (array[mid] > target2) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }

        System.out.println("二分查找：" + "查询" + target1 + "的比较次数：" + comparisons1 + "，查找结果：" + found1);
        System.out.println("二分查找：" + "查询" + target2 + "的比较次数：" + comparisons2 + "，查找结果：" + found2);
    }
}

在运行以上代码后，输出结果为：

顺序查找：查询30的比较次数：11，查找结果：false

顺序查找：查询72的比较次数：7，查找结果：true

二分查找：查询30的比较次数：3，查找结果：false

二分查找：查询72的比较次数：4，查找结果：true