数据结构中的迭代是什么？

2024年8月28日 | 阅读 22 分钟

迭代是指**连续重复一定数量的步骤**，直到满足某个特定条件为止。迭代的次数可以是有限的，也可以是无限的。这完全取决于我们执行迭代的程序。

迭代在执行相同指令和重复相同的代码行方面起着非常重要的作用。有时，迭代是没有价值的，当条件陷入无限循环时，会产生死锁。

在操作系统中，我们读到过“临界区”这个术语，其中有多个进程想要访问临界区。但是，根据临界区的规则，一次只能有一个进程访问它，而其他进程必须等待。
因此，为了解决临界区的问题，我们将使用信号量。根据某些条件，如果信号量的值为 1，则进程可以进入临界区并立即将信号量减为 0，这样在当前进程位于临界区时，另一个进程就无法进入临界区。
如果进程到来时看到信号量的值为 0，那么它最终会陷入无限循环，在这种情况下，无限迭代就可以解决问题并证明是有益的。
现在，让我们通过一些其他例子来更详细地理解它。例如，如果我们想打印 10 次“hello”语句，我们可以有两种方法。
一种方法是直接键入 print 语句，逐个打印 10 次 hello。
但是上述情况最终会浪费时间，并会不必要地增加内存空间和代码行数。如果我们必须打印 10,000 次，我们甚至都不会尝试这种方法，因为它不能使代码高效。
第二种方法是运行一个循环，将 hello 语句迭代 10 次，从而节省我们的时间，减少不必要的代码行，并使代码比前一种方法更高效。我们将选择第二种方法，并走向高效方法。
所以，想一想迭代在高效运行任何程序和节省程序员时间方面有多么重要。

打印 "Hello world" 10 次的程序

/* Program to print the  " Hello world " 10 times in C language without using iterations */
#include<stdio.h>
void main ( )
{
	printf ( " Hello, world ! \n " ) ;
	printf ( " Hello, world ! \n " ) ;
	printf ( " Hello, world ! \n " ) ;
	printf ( " Hello, world ! \n " ) ;
	printf ( " Hello, world ! \n " ) ;
	printf ( " Hello, world ! \n " ) ;
	printf ( " Hello, world ! \n " ) ;	
	printf ( " Hello, world ! \n " ) ;
	printf ( " Hello, world ! \n " ) ;
	printf ( " Hello, world ! \n " ) ;
}

上述程序的输出

Hello, world!
  Hello, world! 
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!

/* Program to print the  " Hello world " 10 times in C language with using iterations */
#include<stdio.h>
void main ( )
{
	int i ;
	for ( i = 1 ; i <= 10 ; i++ )
	{
	printf ( " Hello, world ! \n " ) ;
    }
}

上述程序的输出

Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!
  Hello, world!

当我们分析上述案例时，我们很容易就能了解迭代在程序中的重要性，以及它如何减少编码员的额外工作。它最终节省了时间，并使代码更高效、更易读。

在程序中执行迭代的方法

在任何程序中执行迭代的各种方法如下：

1. 使用程序中的各种循环

使用 For 循环
使用 while 循环
使用 do-while 循环

2. 使用递归

让我们结合示例，逐一详细讨论这些方法。这里我们参考 C 和 C++ 语言。

在程序中使用各种类型的循环执行迭代

1. 使用程序中的各种循环

1. 使用 For 循环

在 C 和 C++ 语言中实现 for 循环非常简单，其基本语法如下：

for ( Expression 1; Expression 2; Expression 3 )
{
Statement 1 ;
Statement 2 ;
.
.
.
Statement n ;
}

在 expression 1 中，我们将在此处初始化变量，并且可以进行多个初始化。

在 expression 2 中，我们将编写条件表达式，循环将在此处运行。

在 expression 3 中，我们将根据条件和程序员的需求执行增量和减量操作。

实现 'for' 循环的特定过程。首先，expression 1，即变量初始化，将运行，变量将根据 for 循环中提到的语句进行初始化。初始化后，将执行 expression 2，即进行条件检查，如果满足条件，则指针将直接跳转到循环内部并执行循环内部提到的语句数量，执行语句后，指针将跳转到 expression 3 并对变量执行**增量**或**减量**操作，然后它将跳转到 expression 2 并再次检查条件，如果为真。指针将移出块。它将跳转到循环内部并执行循环内部提到的语句数量，然后指针再次移动到 expression 3，对变量执行增量或减量操作。之后，它将检查条件……整个过程将重复，直到条件变为假。

