Program Python untuk mencari elemen dalam tatasusunan

Dalam Python, terdapat terutamanya dua algoritma carian yang digunakan secara meluas. Daripada itu, yang pertama ialah Carian Linear dan yang kedua ialah Carian Binari.

Kedua-dua teknik ini digunakan terutamanya untuk mencari elemen dari tatasusunan yang diberikan atau dari senarai yang diberikan juga. Semasa mencari elemen, terdapat dua metodologi yang boleh diikuti dalam sebarang jenis algoritma. Salah satunya ialah pendekatan rekursif dan satu lagi pendekatan berulang. Mari kita bincangkan kedua-dua algoritma dalam kedua-dua pendekatan dan selesaikan masalah yang serupa.

Carian Linear

Teknik Linear Search juga dikenali sebagai Sequential search. Maksud nama " Carian berurutan " pasti dibenarkan oleh proses yang diikuti oleh algoritma carian ini. Ia ialah kaedah atau teknik yang digunakan untuk mencari elemen dalam tatasusunan atau senarai dalam Python.

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

算法

• Langkah 1 − Ia mencari elemen dalam susunan berurutan hanya dengan membandingkan elemen yang dikehendaki dengan setiap elemen yang terdapat dalam tatasusunan yang diberikan.

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

• Langkah 3

  − Jika elemen tidak hadir dalam tatasusunan, maka pengguna akan dimaklumkan bahawa elemen itu tidak ditemui. Dengan cara ini, algoritma diproses.

Secara amnya, algoritma carian Linear secara perbandingan sesuai dan cekap untuk tatasusunan kecil atau senarai kecil yang mempunyai saiz kurang daripada atau sama dengan 100 kerana ia menyemak dan membandingkan dengan setiap elemen.

如果所需元素位于数组的最后位置，将会消耗更多时间。
线性搜索算法在最佳情况下的时间复杂度为“ O( 1 ) ”。在这种情况下，尀不素下，広不素下，庆不素为“位置，即索引为“ 0 ”。
Kerumitan Masa algoritma Carian Linear dalam kes purata ialah “ O( n ) ”. Dalam kes ini, elemen akan hadir di kedudukan tengah tatasusunan, iaitu, dengan indeks “ ( n – 1 ) / 2 ” atau “ (( n – 1 ) / 2 )+ 1 ”.
Kerumitan Masa algoritma Carian Linear dalam kes terburuk ialah “ O( n ) ”. Dalam kes ini, elemen akan hadir dalam kedudukan terakhir tatasusunan, iaitu, dengan indeks “ n-1 ”.
Contoh

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

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))

Output

上述程序的输出如下：

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

Contoh (Rekursif)

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

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))

Output

上述程序的输出如下：

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

Carian Binari

二分查找算法与线性查找算法相当不同。它遵循完全不同的过程来搜索索数。只考虑有序数组。

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

算法

• 步骤 1

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

• Langkah 2

  − Selepas tatasusunan diisih, tatasusunan dianggap sebagai dua bahagian. Satu separuh bermula dari elemen pertama hingga elemen tengah tatasusunan yang diisih dan separuh kedua bermula dari elemen selepas elemen tengah hingga elemen terakhir tatasusunan yang diisih.

• Langkah 3

  − Elemen utama (elemen yang sepatutnya dicari dikenali sebagai elemen utama) dibandingkan dengan elemen tengah tatasusunan yang diisih.

• Langkah 4

  − Jika elemen kunci kurang daripada atau sama dengan elemen tengah tatasusunan yang diisih, elemen separuh kedua diabaikan lagi kerana elemen kunci lebih kecil daripada elemen tengah. Jadi, pastinya, elemen itu mesti ada di antara elemen pertama dan elemen tengah.

• Langkah 6

  − Jika elemen utama lebih besar daripada elemen tengah, maka separuh pertama tatasusunan yang diisih diabaikan dan elemen dari elemen tengah hingga elemen terakhir dipertimbangkan.

• Langkah 7

  − Daripada elemen tersebut, elemen utama sekali lagi dibandingkan dengan elemen tengah tatasusunan separuh dan mengulangi prosedur yang sama. Jika elemen utama lebih besar daripada elemen tengah tatasusunan separuh, maka separuh pertama diabaikan.

• 第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

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

Atas ialah kandungan terperinci Program Python untuk mencari elemen dalam tatasusunan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!