Programme Python pour rechercher des éléments dans un tableau

En Python, il existe principalement deux algorithmes de recherche qui sont principalement utilisés. Parmi ceux-ci, le premier est la recherche linéaire et le second est la recherche binaire.

Ces deux techniques sont principalement utilisées pour rechercher un élément dans le tableau donné ou également dans la liste donnée. Lors de la recherche d’un élément, deux méthodologies peuvent être suivies dans tout type d’algorithme. L’une d’elles est l’approche récursive et l’autre est l’approche itérative. Discutons des deux algorithmes dans les deux approches et résolvons des problèmes similaires.

Recherche linéaire

La technique de recherche linéaire est également connue sous le nom de recherche séquentielle. La signification du nom « Recherche séquentielle » est définitivement justifiée par le processus suivi par cet algorithme de recherche. C'est une méthode ou une technique utilisée pour trouver les éléments dans un tableau ou une liste en Python.

它被认为是所有其他搜索算法中最简单和最容易的。但是，这个算法的唯一缺点是效率不高。这就是为什么不经常使用线性搜索的主要原因。

算法

• Étape 1 - Il recherche un élément dans un ordre séquentiel simplement en comparant l'élément souhaité avec chaque élément présent dans le tableau donné.

• 步骤 2 − 如果找到所需的元素，则会将元素的索引或位置显示给用户。

• Étape 3 - Si l'élément n'est pas présent dans le tableau, l'utilisateur sera informé que l'élément n'est pas trouvé. De cette façon, l'algorithme est traité.

En général, l'algorithme de recherche linéaire est comparativement adapté et efficace pour les petits tableaux ou les petites listes d'une taille inférieure ou égale à 100 car il vérifie et compare avec chaque élément.

• 如果所需元素位于数组的最后位置，将会消耗更多时间。

"O( 1 )"。在这种情况下，元素将位于数组的第一个位置，即索引为« 0 »。
La complexité temporelle de l'algorithme de recherche linéaire dans le cas moyen est « O( n ) ». Dans ce cas, l'élément sera présent en position médiane du tableau, c'est-à-dire avec l'index « ( n – 1 ) / 2 » ou « (( n – 1 ) / 2 )+ 1 ».
La complexité temporelle de l'algorithme de recherche linéaire dans le pire des cas est « O( n ) ». Dans ce cas, l'élément sera présent en dernière position du tableau, c'est-à-dire avec l'indice « n-1 ».
Exemple

在下面的示例中，我们将学习使用线性搜索在数组中查找元素的过程。

def iterative_linear( arr, n, key_element):
   for x in range(n):
      if(arr[x] == key_element):
         return x
   return -1
arr = [2, 3, 5, 7, 9, 1, 4, 6, 8, 10]
max_size = len(arr)
key = 8
result = iterative_linear(arr, max_size - 1, key)
if result != -1:
   print ("The element", key," is found at the index " ,(result), "and in the ", (result+1), "position")
else:
   print ("The element %d is not present in the given array" %(key))

Sortie

上述程序的输出如下：

The element 8  is found at the index  8 and in the  9 position

Exemple (récursif)

在下面的例子中，我们将学习使用递归方法在数组中进行线性搜索的过程。

def recursive_linear( arr, first_index, last_index, key_element):
   if last_index < first_index:
      return -1
   if arr[first_index] == key_element:
      return first_index
   if arr[last_index] == key_element:
      return last_index  
   return recursive_linear(arr, first_index + 1, last_index - 1, key_element)

arr = [2, 3, 5, 7, 9, 1, 4, 6, 8, 10]
max_size = len(arr)
key = 8
result = recursive_linear(arr, 0, max_size - 1, key)
if result != -1:
   print ("The element", key," is found at the index " ,(result), "and in the ", (result+1), "position")
else:
   print ("The element %d is not present in the given array" %(key))

Sortie

上述程序的输出如下：

The element 8  is found at the index  8 and in the  9 position

Recherche binaire

..常只考虑有序数组。