在 for 循环的工作中，我们可以观察到 expression 1，即变量初始化，只在开始时执行一次，之后指针将永远不会跳转到初始化部分。它将在 expression 2 和 expression 3 以及循环内部围绕，直到条件变为假。

让我们结合示例来理解 for 循环的工作原理。

/* Program to print the  value of any variable participating in the loop in C language with using for loop iterations */
#include< stdio.h>
void main ( )
{
	int i ;
	for ( i = 1 ; i <= 10 ; i++ )
	{
	printf ( " Value of i is: %d \n ", i  ) ;
    }
}

上述程序的输出

  Value of i is: 1
  Value of i is: 2
  Value of i is: 3
  Value of i is: 4
  Value of i is: 5
  Value of i is: 6
  Value of i is: 7
  Value of i is: 8
  Value of i is: 9
  Value of i is: 10

/* Program to print the Fibonacci series for n terms  in C language with using for loop iterations */
#include<stdio.h> 
#include<time.h>
int fib ( int n )
{
	int f [ n + 1 ] ;
	int i ;
	f [ 0 ] = 0 ;
	f [ 1 ] = 1 ;
	for ( i = 2 ; i <= n ; i++ )
	{
		f [ i ] = f [ i - 1 ] + f [ i - 2 ] ;
	}
	return f [ n ] ;
}
void main()
{
	double time_spent = 0.0 ;
	int i , n ;
	printf ( " Enter terms of fibonacci series \n " ) ;
	scanf ( "%d" , &n ) ;
	clock_t begin = clock() ;
	printf ( " Fibonacci series is : \n " ) ;
	for ( i = 0 ; i < n ; i++ )
	{
		printf ( " %d " , fib ( i ) ) ;
    }
    clock_t end = clock() ;
	time_spent = time_spent + ( double ) ( end - begin ) / CLOCKS_PER_SEC ;
	printf ( " \n %f secs " , time_spent ) ;
}

上述程序的输出

Enter terms of fibonacci series
 20
 Fibonacci series is :
  0  1  1  2  3  5  8  13  21  34  55  89  144  233  377  610  987  1597  2584  4181
 0.000000 secs

2. 使用 While 循环

在 C/C++ 语言中 while 循环的工作原理与 C/C++ 语言中 for 循环的工作原理相同。while 循环的语法与 for 循环有很大不同，语法如下：

Expression 1 ;
while( Expression 2 )
{
Stetement 1 ;
Statement 2 ;
Statement 3 ;
.
.
.
Statement n ;
Expression 3 ;
}

在 expression 1 中，我们将在此处初始化变量，并且可以进行多个初始化。

在 expression 2 中，我们将编写条件表达式，循环将在此处运行。

在 expression 3 中，我们将根据条件和程序员的需求执行增量和减量操作。

实现 while 循环的特定过程。首先，expression 1，即变量初始化，将运行，变量将根据 while 循环中提到的语句进行初始化。初始化后，将执行 expression 2，即进行条件检查，如果满足条件，则指针将直接跳转到循环内部并执行循环内部提到的语句数量，执行语句后，指针将跳转到 expression 3 并对变量执行增量或减量操作。它将跳转到 expression 2 并再次检查条件，如果为真。指针将移出块。它将跳转到循环内部并执行循环内部提到的语句数量，然后指针再次移动到 expression 3，对变量执行增量或减量操作。之后，它将检查条件……整个过程将重复，直到条件变为假。

正如我们所观察到的，for 循环和 while 循环的工作过程是相同的；在 for 循环中，初始化语句仅执行一次，同样，在此 while 循环中，初始化语句在进入 while 循环块之前执行一次。

让我们结合示例来理解它。

/* Program to print the  value of any variable participating in the loop in C language with using while loop iterations */
#include<stdio.h>
void main ( )
{
	int i = 1 ;
	while ( i <= 10 )
	{
	printf ( " Value of i is: %d \n ", i ) ;
	i = i + 1 ;
    }
}

上述程序的输出

  Value of i is: 1
  Value of i is: 2
  Value of i is: 3
  Value of i is: 4
  Value of i is: 5
  Value of i is: 6
  Value of i is: 7
  Value of i is: 8
  Value of i is: 9
  Value of i is: 10

