写一个二分查找的代码

// 二分查找代码：

int binarySearch(int arr[], int l, int r, int x)
{
if (r >= l)
{
int mid = l + (r - l)/2;

// 如果中间元素是要查找的元素，则返回
if (arr[mid] == x)
return mid;

// 如果中间元素大于要查找的元素，则搜索左半部分
if (arr[mid] > x)
return binarySearch(arr, l, mid-1, x);

// 如果中间元素小于要查找的元素，则搜索右半部分
return binarySearch(arr, mid+1, r, x);
}

// 如果没有找到，则返回-1
return -1;
}

相关问题

帮我写一个二分查找代码

### 回答1：

def binary_search(arr, target):
left = 0
right = 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我可以为你写一段二分查找代码：def 二分查找(arr, target):
left = 0
right = 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

### 回答2：
二分查找(also known as 二分搜索)是一种在有序数组中查找特定元素的算法。它的原理是将数组分成两部分，然后确定目标元素位于哪一部分中，并继续将该部分一分为二，直到找到目标元素或者确定目标元素不存在为止。

下面是一个简单的二分查找的代码示例:

def binary_search(arr, target):
    low = 0
    high = len(arr) - 1

    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1

    return -1

# 测试
arr = [1, 3, 5, 7, 9, 11, 13]
target = 9
index = binary_search(arr, target)
if index != -1:
    print(f"找到目标元素 {target}，在索引位置 {index}。")
else:
    print(f"未找到目标元素 {target}。")

这个二分查找代码中，我们传入一个有序数组 `arr` 和目标元素 `target`，然后使用变量 `low` 和 `high` 分别在数组的最低和最高索引之间进行二分查找。

在每个循环迭代中，我们通过计算 `mid` 来找到数组的中间索引，然后将该索引处的元素与目标元素进行比较。如果它们相等，说明找到了目标元素，返回该索引。如果目标元素比中间元素大，说明目标元素在数组的后半部分，我们将 `low` 更新为 `mid + 1`。如果目标元素比中间元素小，说明目标元素在数组的前半部分，我们将 `high` 更新为 `mid - 1`。

如果循环结束后仍然没有找到目标元素，返回 -1 表示未找到。在示例测试中，我们使用 `[1, 3, 5, 7, 9, 11, 13]` 这个有序数组，在其中查找元素 9，最终返回值为 4，表示目标元素 9 在数组中的索引位置为 4。

希望以上代码能够帮助到您！

### 回答3：
二分查找也被称为折半查找，是一种高效的查找算法。下面是一个用Python编写的二分查找代码示例：

def binary_search(arr, target):
    low = 0
    high = len(arr) - 1

    while low <= high:
        mid = (low + high) // 2

        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1

    return -1  # 如果找不到目标元素，返回-1

# 测试代码
arr = [1, 3, 5, 7, 9, 11, 13, 15]
target = 7

result = binary_search(arr, target)
if result != -1:
    print("目标元素的索引是:", result)
else:
    print("目标元素不存在.")

这段代码使用了一个循环来不断缩小查找的范围，直到目标元素被找到或者范围缩小至空。在每一次循环中，我们取中间元素的索引并将其与目标元素进行比较。如果目标元素等于中间元素，则返回中间元素的索引；如果目标元素大于中间元素，则说明目标元素在后半部分，将查找范围缩小为后半部分；如果目标元素小于中间元素，则说明目标元素在前半部分，将查找范围缩小为前半部分。如果循环结束时仍未找到目标元素，则返回-1。

在上述代码中，我们将目标元素设为7进行测试，如果找到了目标元素，则打印其索引；否则，打印“目标元素不存在”。

用abap写一个二分查找代码

### 回答1：
以下是在 SAP ABAP 中实现二分查找的代码示例：

REPORT z_binary_search.

DATA: lv_array TYPE STANDARD TABLE OF i,
      lv_value TYPE i,
      lv_index TYPE i,
      lv_found TYPE abap_bool.

* 初始化数组
lv_array = VALUE #( (1) (2) (3) (4) (5) ).

* 要查找的值
lv_value = 3.

* 初始化查找边界
DATA(lv_low) = 1.
DATA(lv_high) = lines( lv_array ).

* 开始二分查找
WHILE lv_low <= lv_high.
  lv_index = lv_low + trunc( ( lv_high - lv_low ) / 2 ).
  IF lv_array[ lv_index ] EQ lv_value.
    lv_found = abap_true.
    EXIT.
  ELSEIF lv_array[ lv_index ] < lv_value.
    lv_low = lv_index + 1.
  ELSE.
    lv_high = lv_index - 1.
  ENDIF.
ENDWHILE.

