编写程序： 用二分法在有序表{3,4,10,13,33,42,46,63,76,78,95,96,120}中查找一个给定的数。

### 回答1：
可以使用二分法来查找一个给定的数。具体步骤如下：

1. 定义一个有序表，例如：{3,4,10,13,33,42,46,63,76,78,95,96,120}。

2. 定义要查找的数，例如：33。

3. 定义左右边界，初始时左边界为，右边界为有序表的长度减1。

4. 进入循环，每次将左右边界的中间值与要查找的数进行比较。

5. 如果中间值等于要查找的数，则返回中间值的下标。

6. 如果中间值大于要查找的数，则将右边界移动到中间值的左边一位。

7. 如果中间值小于要查找的数，则将左边界移动到中间值的右边一位。

8. 如果左边界大于右边界，则说明要查找的数不存在于有序表中，返回-1。

下面是具体的代码实现：

def binary_search(arr, target):
    left, right = , len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] > target:
            right = mid - 1
        else:
            left = mid + 1
    return -1

arr = [3,4,10,13,33,42,46,63,76,78,95,96,120]
target = 33
result = binary_search(arr, target)
print(result)  # 输出：4

在上面的代码中，我们定义了一个函数`binary_search`，它接受两个参数：有序表`arr`和要查找的数`target`。函数内部使用了二分法来查找`target`在`arr`中的下标，如果找到了则返回下标，否则返回-1。最后我们定义了一个有序表和要查找的数，调用`binary_search`函数并输出结果。

### 回答2：
二分法（Binary Search）又称折半查找，是一种在有序数组中查找某一特定元素的搜索算法。它的搜索过程类似于我们猜数字时采用的方法：猜想一个数字，如果猜小了，就把数值范围缩小到猜的数字到最大值之间，如果猜大了，就把范围缩小到最小值和猜的数字之间。通过这种方式反复猜测，最终就能找到目标数字。

在有序表{3，4，10，13，33，42，46，63，76，78，95，96，120}中查找一个给定的数，我们就可以用二分法来完成。具体实现步骤如下：

1. 取有序表的中间位置，即取数组下标为（left+right）/2的元素。

2. 将查找元素与该位置的元素进行比较，如果相等，就直接返回该位置，查找成功；如果查找元素小于该位置的元素，则在左半边继续查找（即令right=(left+right)/2-1），否则在右半边查找（即令left=(left+right)/2+1）。

3. 重复以上步骤，直到left>right为止，此时查找失败。

下面是用Python实现该程序：

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid  # 查找成功，返回下标
        elif arr[mid] < target:
            left = mid + 1  # 在右半边继续查找
        else:
            right = mid - 1  # 在左半边继续查找
    return -1  # 查找失败

在主程序中调用该函数，即可完成对给定数的查找：

arr = [3, 4, 10, 13, 33, 42, 46, 63, 76, 78, 95, 96, 120]
target = 33
result = binary_search(arr, target)
if result != -1:
    print(f"查找成功，目标数{target}的下标为{result}")
else:
    print("查找失败！")

运行程序，输出结果为：

查找成功，目标数33的下标为4

因为我们的目标数是33，而在有序表中，33的下标恰好为4，所以该程序的查找结果是正确的。

总结来说，二分法是一种高效的查找算法，适用于大规模数据的查找。但要注意的是，该算法的前提条件是有序表，如果数据无序，则需要先进行排序，才能使用二分法进行查找。

### 回答3：
二分查找法，也称折半查找法，是常用的一种查找算法。二分查找法在有序序列中查找某一元素时，每次都取中间位置的元素进行比较，通过一定的比较运算缩小查找范围，直至找到该元素或查找结束。

本题中，我们有一个有序表 {3，4，10，13，33，42，46，63，76，78，95，96，120}。我们要查找其中是否有给定的数，假设该数为 n。

用二分法查找时，首先找到有序表的中间元素，把它与要查找的数 n 进行比较，如果相等，则找到了该数，返回它的位置；如果中间元素大于要查找的数 n，则在左半部分继续查找；如果中间元素小于要查找的数 n，则在右半部分继续查找。通过不断折半，最终可以找到要查找的数或者确定该数不存在于有序表中。

在程序实现时，我们可以使用循环或者递归的方式进行二分查找。下面是使用循环的代码实现：

def binary_search(arr, n):
    low = 0
    high = len(arr) - 1
    
    while low <= high:
        mid = (low + high) // 2
        
        if arr[mid] == n:
            return mid
        elif arr[mid] > n:
            high = mid - 1
        else:
            low = mid + 1
    
    return -1

在这个代码中，我们定义了一个函数 binary_search，它接受一个有序表 arr 和要查找的数 n。我们使用两个变量 low 和 high 来表示有序表的起始位置和结束位置。在循环中，我们计算中间位置 mid，并对该位置的元素进行比较。

如果 arr[mid] 等于要查找的数 n，那么说明找到了该数，返回 mid。如果 arr[mid] 大于要查找的数 n，那么说明要查找的数在左半部分，因此更新 high 的值为 mid - 1。如果 arr[mid] 小于要查找的数 n，那么说明要查找的数在右半部分，因此更新 low 的值为 mid + 1。

如果循环结束时仍然没有找到要查找的数，那么说明该数不存在于有序表中，返回 -1。

使用上述代码，可以很方便地在给定的有序表中查找一个数。虽然该算法的时间复杂度为 O(log n)，但是在有序表中查找是十分高效的。