/* Program to print the Fibonacci series for n terms in C language with using while loop iterations */
#include<stdio.h> 
#include<time.h>
int fib ( int n )
{
	int f [ n + 1 ] ;
	int i = 2 ;
	f [ 0 ] = 0 ;
	f [ 1 ] = 1 ;
	while ( i <= n )
	{
		f [ i ] = f [ i - 1 ] + f [ i - 2 ] ;
		i = i + 1 ;
	}
	return f [ n ] ;
}
void main()
{
	double time_spent = 0.0 ;
	int i = 0 , n ;
	printf ( " Enter terms of fibonacci series \n " ) ;
	scanf ( "%d" , &n ) ;
	clock_t begin = clock() ;
	printf ( " Fibonacci series is : \n " ) ;
	while ( i < n )
	{
		printf ( " %d " , fib ( i ) ) ;
		i = i + 1 ;
    }
    clock_t end = clock() ;
	time_spent = time_spent + ( double ) ( end - begin ) / CLOCKS_PER_SEC ;
	printf ( " \n %f secs " , time_spent ) ;
}

上述程序的输出

Enter terms of fibonacci series
 20
 Fibonacci series is :
  0  1  1  2  3  5  8  13  21  34  55  89  144  233  377  610  987  1597  2584  4181
 0.000000 secs

3. 使用 do-while 循环

使用 do-while 循环的过程与我们在 for 循环和 while 循环中遵循的过程不同。正如我们已经看到 while 循环和 for 循环的工作原理一样，在这两个循环中，我们首先初始化变量的值，检查条件，然后进入循环块。但是在这里的 do-while 循环中，过程与上述两种过程完全不同；在这个循环中，我们将首先初始化变量的值，然后我们将直接进入循环而无需检查任何条件，执行 do-while 块中提到的语句数量。我们将根据条件通过增量或减量来更新变量的值，然后最终我们将检查条件。

do-while 循环的语法如下：

Expression 1 ;
do
{
Stetement 1 ;
Statement 2 ;
Statement 3 ;
.
.
.
Statement n ;
Expression 2 ;
} while ( Expression 3 ) ;

在 expression 1 中，我们将在此处初始化变量，并且可以进行多个初始化。

在 expression 2 中，我们将根据条件和程序员的需求执行增量和减量操作。

在 expression 3 中，我们将编写条件表达式，循环将在此处运行。

do-while 循环的实现过程如下：首先 expression 1，即变量初始化，将运行，变量将根据 do-while 循环中提到的语句进行初始化。初始化后，指针将直接跳转到循环内部并执行循环内部提到的语句数量；执行语句后，指针将跳转到 expression 2，即指针将对变量执行增量或减量操作，之后它将跳转到 expression 3，即检查根据程序员需求提到的条件，一旦条件满足，指针将再次重复相同的过程，直接跳转到循环内部并执行循环内部提到的语句数量。指针再次移动到 expression 2，对变量执行增量或减量操作，然后检查条件……整个过程将重复，直到条件变为假。指针将移出块。

让我们结合示例来理解它。

/* Program to print the  value of any variable participating in the loop in C language with using do-while loop iterations */
#include<stdio.h>
void main ( )
{
	int i = 1 ;
	do
	{
	printf ( " Value of i is: %d \n ", i ) ;
	i = i + 1 ;
    } while ( i <= 10) ;
}

上述程序的输出

  Value of i is: 1
  Value of i is: 2
  Value of i is: 3
  Value of i is: 4
  Value of i is: 5
  Value of i is: 6
  Value of i is: 7
  Value of i is: 8
  Value of i is: 9
  Value of i is: 10

/* Program to print the Fibonacci series for n terms  in C language with using do while loop iterations */
#include<stdio.h> 
#include<time.h>
int fib ( int n )
{
	int f [ n + 1 ] ;
	int i = 2 ;
	f [ 0 ] = 0 ;
	f [ 1 ] = 1 ;
	do
	{
		f [ i ] = f [ i - 1 ] + f [ i - 2 ] ;
		i = i + 1 ;
	} while ( i <= n ) ;
	return f [ n ] ;
}
void main()
{
	double time_spent = 0.0 ;
	int i = 0 , n ;
	printf ( " Enter terms of fibonacci series \n " ) ;
	scanf ( "%d" , &n ) ;
	clock_t begin = clock() ;
	printf ( " Fibonacci series is : \n " ) ;
	do
	{
		printf ( " %d " , fib ( i ) ) ;
		i = i + 1 ;
    } while ( i < n ) ;
    clock_t end = clock() ;
	time_spent = time_spent + ( double ) ( end - begin ) / CLOCKS_PER_SEC ;
	printf ( " \n %f secs " , time_spent ) ;
}