* 输出结果
IF lv_found = abap_true.
  WRITE:/ '找到了 ', lv_value, ' 在数组中的索引为 ', lv_index.
ELSE.
  WRITE:/ '未找到 ', lv_value, ' 在数组中的索引。'.
ENDIF.

该代码首先创建一个整数数组 `lv_array`，其中包含 1 到 5 的整数。然后它定义了要查找的值 `lv_value`，以及一个名为 `lv_index` 的变量来保存找到的索引，以及一个布尔变量 `lv_found` 来表示是否找到了该值。接下来，代码初始化了查找边界 `lv_low` 和 `lv_high`，开始二分查找。

在每次迭代中，代码计算数组的中间索引 `lv_index`，并根据该值与 `lv_value` 的比较结果更新 `lv_low` 或 `lv_high`。如果找到了 `lv_value`，则将 `lv_found` 设置为真，并退出循环。最后，代码根据 `lv_found` 的值输出结果。

请注意，此示例仅针对整数数组。如果需要在更复杂的数据结构中进行二分查找，则需要根据情况修改代码。

### 回答2：
ABAP是一种面向对象的编程语言，用于开发SAP系统。下面是一个用ABAP语言编写的二分查找代码示例：

DATA: lv_table TYPE STANDARD TABLE OF i WITH DEFAULT KEY,
lv_search_value TYPE i VALUE 10,
lv_low TYPE i,
lv_high TYPE i,
lv_middle TYPE i.

lv_table = VALUE #( (1), (4), (7), (10), (13), (16), (19) ).

SORT lv_table ASCENDING.

lv_low = 1.
lv_high = LINES( lv_table ).

WHILE lv_low <= lv_high.
lv_middle = ( lv_low + lv_high ) / 2.

IF lv_table[ lv_middle ] = lv_search_value.
WRITE: '要查找的数值在表中的索引为', lv_middle.
EXIT.
ELSEIF lv_table[ lv_middle ] < lv_search_value.
lv_low = lv_middle + 1.
ELSE.
lv_high = lv_middle - 1.
ENDIF.
ENDWHILE.

IF lv_low > lv_high.
WRITE: '要查找的数值在表中不存在'.
ENDIF.

上面的代码首先定义了一个整型的内表lv_table，并初始化了一些数据。然后使用SORT语句对内表进行升序排序。

接下来，定义了变量lv_low和lv_high用于表示查找范围的下界和上界。通过循环，不断更新lv_low和lv_high的值，直到lv_low大于lv_high为止。

在每次循环中，求出当前查找范围的中间索引lv_middle，并将当前索引处的元素与要查找的值进行比较。如果相等，则找到了要查找的值，输出其索引，并使用EXIT语句退出循环。如果当前索引处的值小于要查找的值，则将lv_middle加1，更新lv_low的值；否则，将lv_middle减1，更新lv_high的值。

循环结束后，通过判断lv_low是否大于lv_high，来确定要查找的值是否存在于表中。

### 回答3：
二分查找是一种高效的查找算法，可以在有序数组中快速定位目标值。在ABAP中，可以使用以下代码实现二分查找：

首先，定义一个函数来实现二分查找：

FUNCTION binary_search.
  DATA: lv_result TYPE i,
        lv_low    TYPE i,
        lv_high   TYPE i,
        lv_mid    TYPE i.

  lv_low  = 0.
  lv_high = lines(p_values) - 1.

  WHILE lv_low <= lv_high.
    lv_mid = ( lv_low + lv_high ) / 2.

    IF p_values[ lv_mid ] = p_target.
      lv_result = lv_mid.
      EXIT.
    ELSEIF p_values[ lv_mid ] < p_target.
      lv_low = lv_mid + 1.
    ELSE.
      lv_high = lv_mid - 1.
    ENDIF.
  ENDWHILE.

  IF lv_result = 0.
    WRITE: '目标值未找到' .
  ELSE.
    WRITE: '目标值的索引为', lv_result .
  ENDIF.

ENDFUNCTION.

在调用函数时，需要传入有序数组 `p_values` 和目标值 `p_target`。函数会返回目标值在数组中的索引位置，如果目标值不存在，则会输出"目标值未找到"。

例如，现有一个有序数组 `lv_array` ：

DATA: lv_array TYPE TABLE OF i,
      lv_target TYPE i.

lv_array = VALUE #( (1) (2) (3) (4) (5) ).
lv_target = 3.

CALL FUNCTION 'binary_search'
  EXPORTING
    p_values = lv_array
    p_target = lv_target.

运行代码，会输出目标值的索引位置3。

这是一个简单的ABAP二分查找实现。通过每次比较目标值和数组中间元素的大小关系，可以快速缩小查找范围，提高查找效率。