如果数组在某些情况下没有排序，则对数组进行排序，然后开始二分搜索算法的过程。一旦数组被二分搜索算法考虑，它首先被排序，然后算法被应用于数组。

算法

步骤 1
• − 对数组进行排序是第一步。

Étape 2
• - Une fois le tableau trié, le tableau est considéré comme deux moitiés. Une moitié commence du premier élément à l'élément du milieu du tableau trié et la seconde moitié commence de l'élément après l'élément du milieu jusqu'au dernier élément du tableau trié.

Étape 3
• - L'élément clé (l'élément censé être recherché est appelé élément clé) est comparé à l'élément central du tableau trié.

Étape 4
• - Si l'élément clé est inférieur ou égal à l'élément du milieu du tableau trié, les éléments de la seconde moitié sont davantage ignorés car l'élément clé est plus petit que l'élément du milieu. Donc, définitivement, l'élément doit être présent entre le premier élément et l'élément du milieu.

Étape 6
• - Si l'élément clé est supérieur à l'élément du milieu, alors la première moitié du tableau trié est ignorée et les éléments de l'élément du milieu au dernier élément sont pris en compte.

Étape 7
• - Parmi ces éléments, l'élément clé est à nouveau comparé à l'élément central du tableau réduit de moitié et répète la même procédure. Si l'élément clé est supérieur à l'élément central du tableau divisé par deux, alors la première moitié est négligée.

• 第8步 - 如果关键元素小于或等于被分割数组的中间元素，则被分割数组的后半部分将被忽略。通过这种方式，元素将在数组的任意一半中进行搜索。

因此，与线性搜索相比，复杂度减少了一半或更多，因为有一半的元素将在第一步中被移除或不被考虑。二分搜索的最佳情况时间复杂度为“O(1)”。二分搜索的最坏情况时间复杂度为“O(logn)”。这就是二分搜索算法的工作原理。让我们考虑一个例子，并应用二分搜索算法来找出数组中的关键元素。

Example

In this example, we are going to learn about the process of searching an element in an array using Binary search in recursive approach.

def recursive_binary(arr, first, last, key_element):
   if first <= last:
      mid = (first + last) // 2 
   if arr[mid] == key_element:
      return mid
   elif arr[mid] > key_element:
      return recursive_binary(arr, first, mid - 1, key_element)
   elif arr[mid] < key_element:  
      return recursive_binary(arr, mid + 1, last, key_element)  
   else:  
      return -1 

arr = [20, 40, 60, 80, 100] 
key = 80 
max_size = len(arr)
result = recursive_binary(arr, 0, max_size - 1, key)  
if result != -1:  
   print("The element", key, "is present at index", (result), "in the position", (result + 1)) 
else:  
   print("The element is not present in the array") 

Output

上述程序的输出如下：

The element 80  is found at the index 3 and in the position 4

Example

In this example, we are going to learn about the process of searching an element in an array using Binary search in iterative approach.

def iterative_binary(arr, last, key_element):
   first = 0
   mid = 0
   while first <= last: 

      mid = (first + last) // 2 
      if arr[mid] < key_element:
         first = mid + 1 

      elif arr[mid] > key_element: 
         last = mid - 1 

      else: 
         return mid 

   return -1 

arr = [20, 40, 60, 80, 100] 
key = 80 
max_size = len(arr)

result = iterative_binary(arr, max_size - 1, key)  

if result != -1:  
   print("The element", key, "is present at index", (result), "in the position", (result + 1)) 
else:  
   print("The element is not present in the array")

Output

上述程序的输出如下：

The element 80  is found at the index 3 and in the position 4

这是二分搜索算法的工作原理。根据时间复杂度的概念，我们可以肯定二分搜索算法比线性搜索算法更高效，时间复杂度在其中起着重要的作用。通过使用这种类型的算法，可以搜索数组中的元素。尽管用于解决问题的过程不同，但结果不会波动。这是使用多种算法检查输出一致性的一个优点。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!