上述程序的输出

Enter terms of fibonacci series
 20
 Fibonacci series is :
  0  1  1  2  3  5  8  13  21  34  55  89  144  233  377  610  987  1597  2584  4181
 0.000000 secs

ii. 使用递归

迭代可以使用递归轻松执行，而递归这个词本身并没有什么特别之处。它只是指一个函数反复调用自身，直到遇到假语句为止。递归函数不一定总是从 main 函数调用，它也可以从其他函数调用，并且在调用递归函数时可以看到各种变化。有时，当函数调用自身陷入无限循环（因为没有条件成功满足，它无法停止调用自身）时，这种递归也称为无限递归。

我们没有递归的特定语法，但下面提到了递归发生的一些情况。

情况 1：当我们通过单级递归调用从 main 函数调用任何函数时

void Fun ( int x , int y , int z ) ;  // Function declaration 
void main ( )
{
int i , a , b ;
Statement 1 ;
Statement 2 ;
.
.
Statement 3 ;
Fun ( i , a , b ) ;  // Function calling
Statement 4 ;
Statement 5 ;
.
.
Statement n ;
} 
void Fun ( int x, int y, int z )
{
If ( Expression 1 )
{
Statement 1 ;
Statement 2 ;
.
.
Statement n ;
}
else
{
return Fun ( x , y ,z ) ;
}
} 

在上述情况下，如果我们观察到我们有 main 函数，并且在 main 函数体之前，函数 Fun 已被声明，这样它就不会产生任何错误。从 main 函数，我们通过传递实际参数调用了 Fun 函数；函数调用后将直接移动到 Fun 函数并开始执行 Fun 的主体，在 Fun 函数中，我们有形式参数，在 Fun 函数的主体中作为临时有效值。在 Fun 函数中，如果我们注意到我们有一些 if 条件，并且在 if 条件中，我们有一些语句需要逐一执行，如果条件被证明为真。一旦条件变为真，Fun 将停止调用自身；否则，它将移向另一个条件并开始调用自身，直到遇到假条件并打破迭代。一旦 Fun 停止调用自身，指针将移入 main 函数并开始执行 main 函数之后的代码，直到执行完整个 main 函数。

情况 2：当我们通过多级递归调用从 main 函数调用任何函数时

void Fun1 ( int x , int y , int z ) ;  // Function declaration 
void Fun2 ( int a , int b ) ;  // Function declaration 
void main ( )
{
int i , a , b ;
Statement 1 ;
Statement 2 ;
.
.
Statement 3 ;
Fun1 ( i , a , b ) ;  // Function calling
Statement 4 ;
Statement 5 ;
.
.
Statement n ;
} 
void Fun1 ( int x, int y, int z )
{
If ( Expression 1 )
{
Statement 1 ;
Statement 2 ;
.
Fun2 ( i , j ) ;
Statement n ;
}
else
{
return Fun1 ( x , y ,z ) ;
}
} 
void Fun2 ( int a, int b )
{
If ( Expression 1 )
{
Statement 1 ;
Statement 2 ;
.
.
Statement n ;
}
else
{
return Fun2 ( a , b ) ;
}
} 

在上述情况下，如果我们观察到我们有 main 函数，并且在 main 函数体之前，函数 **Fun1** 和 **Fun2** 已被声明，这样它就不会产生任何错误。从 main 函数，我们通过传递实际参数调用了 Fun1 函数；函数调用后将直接移动到 Fun1 函数并开始执行 Fun1 的主体，在 Fun1 函数中，我们有形式参数，在 Fun1 函数的主体中作为临时有效值。在 Fun1 函数中，如果我们注意到我们有一些 if 条件，并且在 if 条件中，我们有一些语句需要逐一执行，如果条件被证明为真。在语句数量之间，我们有一些 Fun2 函数的调用；调用 Fun2 函数后，指针将直接跳转到 Fun2 函数的主体。在 Fun2 函数中，我们有相同的过程，有一个 if 条件和 else 部分；如果 if 条件为真，那么它将停止调用自身；否则，它将反复调用自身，直到条件变为假。一旦条件为假，指针将回到它离开的位置，并在 Fun1 函数中执行剩余的语句。一旦条件为真，Fun1 将停止调用自身；否则，它将移向另一个条件并开始调用自身，直到条件变为假。一旦 Fun1 停止调用自身，指针将移入 main 函数并开始执行其后的 main 函数，直到执行完整个 main 函数。

