illyustratsia

1.

ИЛЛЮСТРАЦИЯ ВЫПОЛНЕНИЯ
ПРОГРАММЫ

2.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P) {
for (int i = 1; i <= n; i++) {
if (R[i] == 0) {
P[k] = i; R[i] = 1;
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] = {0};
per(1, R, n, P);
}
Статическая память
Динамическая память

3.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P) {
for (int i = 1; i <= n; i++) {
if (R[i] == 0) {
P[k] = i; R[i] = 1;
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n, P);
}
Статическая память
n
3
R
{0, 0, 0, 0}
P
{0, 0, 0, 0}
Динамическая память

4.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P) {
for (int i = 1; i <= n; i++) {
if (R[i] == 0) {
n
3
R
{0, 0, 0, 0}
P
{0, 0, 0, 0}
Динамическая память
Стек
P[k] = i; R[i] = 1;
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
1
R[i] = 0;
Адрес R[0]
}
}
n=3
}
int main() {
Адрес P[0]
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
P);
}
1
Для
возвращаемого
значения
Адрес 1

5.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
for (int i = 1; i <= n; i++) {
n
3
R
{0, 0, 0, 0}
P
{0, 0, 0, 0}
Динамическая память
Стек
if (R[i] == 0) {
P[k] = i; R[i] = 1;
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
P);
}
1
Для
возвращаемого
значения
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

6.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 0, 0, 0}
P
{0, 0, 0, 0}
Динамическая память
Стек
if (R[i] == 0) {
P[k] = i; R[i] = 1;
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] = 0;
}
}
}
int main() {
Для
возвращаемого
значения
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
P);
1
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

7.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 0, 0, 0}
P
{0, 0, 0, 0}
Динамическая память
Стек
if (R[i] == 0)
true
{
P[k] = i; R[i] = 1;
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j]
i
1
}
k
1
else per(k + 1, R, n, P);
R
Адрес R[0]
n
n=3
P
Адрес P[0]
<< " ";
cout << endl;
R[i] = 0;
}
}
}
Для
возвращаемого
значения
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
P);
1
Адрес 1

8.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 1, 0, 0}
P
{0, 1, 0, 0}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n) {
<< " ";
for (int j = 1; j <= n; j++) cout << P[j]
i
1
cout << endl;
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
}
else per(k + 1, R, n, P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
Для
возвращаемого
значения
Адрес 1

9.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 1, 0, 0}
P
{0, 1, 0, 0}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
false
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для
возвращаемого
значения
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

10.

Программный код
Статическая память
n
#include <iostream>
k=1+1
using namespace std;
void per(int k, int *R, int &n, int *P) {
{
3
Динамическая память
Стек
for (int i = 1; i <= n; i++)
R
{0, 1, 0, 0}
P
{0, 1, 0, 0}
Адрес R[0]
n=3
if (R[i] == 0) {
Адрес P[0]
P[k] = i; R[i] =
1;
Для возвращаемого
значения
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << " ";
cout << endl;
}
else per(k + 1, R, n,
P);
2
R[i] = 0;
}
}
}
int main() {
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
P);
Адрес 2
1
Адрес 1

11.

Программный код
Статическая память
n
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
if (R[i] == 0) {
P[k] = i; R[i] =
1;
R
{0, 1, 0, 0}
P
{0, 1, 0, 0}
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
if (k == n)
{
3
Динамическая память
Стек
Адрес 2
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для возвращаемого
значения
Адрес 1

12.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 1, 0, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 1, 0, 0}
Динамическая память
Стек
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

13.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
false
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 1, 0, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 1, 0, 0}
Динамическая память
Стек
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

14.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 1, 0, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 1, 0, 0}
Динамическая память
Стек
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

15.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
true
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 1, 0, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 1, 0, 0}
Динамическая память
Стек
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

16.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 1, 2, 0}
Динамическая память
Стек
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

17.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
false
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 1, 2, 0}
Динамическая память
Стек
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

