Yes, the algorithm described is known as "Binary Search". It is an efficient search algorithm that operates by repeatedly dividing in half the portion of the list that could contain the target value, until the possible locations have been reduced to just one.

Here is a Python code that implements the recursive binary search algorithm:

```python
def binary_search(arr, target, low, high):
    if high >= low:
        mid = (low + high) // 2

        # Check if the element at mid is the target
        if arr[mid] == target:
            return mid

        # If the element at mid is larger, search in the left subarray
        elif arr[mid] > target:
            return binary_search(arr, target, low, mid - 1)
        
        # If the element at mid is smaller, search in the right subarray
        else:
            return binary_search(arr, target, mid + 1, high)
    else:
        # If the element is not present in the array
        return -1

# Test the function
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
target_value = 7
result = binary_search(my_list, target_value, 0, len(my_list) - 1)

print("The index of the target is:", result) if result != -1 else print("Target not found")
```

In this code:
- `arr` is the ordered list.
- `target` is the value we're looking for.
- `low` and `high` are the indices defining the current sublist we are looking at.

The function starts with the `low` at 0 and the `high` at the length of the list minus one and recursively adjusts these values based on whether the `target` value would be in the left or right half of the current sublist.

If the target value is found, the function returns its index. If after all recursive calls the value is not found, it returns `-1`.

This Python script is a direct implementation of binary search as described.