## [recursion, Java intelligence podcast notes

Cxy happy 2021-08-08 21:24:55
recursion java intelligence podcast notes

There will be n Array of Numbers arr Make a full arrangement , The idea used is recursion and backtracking .

1. Yes n All elements are arranged , Swap the first element with the following elements in turn , Identify the first element

2. Yes, later n-1 All elements are arranged ,**（ It can be seen as a sub problem of the first step ）** Recursive implementation

3. Replace the exchanged elements back , To prevent the order of array elements from being disturbed **（ Back to the mind ）**

See the following functions for specific implementation ,（ You can use it directly ）

``````
/**
* Arrange all the elements in the array
* @param arr Array to be arranged
* @param k Determine the number of elements , It's a subscript , from 0 Start
* */
private static void f(int[] arr, int k) {
// When k Equal to the length of the array , Explain that the arrangement is complete
if (k == arr.length) {
// Output the arranged array
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]);
}
System.out.println();
}
for (int i = k; i < arr.length; i++) {
// Swap the position of the element to be determined with the subsequent element
int t = arr[k];
arr[k] = arr[i];
arr[i] = t;
// recursive （ Make sure No k+1 Elements ）
f(arr, k+1);
// to flash back , Replace the replaced elements back
t = arr[k];
arr[k] = arr[i];
arr[i] = t;
}
}
```

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
```

The test case ：

``````
public static void main(String[] args) {
int[] arr = {1,2,3,4}; // Array to be processed
int n = 3; // Take out the number of elements
int[] newarr = new int[n]; // An array of results
f(arr, 0);
}
```

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
```

3、 ... and 、 Arrangement and combination of array elements

===============

With the above pair from n Array of elements arr Remove from m Number （ Do not consider the order and do not repeat ） And for n The number is fully arranged , So for the n Take out... From the number m The problem of realizing the arrangement of numbers , It can be seen as a combination of the above two problems .

According to the thinking in Mathematics , We can start from n Select from an array of elements m Elements , Then on this m All elements can be arranged in full order .

The implementation method is as follows ：

``````
/**
* Pair in array n The number is arranged completely
* @param Array to be processed
* @param newarr Array after arrangement
* @param k Which subscript element to start processing
* @param n Number of processing elements
* */
private static void pac(int[] arr,int[] newarr, int k,int n) {
// When n=0 when , Note the number of selected numbers is 0, That is, the combination completes
if (n==0) {
f(newarr, 0); // Fully arrange the new array combined
return;
}
for (int i = k; i <= arr.length-n; i++) {
newarr[newarr.length-n] = arr[i];
pac(arr, newarr,i+1, n-1);
}
}
/**
* Arrange all the elements in the array
* @param arr Array to be arranged
* @param k Determine the number of elements , It's a subscript , from 0 Start
* */
private static void f(int[] arr, int k) {
// When k Equal to the length of the array , Explain that the arrangement is complete
if (k == arr.length) {
// Output the arranged array
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]);
}
System.out.println();
}
for (int i = k; i < arr.length; i++) {
// Swap the position of the element to be determined with the subsequent element
int t = arr[k];
arr[k] = arr[i];
arr[i] = t;
// recursive （ Make sure No k+1 Elements ）
f(arr, k+1);
// to flash back , Replace the replaced elements back
t = arr[k];
arr[k] = arr[i];
arr[i] = t;
}
}
```

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
```

The test case ：

## Authoritative guide - The first Docker book

Lead to the completion of Docker Installation 、 Deploy 、 Manage and expand , Let it go through the whole development life cycle from test to production , Deepen understanding Docker What scenarios are applicable to . And this book Docker The learning authority guide introduces the basics of its components , And then use Docker Build containers and services to accomplish various tasks ： utilize Docker Build a test environment for new projects , Demonstrates how to integrate workflow using continuous integration Docker, How to build application services and platforms , How to use Docker Of API, How to expand Docker.

All in all ： brief introduction 、 install Docker、Docker introduction 、 Use Docker Image and warehouse 、 Use... In tests Docker、 Use Docker Build a service 、 Use Fig Orchestration Docke、 Use Docker API、 Get help and help with Docker Make improvements, etc 9 A chapter of knowledge .    Ali's internal use is highly recommended “K8S+Docker Learning Guide ”—《 Explain profound theories in simple language Kubernetes： theory + actual combat 》、《 Authoritative guide - The first Docker book 》, After reading, two words describe , I love you ！ 