18.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 1, 1, 0}
P
{0, 1, 2, 0}
Динамическая память
Стек
k =2+1
Адрес R[0]
if (R[i] == 0)
{
n=3
Адрес P[0]
P[k] = i; R[i] =
1;
Для возвращаемого
значения
Адрес 3
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
3 2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
2
Для возвращаемого
значения
R[i] = 0;
int main() {
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

19.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P) {
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 1, 1, 0}
P
{0, 1, 2, 0}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
if (k == n) {
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
i
2
k
2
R
Адрес R[0]
}
n
n=3
else per(k + 1, R, n,
P
Адрес P[0]
";
cout << endl;
P);
k
3 2
Для возвращаемого
значения
R[i] = 0;
Адрес 2
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

20.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 0}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

21.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 0}
if (R[i] == 0)
false
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

22.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 0}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
2
Для возвращаемого
значения
if (k == n) {
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

23.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 0}
if (R[i] == 0)
false
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
2
Для возвращаемого
значения
if (k == n) {
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

24.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 0}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
3
Для возвращаемого
значения
if (k == n) {
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

25.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 0}
if (R[i] == 0)
true
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
3
Для возвращаемого
значения
if (k == n) {
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

26.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 3}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
3
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
if (k == n) {
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
i
2
k
2
R
Адрес R[0]
}
n
n=3
else per(k + 1, R, n,
P
Адрес P[0]
";
cout << endl;
P);
i
3 2
Для возвращаемого
значения
R[i] = 0;
Адрес 2
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

27.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 3}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
{
true
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
3
Для возвращаемого
значения
if (k == n)
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

28.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 3}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "1 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
1
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

29.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 3}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "2 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
2
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

30.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 3}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "3 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
3
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

31.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 3}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
3 2
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
Вывод перехода на след. строку
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

32.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 2, 3}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
int n = 3, R[4] = {0}, P[4] =
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
R
3 2
}
}
3
Для возвращаемого
значения
R[i] =
0;
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

33.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 1, 1, 0}
P
{0, 1, 2, 3}
Динамическая память
Стек
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
n
3 2
}
}
Адрес R[0]
Для возвращаемого
значения
R[i] =
0;
R
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
k
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

34.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 1, 0, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 1, 2, 3}
Динамическая память
Стек
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

35.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 1, 0, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 1, 2, 3}
Динамическая память
Стек
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

36.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
true
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 1, 0, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 1, 2, 3}
Динамическая память
Стек
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

37.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 1, 3, 3}
Динамическая память
Стек
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

38.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
false
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 1, 3, 3}
Динамическая память
Стек
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

39.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 1, 0, 1}
P
{0, 1, 3, 3}
Динамическая память
Стек
k =2+1
Адрес R[0]
if (R[i] == 0)
{
n=3
Адрес P[0]
P[k] = i; R[i] =
1;
Для возвращаемого
значения
Адрес 3
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
3 2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

40.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P) {
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 1, 0, 1}
P
{0, 1, 3, 3}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
if (k == n) {
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
i
3
k
2
R
Адрес R[0]
}
n
n=3
else per(k + 1, R, n,
P
Адрес P[0]
";
cout << endl;
P);
k
3 2
Для возвращаемого
значения
R[i] = 0;
Адрес 2
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

41.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 3}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

42.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 3}
if (R[i] == 0)
false
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