从以上两种情况，我们分析了递归函数的工作原理以及递归过程是如何在后台执行的。它们都通过**堆栈**来执行；当前调用逐一推入堆栈，如果执行完成则从堆栈中弹出。弹出是基于**LIFO 原理**进行的；最近调用的函数将首先执行并首先被弹出；同样，在此，整个过程都会进行。main 函数首先被推入堆栈，最后，它将从堆栈中弹出，这意味着程序成功完成。

情况 3：当我们通过单级递归调用从其他函数调用任何函数时

void Fun ( int x , int y , int z ) ;  // Function declaration 
void New ( int a , int b ) ; // Function declaration
void main ( )
{
int i , a , b ;
Statement 1 ;
Statement 2 ;
.
.
Statement 3 ;
Fun ( i , a , b ) ;  // Function calling
Statement 4 ;
Statement 5 ;
.
.
Statement n ;
} 
void Fun ( int x, int y, int z )
{
New ( x , y ) ; // Function calling
} 
void New ( int x, int y )
{
If ( Expression 1 )
{
Statement 1 ;
Statement 2 ;
.
.
Statement n ;
}
else
{
return New ( x, y ) ;
}
}

在上述情况下，如果我们观察到我们有 main 函数，并且在 main 函数体之前，函数 Fun 已被声明，这样它就不会产生任何错误。从 main 函数，我们通过传递实际参数调用了 Fun 函数；函数调用后将直接移动到 Fun 函数并开始执行 Fun 的主体，在 Fun 函数中，我们有形式参数，在 Fun 函数的主体中作为临时有效值。当我们进入 Fun 函数时，我们将调用 New 函数，然后指针将跳转到 New 函数的主体。在 New 函数中，如果我们注意到我们有一些 if 条件，并且在 if 条件中，我们有一些语句需要逐一执行，如果条件被证明为真。一旦条件变为真，New 将停止调用自身；否则，它将移向另一个条件并开始调用自身，直到遇到假条件并打破迭代。一旦 New 停止调用自身，指针将移入 Fun 函数，然后在其完成后，指针将指向 main 函数的主体并开始执行其后的 main 函数，直到执行完整个 main 函数。函数调用的回溯是在调用函数时实现的。

让我们结合示例来理解它。

/* Program to print the value of any variable participating in the loop in C language using recursive iterations */
#include<stdio.h>
void recursion ( int i )
{
	if ( i <= 10)
	{
		printf ( "Value of i  is: %d \n " , i ) ;
		return recursion ( i = i + 1 ) ;
		
	}
}
void main ( )
{
	int i = 1 ;
	recursion ( i ) ;
}

上述程序的输出

  Value of i is: 1
  Value of i is: 2
  Value of i is: 3
  Value of i is: 4
  Value of i is: 5
  Value of i is: 6
  Value of i is: 7
  Value of i is: 8
  Value of i is: 9
  Value of i is: 10

/* Program to print the Fibonacci series for n terms  in C language with using recursive iterations */


#include<stdio.h>
#include<time.h>

int fib ( int n )                        // This function will return the fibonacci value for corresponding n values
{
	if ( n <= 1 )
	{
		return 0 ;
	}
	if ( n == 2 )
	{
		return 1 ;
	}
	else
	{
	    return fib ( n - 1 ) + fib ( n - 2 ) ;
	    
	}
}
void main()
{
	double time_spent = 0.0 ;

	int i , n ;
	printf ( "Enter terms of fibonacci series \n " ) ;
	scanf ( "%d" , &n ) ;
	printf ( "Fibonacci series is : \n " ) ;
    clock_t begin = clock ( ) ;
	for ( i = 1 ; i <= n ; i++ )
	{
	
		printf ("%d  " , fib ( i ) ) ;
    }
    clock_t end = clock ( ) ;
	time_spent = time_spent + ( double ) ( end - begin ) / CLOCKS_PER_SEC ;
	printf ( " \n %f secs " , time_spent ) ;
}

上述程序的输出

