线性搜索是一种简单的搜索算法，其中对所有项目一个一个地进行顺序搜索。该算法通常使用迭代方法实现，但有时面试官会调整问题并要求递归实现算法。

在本文中，您将学习如何在c、Python、JavaScript和C中使用递归实现线性搜索算法。

问题陈述

给定一个未排序的数组和一个要在给定数组中搜索的元素。您需要编写一个递归函数，以便如果在给定数组中找到该元素，则返回该元素的索引，如果在该数组中找不到该元素，则返回-1。

示例1 :让arr=[1，2，3，4，5，6，7]和elementToBeSearched=4

四存在于索引3处的数组中。

因此，函数返回3,输出中显示"在索引3处找到的元素4"。

示例2 :让arr=[1，1，1，1，1]和elementToBeSearched=2

2不在数组中。

因此，函数返回-1,输出中显示"未找到元素2"。

解决问题的方法

将要搜索的元素与数组中最左侧索引和最右侧索引的元素进行比较。

如果找到该元素，则返回索引。

否则，通过增加左索引并减少右索引递归地搜索数组其余部分的元素。

递归调用该函数，直到右索引小于左索引。

相关：如何查找数组中所有元素的总和

使用递归实现线性搜索算法的C程序

下面是使用递归实现线性搜索算法的C程序：

//递归搜索数组中元素的C程序

#包含输入输出流

使用命名空间标准；

//递归搜索数组中元素的函数

int recursiveSearch(int arr[]，int left，int right，int elementToBeSearched)