43.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 3}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
2
Для возвращаемого
значения
if (k == n) {
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

44.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 3}
if (R[i] == 0)
true
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
2
Для возвращаемого
значения
if (k == n) {
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

45.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
if (k == n) {
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
i
3
k
2
R
Адрес R[0]
}
n
n=3
else per(k + 1, R, n,
P
Адрес P[0]
";
cout << endl;
P);
i
3 2
Для возвращаемого
значения
R[i] = 0;
Адрес 2
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

46.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
{
true
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
2
Для возвращаемого
значения
if (k == n)
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

47.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "1 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
2
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
1
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

48.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "3 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
2
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
2
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

49.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "2 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
2
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
3
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

50.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
3 2
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
Вывод перехода на след. строку
for (int j = 1; j <= n; j++) cout << P[j] << "
";
2
Для возвращаемого
значения
if (k == n)
{
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

51.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
int n = 3, R[4] = {0}, P[4] =
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
R
3 2
}
}
3
Для возвращаемого
значения
R[i] =
0;
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
2
Для возвращаемого
значения
if (k == n)
{
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

52.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 2}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
3
Для возвращаемого
значения
if (k == n) {
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

53.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 1, 3, 2}
if (R[i] == 0)
false
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
3
Для возвращаемого
значения
if (k == n) {
";
i
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

54.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 1, 0, 1}
P
{0, 1, 3, 2}
Динамическая память
Стек
if (R[i] == 0) {
P[k] = i; R[i] =
1;
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
if (k == n) {
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
i
3
k
2
R
Адрес R[0]
}
n
n=3
else per(k + 1, R, n,
P
Адрес P[0]
";
cout << endl;
P);
k
3 2
Для возвращаемого
значения
R[i] = 0;
Адрес 2
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

55.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 1, 0, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 1, 3, 2}
Динамическая память
Стек
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

56.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
2
n
3
R
{0, 1, 0, 0}
P
{0, 1, 3, 2}
Динамическая память
Стек
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

57.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 0, 0, 0}
P
{0, 1, 3, 2}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для
возвращаемого
значения
i
1
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

58.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 0, 0, 0}
P
{0, 1, 3, 2}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для
возвращаемого
значения
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

59.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 0, 0, 0}
P
{0, 1, 3, 2}
Динамическая память
Стек
if (R[i] == 0)
true
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для
возвращаемого
значения
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

60.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 0, 1, 0}
P
{0, 2, 3, 2}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для
возвращаемого
значения
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

61.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 0, 1, 0}
P
{0, 2, 3, 2}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
false
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для
возвращаемого
значения
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

62.

Программный код
Статическая память
n
#include <iostream>
k=1+1
using namespace std;
void per(int k, int *R, int &n, int *P) {
{
3
Динамическая память
Стек
for (int i = 1; i <= n; i++)
R
{0, 0, 1, 0}
P
{0, 2, 3, 2}
Адрес R[0]
n=3
if (R[i] == 0) {
Адрес P[0]
P[k] = i; R[i] =
1;
Для возвращаемого
значения
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << " ";
cout << endl;
}
else per(k + 1, R, n,
P);
2
R[i] = 0;
}
}
}
int main() {
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
P);
Адрес 2
1
Адрес 1

63.

Программный код
Статическая память
n
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
if (R[i] == 0) {
P[k] = i; R[i] =
1;
R
{0, 0, 1, 0}
P
{0, 2, 3, 2}
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
if (k == n)
{
3
Динамическая память
Стек
Адрес 2
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для возвращаемого
значения
Адрес 1

64.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 0, 1, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 2, 3, 2}
Динамическая память
Стек
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

65.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
true
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 0, 1, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 2, 3, 2}
Динамическая память
Стек
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

66.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 2, 1, 2}
Динамическая память
Стек
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

67.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
false
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 2, 1, 2}
Динамическая память
Стек
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

68.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 1, 1, 0}
P
{0, 2, 1, 2}
Динамическая память
Стек
k =2+1
Адрес R[0]
if (R[i] == 0)
{
n=3
Адрес P[0]
P[k] = i; R[i] =
1;
Для возвращаемого
значения
Адрес 3
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
3 2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
1
Для возвращаемого
значения
R[i] = 0;
int main() {
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

69.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P) {
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 1, 1, 0}
P
{0, 2, 1, 2}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
if (k == n) {
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
i
1
k
2
R
Адрес R[0]
}
n
n=3
else per(k + 1, R, n,
P
Адрес P[0]
";
cout << endl;
P);
k
3 2
Для возвращаемого
значения
R[i] = 0;
Адрес 2
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

70.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 2}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