Enter terms of fibonacci series
 20
 Fibonacci series is :
  0  1  1  2  3  5  8  13  21  34  55  89  144  233  377  610  987  1597  2584  4181

/* Program to perform the recursive linear search in C language with using recursion */
#include<stdio.h>
int RLS ( int A [ ] , int n , int index , int key ) /* Recursive linear search function, which calls itself recursively until the key is searched, or when it will check the whole array and key was not able to found */
{
	if ( index >= n )
	{
		return -1 ;
	}
	if ( A [ index ] == key )
	{
		return index ;
	}
	else
	{
		return RLS ( A , n , index + 1 , key ) ; // Calling recursive linear search function from same function

	}
}
void main()
{
	int A [ 30 ] ;
	int key , n , i , index , x ;
	index = 0 ;
	printf ( " Enter the size of an array : " ) ;
	scanf ( "%d" , &n ) ;
	printf ( "Enter Array \n " ) ;
	for ( i = 0 ; i < n ; i++ )
	{
		scanf ( "%d" , &A [ i ] ) ;
	}
	printf ( " Enter value to search : " ) ;
	scanf("%d" , &key ) ;
	x = RLS ( A , n , index , key ) ; // Calling recursive linear search function from main function

	if ( x != -1 )
	{ 
		printf ( " Value present at index : %d " , x ) ;
	}
	else
	{
		printf ( " Value not found ! \n ") ;
	}
}

上述程序的输出

Enter the size of an array: 10
Enter Array
 12
13
15
8
7
9
6
11
10
4
 Enter the value to search: 7
 Value present at index: 4

/* Program to perform the recursive binary search in C language with using recursion */
#include<stdio.h>
int RBS ( int A[] , int l , int h , int key ) /* Recursive Binary search function, which calls itself recursively until the key is searched, or when it will check the whole array and key was not able to found */

{
	int mid ;
	mid = ( l + h ) / 2 ;
	if ( l <= h )
	{
	
		if ( A [ mid ] == key )
		{
		return mid ;
	}
		if ( A [ mid ] < key )
		{
		return ( RBS ( A , mid + 1 , h , key ) ) ; // Calling recursive binary search function from same function

	}
		else
		
		return ( RBS ( A , l , mid - 1 , key ) ) ; // Calling recursive binary search function from same function

	}
	else
	return -1 ; 
}
void main()
{
	int A [ 30 ] , l , x , h , n , i , key ;
	printf ( "Enter size of array \n " ) ;
	scanf ( "%d" , &n ) ;
	l = 0 ;
	h = n - 1 ;
	printf ("Enter Array \n " ) ;
	for ( i = 0 ; i < n ; i++ )
	{
		scanf ( "%d" , &A [ i ] ) ;
	}
	printf ( "Enter value for search : " ) ;
	scanf ( "%d" , &key ) ;
	x = RBS ( A , l , h , key ) ;  // Calling recursive binary search function from main function
	if ( x != -1 )
	{
	printf ( "Value present at index : %d " , x ) ;
}
	else
	printf ( "Value not found \n " ) ;
}

上述程序的输出

Enter the size of the array
 12
Enter Array
 14
12
7
8
9
11
3
1
10
5
 18
13
Enter a value for search: 11
Value present at index: 5

下一个主题数据结构中的线性搜索和二分搜索是什么

数据结构中的迭代是什么？

打印 "Hello world" 10 次的程序

在程序中执行迭代的方法

1. 使用程序中的各种循环

2. 使用递归

1. 使用程序中的各种循环

ii. 使用递归

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

数据结构教程

DS 数组

DS 链表

DS 栈

DS 队列

DS 树

DS 图

DS 搜索

DS 排序

哈希与堆

差异

二叉树

二叉搜索树

AVL 树

单向链表

双向链表

循环链表

循环双向链表

DS 选择题

其他

数据结构中的迭代是什么？

打印 "Hello world" 10 次的程序

在程序中执行迭代的方法

1. 使用程序中的各种循环

2. 使用递归

1. 使用程序中的各种循环

ii. 使用递归

相关帖子

三元搜索树

2-3 树 (搜索、插入和删除)

以波浪形排序数组

前缀表达式到后缀表达式的转换

二叉树的直径

反转队列

使用 Map 进行二叉树的垂直顺序遍历

移除链表中的循环

递归冒泡排序

N 元树的层序遍历

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器