{

如果(右向左)

{

返回-1;

}

if(arr[left]==要搜索的元素)

{

向左返回；

}

if(arr[right]==要搜索的元素)

{

返回右侧；

}

返回递归搜索(arr，左1,右1，元素被搜索

}

void printArrayElements(int arr[]，int size)

{

for(int I=0；isize(一)

{

我可以；

}

cout endl

}

int main()

{

int arr1[]={1，2，3，4，5，6，7 }；

int size1=sizeof(arr 1)/sizeof(arr 1[0])；

cout ' Array 1: ' endl

printrarayelements(arr 1，size 1)；

要搜索的int元素ed 1=4；

cout '要搜索的元素“:”元素搜索第1行；

int indexofelementit 1=recursiveSearch(arr 1，0，size1-1，element to SSE archive 1)；

if(indexofelementt1==-1)

{

cout“元素”要搜索的元素“ed 1”未找到“endl

}

其他

{

在索引" indexOfElement1 endl "处找到了cout“元素”要搜索的元素1；

}

int arr2[]={2，4，6，10，12，3，6 }；

int size2=sizeof(arr 2)/sizeof(arr 2[0])；

cout ' Array 2: ' endl

printrarayelements(arr 2，尺寸2)；

要搜索的int元素ed 2=4；

cout '要搜索的元素“:”元素搜索第二个端点；

int indexofelements 2=recursiveSearch(arr 2，0，size2-1，要搜索的元素ed 2)；

if(indexofelementt2==-1)

{

cout“元素”要搜索的元素“ed 2”未找到“endl

}

其他

{

在索引" indexOfElement2 endl "处找到了cout“元素”要搜索的元素ed 2；

}

int arr3[]={1，1，1，1，1 }；

int size3=sizeof(arr 3)/sizeof(arr 3[0])；

cout ' Array 3: ' endl

printrarayelements(arr 3，尺寸3)；

要搜索的int元素ed 3=2；

cout '要搜索的元素“:”元素搜索第3行；

int indexofelementt 3=recursiveSearch(arr 3，0，size3-1，要搜索的元素3)；

if(indexofelementt3==-1)

{

cout“元素”要搜索的元素“ed 3”未找到“endl

}

其他

{

在索引" indexOfElement3 endl "处找到了cout“元素”要搜索的元素3；

}

返回0;

}

输出：

数组1:

1 2 3 4 5 6 7

要搜索的元素： 4

在索引3处找到元素四

数组2:

2 4 6 10 12 3 6

要搜索的元素： 4

在索引一处找到元素四

数组3:

1 1 1 1 1

要搜索的元素： 2

找不到元素2

相关：归并排序算法简介

使用递归实现线性搜索算法的计算机编程语言程序

下面是使用递归实现线性搜索算法的计算机编程语言程序：

# Python程序递归搜索数组中的元素

#函数递归搜索数组中的元素

def recursiveSearch(arr，左，右，要搜索的元素):

如果右向左：

返回-1

if arr[left]==要搜索ed :的元素

向左返回

if arr[right]==element to search ed :

向右返回

返回递归搜索(arr，左1,右1，elementToBeSearched)

def printListElements(arr，size):

对于范围（尺寸)为：的我

打印(arr[i]，end=' ')

打印()

arr1=[1，2，3，4，5，6，7]

size1=len(arr1)

打印("阵列1:")

printListElements(arr1，size1)

要搜索的元素ed 1=4

打印('要搜索的元素： ',元素1)

indexofelementit 1=recursiveSearch(arr 1，0，size1-1，要搜索的元素ed 1)

if indexofelementt1==-1:

打印("元素“，元素搜索ed 1，”未找到")

else:

打印("元素“，元素搜索ed 1，”在索引处找到"，indexofelements 1)

arr2=[2，4，6，10，12，3，6]

size2=len(arr2)

打印('数组2: ')

printListElements(arr2，size2)

要搜索的元素ed 2=4

打印('要搜索的元素： ',要搜索的元素2)

indexofelements 2=recursiveSearch(arr 2，0，size2-1，要搜索的元素ed 2)

if indexofelementt2==-1:

打印("元素“，元素搜索ed 2，”未找到")

else:

打印("元素“，元素搜索ed 2，”在索引处找到"，indexofelements 2)

arr3=[1，1，1，1，1]

size3=len(arr3)

打印("阵列3:")

printListElements(arr3，size3)

要搜索的元素ed 3=2

打印('要搜索的元素： ',要搜索的元素3)

indexofelementt 3=recursiveSearch(arr 3，0，size3-1，要搜索的元素ed 3)

if indexofelementt3==-1:

打印("元素“，元素搜索ed 3，”未找到")

else:

打印("元素"，element to search ed 3，"在索引处找到"，indexofelements 3)

输出：

数组1:

1 2 3 4 5 6 7

要搜索的元素： 4

在索引3处找到元素四

数组2:

2 4 6 10 12 3 6

要搜索的元素： 4

在索引一处找到元素四

数组3:

1 1 1 1 1

要搜索的元素： 2

找不到元素2

相关：如何使用递归求自然数之和

使用递归实现线性搜索算法的Java脚本语言程序

下面是使用递归实现线性搜索算法的Java脚本语言程序：

//递归搜索数组中元素的Java Script语言程序

//递归搜索数组中元素的函数

函数递归搜索(arr，左，右，要搜索的元素){ 0

如果(右向左){ 0

返回-1;

}

if(arr[left]==要搜索的元素){ 0

向左返回；

}

if(arr[right]==要搜索的元素){ 0

返回右侧；

}

返回递归搜索(arr，左1,右1，元素被搜索

}

函数printrarayelements(arr，size){ 0

用于(设I=0；isizeI){ 0

文件。写作；

}

文件。write(' br ')；

}

var arr1=[1，2，3，4，5，6，7]；

变量大小1=arr 1。长度；

文件。写入(' Array 1: ' ' br ')；

printrarayelements(arr 1，size 1)；

要搜索的var元素ed 1=4；

document.write('要搜索的元素： '要搜索的元素ed 1 ' br ')；

var indexofelementit 1=recursiveSearch(arr 1，0，size1-1，element to be ssearch 1)；

if(indexofelementt1==-1){ 0

文件。写入(' Element '元素以搜索ed 1 '未找到' br ')；

} else {

文件。将(' Element '元素写入搜索的1 '在索引indexOfElement1 ' br '处找到);

}

var arr2=[2，4，6，10，12，3，6]；

变化大小2=arr 2。长度；

文件。写入(' Array 2: ' ' br ')；

printrarayelements(arr 2，尺寸2)；

要搜索的var元素ed 2=4；

document.write('要搜索的元素： '要搜索的元素ed 2 ' br ')；

var indexofelements 2=recursiveSearch(arr 2，0，size2-1，要搜索的元素ed 2)；

if(indexofelementt2==-1){ 0

文件。写入('元素'元素搜索ed 2 '未找到' br ')；

} else {

文件。写入('元素'元素搜索ed 2 '在索引indexOfElement2 ' br '处找到);

}

var arr3=[1，1，1，1，1]；

变化大小3=arr 3。长度；

文件。写入(' Array 3: ' ' br ')；

printrarayelements(arr 3，尺寸3)；

要搜索的var元素ed 3=2；

document.write('要搜索的元素： '要搜索的元素ed 3 ' br ')；

var indexofelementt 3=recursiveSearch(arr 3，0，size3-1，要搜索的元素3)；

if(indexofelementt3==-1){ 0

文件。写入('元素'元素搜索ed 3 '未找到' br ')；

} else {

文件。将('元素'元素写入搜索的3 '在索引indexOfElement3 ' br '处找到);

}

输出：

数组1:

1 2 3 4 5 6 7

要搜索的元素： 4

在索引3处找到元素四

数组2:

2 4 6 10 12 3 6

要搜索的元素： 4

在索引一处找到元素四

数组3:

1 1 1 1 1

要搜索的元素： 2

找不到元素2

相关：冒泡排序算法简介

使用递归实现线性搜索算法的C程序

下面是使用递归实现线性搜索算法的C程序：

//递归搜索数组中元素的C程序

#包含stdio.h

//递归搜索数组中元素的函数

int recursiveSearch(int arr[]，int left，int right，int elementToBeSearched)

{

如果(右向左)

{

返回-1;

}

if(arr[left]==要搜索的元素)

{

向左返回；

}

if(arr[right]==要搜索的元素)

{

返回右侧；

}

返回递归搜索(arr，左1,右1，元素被搜索

}

void printArrayElements(int arr[]，int size)

{

for(int I=0；isize(一)

{

printf('%d '，arr[I])；

}

printf('n')；

}

int main()

{

int arr1[]={1，2，3，4，5，6，7 }；

int size1=sizeof(arr 1)/sizeof(arr 1[0])；

printf('数组1: n')；

printrarayelements(arr 1，size 1)；

要搜索的int元素ed 1=4；

printf('要搜索的元素： %d n',element搜索ed 1)；

int indexofelementit 1=recursiveSearch(arr 1，0，size1-1，element to SSE archive 1)；

if(indexofelementt1==-1)

{

printf('在n'找不到元素%d，要搜索的元素ed 1)；

}

其他

{

printf('在索引%d处找到元素%d n',element搜索ed 1，indexofelementit 1)；

}

int arr2[]={2，4，6，10，12，3，6 }；

int size2=sizeof(arr 2)/sizeof(arr 2[0])；

printf('数组2: n')；

printrarayelements(arr 2，尺寸2)；

要搜索的int元素ed 2=4；

printf('待搜索元素：% n'，元素待搜索2);

int indexofelements 2=recursiveSearch(arr 2，0，size2-1，要搜索的元素ed 2)；

if(indexofelementt2==-1)

{

printf('在n'找不到元素%d，要搜索的元素ed 2)；

}

其他

{

printf('在索引%d处找到元素%d n',element搜索ed 2，indexofelements 2)；

}

int arr3[]={1，1，1，1，1 }；

int size3=sizeof(arr 3)/sizeof(arr 3[0])；

printf('数组3: n')；

printrarayelements(arr 3，尺寸3)；

要搜索的int元素ed 3=2；

printf('待搜索元素：% n'，元素待搜索3);

int indexofelementt 3=recursiveSearch(arr 3，0，size3-1，要搜索的元素3)；

if(indexofelementt3==-1)

{

printf('在n'找不到元素%d，要搜索的元素ed ^ 3)；

}

其他

{

printf('在索引%d处找到元素%d n',element搜索ed 3，indexofelementt 3)；

}

返回0;

}

输出：

数组1:

1 2 3 4 5 6 7

要搜索的元素： 4

在索引3处找到元素四

数组2:

2 4 6 10 12 3 6

要搜索的元素： 4

在索引一处找到元素四

数组3:

1 1 1 1 1

要搜索的元素： 2

找不到元素2

学习递归

递归是一个非常重要和有趣的编程主题。递归用于解决可以分解为更小的重复问题的问题。对于初学者来说，学习可能有点困难，但是学习如何使用递归解决问题是值得的。