71.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 2}
if (R[i] == 0)
false
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

72.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 2}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
2
Для возвращаемого
значения
if (k == n) {
";
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

73.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 2}
if (R[i] == 0)
false
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
2
Для возвращаемого
значения
if (k == n) {
";
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

74.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 2}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
3
Для возвращаемого
значения
if (k == n) {
";
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

75.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 2}
if (R[i] == 0)
true
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
3
Для возвращаемого
значения
if (k == n) {
";
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

76.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 3}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
3
Для возвращаемого
значения
if (k == n) {
";
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

77.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 3}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
{
true
cout << endl;
}
else per(k + 1, R, n,
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
3 2
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
P);
3
Для возвращаемого
значения
if (k == n)
";
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

78.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 3}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "2 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
1
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

79.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 3}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "1 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
2
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

80.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 3}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "3 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
3
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

81.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 3}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
3 2
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
Вывод перехода на след. строку
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

82.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 0}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 1, 3}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
else per(k + 1, R, n,
P);
int n = 3, R[4] = {0}, P[4] =
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
R
3 2
}
}
3
Для возвращаемого
значения
R[i] =
0;
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

83.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 1, 1, 0}
P
{0, 2, 1, 3}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
else per(k + 1, R, n,
P);
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
n
3 2
}
}
Адрес R[0]
Для возвращаемого
значения
R[i] =
0;
R
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
k
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

84.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 1, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 2, 1, 3}
Динамическая память
Стек
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

85.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 1, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 2, 1, 3}
Динамическая память
Стек
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

86.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
false
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 1, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 2, 1, 3}
Динамическая память
Стек
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

87.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 1, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 2, 1, 3}
Динамическая память
Стек
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

88.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
true
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 1, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 2, 1, 3}
Динамическая память
Стек
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

89.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 2, 3, 3}
Динамическая память
Стек
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

90.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
false
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 2, 3, 3}
Динамическая память
Стек
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

91.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 0, 1, 1}
P
{0, 2, 3, 3}
Динамическая память
Стек
k =2+1
Адрес R[0]
if (R[i] == 0)
{
n=3
Адрес P[0]
P[k] = i; R[i] =
1;
Для возвращаемого
значения
Адрес 3
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
3 2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

92.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P) {
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 0, 1, 1}
P
{0, 2, 3, 3}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
if (k == n) {
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
i
3
k
2
R
Адрес R[0]
}
n
n=3
else per(k + 1, R, n,
P
Адрес P[0]
";
cout << endl;
P);
k
3 2
Для возвращаемого
значения
R[i] = 0;
Адрес 2
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

93.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 3}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

94.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 3}
if (R[i] == 0)
true
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

95.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 1}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

96.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 1}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
{
true
cout << endl;
}
else per(k + 1, R, n,
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
3 2
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
P);
1
Для возвращаемого
значения
if (k == n)
";
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

97.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "2 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
1
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
1
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

98.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "3 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
1
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
2
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

99.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "1 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
1
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
3
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

100.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
3 2
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
Вывод перехода на след. строку
for (int j = 1; j <= n; j++) cout << P[j] << "
";
1
Для возвращаемого
значения
if (k == n)
{
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

101.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
int n = 3, R[4] = {0}, P[4] =
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
R
3 2
}
}
3
Для возвращаемого
значения
R[i] =
0;
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
1
Для возвращаемого
значения
if (k == n)
{
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

102.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
int n = 3, R[4] = {0}, P[4] =
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
R
3 2
}
}
3
Для возвращаемого
значения
R[i] =
0;
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
2
Для возвращаемого
значения
if (k == n)
{
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

103.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 1}
if (R[i] == 0)
false
{
P[k] = i; R[i] =
1;
cout <<
endl;
P);
3 2
}
}
}
int main() {
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
R[i] =
0;
3
Для возвращаемого
значения
}
else per(k + 1, R, n,
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
2
Для возвращаемого
значения
if (k == n)
{
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

104.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
int n = 3, R[4] = {0}, P[4] =
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
R
3 2
}
}
3
Для возвращаемого
значения
R[i] =
0;
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

