An effective algorithm for finding items from a sorted list of binary search items.

With sorted datasets, we can take advantage of sorting orders that are more efficient than element by element, such as linear layout.

What if you started with an estimate of 1?

Binary search.

It is important to note that binary search only works on a list that is already configured.

** ثنائی عمل **

Binary search requires configurable datasets.

Step 1. Check the median value of the dataset. If this value matches our target we can return the index.

Step 2. If the median value is less than our target. Start at step 1 using the right half of the list.

Step 3. If the median value exceeds our target. Start at step 1 using the left half of the list.

Eventually we move away from the values in the list, or find the target value.

** مثال **

To find the number ` 28 `

In the following list ` Check that the mean value, `

` 22 `

, is equal to the target number ` Because `

` 28 and GT22 `

we will now see the right half of the row:

```
``` [28, 36, 50]

Check that the median value, ` 36 `

, is equal to the target number ` Because `` 28 & late 36 `

Now we will see the item (s) on the left:

```
``` [28]

Check the middle value, ` 28 `

, then the target number ` Back `` 28 `

```
```

Let's talk about how to do this over and over again! Iteratively: We keep iterating through the same set of instructions. Recursively: We solve a problem by having a method call itself.

** Frequent Point of View **

There is an old computer science joke that "to understand repetition, one must first understand thinking."

Powerful is a powerful tool for resolving recurring problems that requires multiple execution of up to one condition, or * *** base case ** complete. It happens.

** Implement iteration in Java **

Our ` binary search () `

method will accept the following parameters:

class BinarySearch { public static int binarySearch(int[] arr, int left, int right, int target) { // implement steps here } public static void main(String[] args) { int[] arr = { 2, 5, 6, 8, 9, 10 }; int target = 8; int left = 0; int right = arr.length - 1; int index = binarySearch(arr, left, right, target); if (index != -1) { System.out.println("Element found at index " + index); } else { System.out.println("Element not found in the array"); } } }
There are many possible ways to implement this algorithm with repetition in Java.

Step 1. Create a variable.

Step 2. Create a basic case, create a scenario where we are preventing repetition, which checks whether our ` target `

Equivalent to the price.

Step 3. Create 2 recurring terms:

Check if target is less than the value of our input array at index mid. If true, return the value of recursively calling binarySearch(), passing in values to search the left half of our array. Check if target is greater than the value of array at index mid. If true, return the value of recursively calling binarySearch(), passing in values to search the right half of our array.

Step 4. Create another base case that checks out our search space.

** Another AMP two steps: define the midpoint and return the target index if found **

We will check the ` IN `

, ```
```

`5 / 2; // 2`

```
``` Now that we have found our midpoint, we can see if it is equal to our target value.