105.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 2, 3, 1}
if (R[i] == 0)
false
{
P[k] = i; R[i] =
1;
cout <<
endl;
P);
3 2
}
}
}
int main() {
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
R[i] =
0;
3
Для возвращаемого
значения
}
else per(k + 1, R, n,
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
i
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

106.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 0, 1, 1}
P
{0, 2, 3, 1}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout <<
endl;
P);
3 2
}
}
}
int main() {
n
n=3
P
Адрес P[0]
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
R[i] =
0;
Адрес R[0]
Для возвращаемого
значения
}
else per(k + 1, R, n,
R
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
k
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

107.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 1, 0}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 2, 3, 1}
Динамическая память
Стек
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

108.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
2
n
3
R
{0, 0, 1, 0}
P
{0, 2, 3, 1}
Динамическая память
Стек
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

109.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 0, 0, 0}
P
{0, 2, 3, 1}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для
возвращаемого
значения
i
2
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

110.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 0, 0, 0}
P
{0, 2, 3, 1}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для
возвращаемого
значения
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

111.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 0, 0, 0}
P
{0, 2, 3, 1}
Динамическая память
Стек
if (R[i] == 0)
true
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для
возвращаемого
значения
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

112.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 0, 0, 1}
P
{0, 3, 3, 1}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для
возвращаемого
значения
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

113.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 0, 0, 1}
P
{0, 3, 3, 1}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
false
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для
возвращаемого
значения
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

114.

Программный код
Статическая память
n
#include <iostream>
k=1+1
using namespace std;
void per(int k, int *R, int &n, int *P) {
{
3
Динамическая память
Стек
for (int i = 1; i <= n; i++)
R
{0, 0, 0, 1}
P
{0, 3, 3, 1}
Адрес R[0]
n=3
if (R[i] == 0) {
Адрес P[0]
P[k] = i; R[i] =
1;
Для возвращаемого
значения
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << " ";
cout << endl;
}
else per(k + 1, R, n,
P);
2
R[i] = 0;
}
}
}
int main() {
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
P);
Адрес 2
1
Адрес 1

115.

Программный код
Статическая память
n
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
if (R[i] == 0) {
P[k] = i; R[i] =
1;
R
{0, 0, 0, 1}
P
{0, 3, 3, 1}
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
if (k == n)
{
3
Динамическая память
Стек
Адрес 2
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для возвращаемого
значения
Адрес 1

116.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 0, 0, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 3, 3, 1}
Динамическая память
Стек
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

117.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
true
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 0, 0, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 3, 3, 1}
Динамическая память
Стек
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

118.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 3, 1, 1}
Динамическая память
Стек
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

119.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
false
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 3, 1, 1}
Динамическая память
Стек
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

120.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 1, 0, 1}
P
{0, 3, 1, 1}
Динамическая память
Стек
k =2+1
Адрес R[0]
if (R[i] == 0)
{
n=3
Адрес P[0]
P[k] = i; R[i] =
1;
Для возвращаемого
значения
Адрес 3
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
3 2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
1
Для возвращаемого
значения
R[i] = 0;
int main() {
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

121.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P) {
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 1, 0, 1}
P
{0, 3, 1, 1}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
if (k == n) {
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
i
1
k
2
R
Адрес R[0]
}
n
n=3
else per(k + 1, R, n,
P
Адрес P[0]
";
cout << endl;
P);
k
3 2
Для возвращаемого
значения
R[i] = 0;
Адрес 2
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

122.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 1}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

123.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 1}
if (R[i] == 0)
false
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

124.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 1}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
2
Для возвращаемого
значения
if (k == n) {
";
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

125.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 1}
if (R[i] == 0)
true
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
2
Для возвращаемого
значения
if (k == n) {
";
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

126.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 2}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
2
Для возвращаемого
значения
if (k == n) {
";
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

127.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 2}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
{
true
cout << endl;
}
else per(k + 1, R, n,
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
3 2
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
P);
2
Для возвращаемого
значения
if (k == n)
";
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

128.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "3 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
2
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
1
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

129.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "1 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
2
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
2
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

130.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "2 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
2
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
3
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

131.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
3 2
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
Вывод перехода на след. строку
for (int j = 1; j <= n; j++) cout << P[j] << "
";
2
Для возвращаемого
значения
if (k == n)
{
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

132.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
int n = 3, R[4] = {0}, P[4] =
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
R
3 2
}
}
3
Для возвращаемого
значения
R[i] =
0;
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
2
Для возвращаемого
значения
if (k == n)
{
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

133.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 2}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
int n = 3, R[4] = {0}, P[4] =
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
R
3 2
}
}
3
Для возвращаемого
значения
R[i] =
0;
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

134.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 0, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 1, 2}
if (R[i] == 0)
false
{
P[k] = i; R[i] =
1;
cout <<
endl;
P);
3 2
}
}
}
int main() {
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
R[i] =
0;
3
Для возвращаемого
значения
}
else per(k + 1, R, n,
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

135.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 1, 0, 1}
P
{0, 3, 1, 2}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout <<
endl;
P);
3 2
}
}
}
int main() {
n
n=3
P
Адрес P[0]
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
R[i] =
0;
Адрес R[0]
Для возвращаемого
значения
}
else per(k + 1, R, n,
R
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
k
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

136.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 0, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 3, 1, 2}
Динамическая память
Стек
i
1
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

137.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 0, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 3, 1, 2}
Динамическая память
Стек
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

138.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
true
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 0, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 3, 1, 2}
Динамическая память
Стек
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

139.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 3, 2, 2}
Динамическая память
Стек
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

140.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
false
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 3, 2, 2}
Динамическая память
Стек
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

141.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 0, 1, 1}
P
{0, 3, 2, 2}
Динамическая память
Стек
k =2+1
Адрес R[0]
if (R[i] == 0)
{
n=3
Адрес P[0]
P[k] = i; R[i] =
1;
Для возвращаемого
значения
Адрес 3
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
3 2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
2
Для возвращаемого
значения
R[i] = 0;
int main() {
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

142.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P) {
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 0, 1, 1}
P
{0, 3, 2, 2}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
if (k == n) {
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
i
2
k
2
R
Адрес R[0]
}
n
n=3
else per(k + 1, R, n,
P
Адрес P[0]
";
cout << endl;
P);
k
3 2
Для возвращаемого
значения
R[i] = 0;
Адрес 2
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
per(1, R, n,
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

143.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 2}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

144.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 2}
if (R[i] == 0)
true
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

145.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 1}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
cout << endl;
}
P);
3 2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
else per(k + 1, R, n,
1
Для возвращаемого
значения
if (k == n) {
";
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

146.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 1}
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
{
true
cout << endl;
}
else per(k + 1, R, n,
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
3 2
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
P);
1
Для возвращаемого
значения
if (k == n)
";
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

147.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "3 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
1
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
1
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

148.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "2 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
1
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
2
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

149.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
Вывод: "1 "
if (k == n)
{
}
P);
3 2
k
3
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
1
Для возвращаемого
значения
R[i] = 0;
int main() {
i
Адрес 3
cout << endl;
else per(k + 1, R, n,
3
Для возвращаемого
значения
for (int j = 1; j <= n; j++) cout << P[j] << "
";
j
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

150.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 1, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
3 2
Адрес 2
}
}
}
int n = 3, R[4] = {0}, P[4] =
{0};
3
Для возвращаемого
значения
R[i] = 0;
int main() {
k
Адрес 3
Вывод перехода на след. строку
for (int j = 1; j <= n; j++) cout << P[j] << "
";
1
Для возвращаемого
значения
if (k == n)
{
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

151.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
int n = 3, R[4] = {0}, P[4] =
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
R
3 2
}
}
3
Для возвращаемого
значения
R[i] =
0;
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
1
Для возвращаемого
значения
if (k == n)
{
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

152.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
int n = 3, R[4] = {0}, P[4] =
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
R
3 2
}
}
3
Для возвращаемого
значения
R[i] =
0;
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
2
Для возвращаемого
значения
if (k == n)
{
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

153.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 1}
if (R[i] == 0)
false
{
P[k] = i; R[i] =
1;
cout <<
endl;
P);
3 2
}
}
}
int main() {
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
R[i] =
0;
3
Для возвращаемого
значения
}
else per(k + 1, R, n,
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
2
Для возвращаемого
значения
if (k == n)
{
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

154.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 1}
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
int n = 3, R[4] = {0}, P[4] =
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
R
3 2
}
}
3
Для возвращаемого
значения
R[i] =
0;
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

155.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
n
3
R
{0, 0, 1, 1}
P
for (int i = 1; i <= n; i++)
Динамическая память
Стек
{0, 3, 2, 1}
if (R[i] == 0)
false
{
P[k] = i; R[i] =
1;
cout <<
endl;
P);
3 2
}
}
}
int main() {
R
Адрес R[0]
n
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
R[i] =
0;
3
Для возвращаемого
значения
}
else per(k + 1, R, n,
k
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
i
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

156.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
n
3
R
{0, 0, 1, 1}
P
{0, 3, 2, 1}
Динамическая память
Стек
if (R[i] == 0) {
P[k] = i; R[i] =
1;
cout <<
endl;
}
else per(k + 1, R, n,
P);
n=3
P
Адрес P[0]
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 2
}
int main() {
n
3 2
}
}
Адрес R[0]
Для возвращаемого
значения
R[i] =
0;
R
Адрес 3
for (int j = 1; j <= n; j++) cout << P[j] << "
";
3
Для возвращаемого
значения
if (k == n)
{
k
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

157.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 0, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 3, 2, 1}
Динамическая память
Стек
i
2
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

158.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 0, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 3, 2, 1}
Динамическая память
Стек
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

159.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
if (R[i] == 0)
false
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
3
R
{0, 0, 0, 1}
P
for (int i = 1; i <= n; i++)
{
n
2
{0, 3, 2, 1}
Динамическая память
Стек
i
3
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

160.

Программный код
Статическая память
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j] << "
";
cout << endl;
}
else per(k + 1, R, n,
P);
R[i] =
0;
}
}
}
int main() {
2
n
3
R
{0, 0, 0, 1}
P
{0, 3, 2, 1}
Динамическая память
Стек
k
2
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 2
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Для возвращаемого
значения
Адрес 1

161.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 0, 0, 0}
P
{0, 3, 2, 1}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
{0};
Для
возвращаемого
значения
i
3
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

162.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P)
{
{
for (int i = 1; i <= n; i++)
Статическая память
n
3
R
{0, 0, 0, 0}
P
{0, 3, 2, 1}
Динамическая память
Стек
if (R[i] == 0)
{
P[k] = i; R[i] =
1;
if (k == n)
{
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] =
0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] =
Для
возвращаемого
значения
k
1
R
Адрес R[0]
n
n=3
P
Адрес P[0]
Адрес 1

163.

Программный код
#include <iostream>
using namespace std;
void per(int k, int *R, int &n, int *P) {
for (int i = 1; i <= n; i++) {
if (R[i] == 0) {
P[k] = i; R[i] = 1;
if (k == n) {
for (int j = 1; j <= n; j++) cout << P[j]
<< " ";
cout << endl;
}
else per(k + 1, R, n, P);
R[i] = 0;
}
}
}
int main() {
int n = 3, R[4] = {0}, P[4] = {0};
per(1, R, n, P);
}
Статическая память
Динамическая память

164.

Результат программы в консоли: