import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int a[] = new int[] { 1, 1, 23, 456, 0 };
// int a初始化方式
int bb[] = { 1, 2, 3, 4 };
// int c[5] = {1,2,34,5,6};//错误
int d[] = new int[6]; // 初始为0
// int e[] = new int[5]{1,2,34,52,2}; 错误
int f[] = new int[] { 1, 2, 3, 4, 5, 6 };
for (int i = 0; i != 6; ++i) {
System.out.println("ay i=" + d + ",value=" + d[i]);
}
System.out.println("------------");
// Arrays.fill(a, 0, 6, 1);
Arrays.parallelSort(a, 0, 5);
// 快速升序排序
for (int i = 0; i != 5; ++i) {
System.out.println("ay i=" + i + ",value=" + a[i]);
}
int[] b = Arrays.copyOfRange(a, 1, 7);
// Array是copy，是浅copy,from需要小于长度，to超过长度将初始化为0
for (int i = 0; i != 6; ++i) {
System.out.println("by i=" + i + ",value=" + b[i]);
}
int heap_max[] = { 111, 2121, 222, 113, 11111114, 5111, 1, 3, 24, 1, 213, 123 };
// maxHeap(heap_max, 5);
int size = 12;
while (size > 0) {
maxHeap(heap_max, size);
int last = heap_max[size - 1];
heap_max[size - 1] = heap_max[0];
heap_max[0] = last;
size--;
}
}
static void maxHeap(int a[], int size) {
int last_index = size - 1;
// 自下而上检测
while (last_index > 0) {
int root_index = last_index / 2;
if (last_index % 2 == 0) {
root_index = root_index - 1;
} else {
}
int root = a[root_index];
int left = a[root_index * 2 + 1];
int right = 0;
if (root_index * 2 + 2 < size) {
right = a[root_index * 2 + 2];
}
if (root < left) {
if (left < right) {
int rc = root;
a[root_index] = right;
a[root_index * 2 + 2] = rc;
} else {
int rc = root;
a[root_index] = left;
a[root_index * 2 + 1] = rc;
}
} else {
if (root < right) {
int rc = root;
a[root_index] = right;
a[root_index * 2 + 2] = rc;
}
}
last_index -= 2;
// System.out.println(Arrays.toString(a));
}
// 自上而下检测所有根节点
int index = 0;
while (index < size) {
int root_index = index;
int root = a[root_index];
int left_index = root_index * 2 + 1;
int left = 0;
if (left_index < size) {
left = a[left_index];
} else {
left = -1;
break;
}
int right_index = root_index * 2 + 2;
int right = 0;
if (right_index < size) {
right = a[right_index];
} else {
right = -1;
break;
}
if (root < left) {
if (left < right) {
int rc = root;
a[root_index] = a[right_index];
a[right_index] = rc;
} else {
int rc = root;
a[root_index] = a[left_index];
a[left_index] = rc;
}
} else {
if (root < right) {
int rc = root;
a[root_index] = a[right_index];
a[right_index] = rc;
}
}
index++;
// System.out.println(Arrays.toString(a));
}
System.out.println(Arrays.toString(a));
}
}
Commençons par le code. Le tri par tas a toujours été source de confusion. J'ai trouvé la vidéo et je l'ai tout de suite comprise, alors j'ai commencé à me masturber.
Généralement, un tableau est utilisé pour construire une relation de tas. dans un tableau
L'index de chaque nœud racine
root_index = left_child_index/2
root_index = right_child_index/2 -1 ;
left_child_index = 2*root_index+1;
right_child_index = 2*root_index+2;
Rappelez-vous cette relation, puis exécutez dans l'ordre de construction du i-heap :
1. Construisez un arbre binaire, c'est-à-dire construisez-le selon la relation de position ci-dessus
2. Détection ascendante :
En partant du dernier nœud, recherchez le nœud racine de chaque nœud, puis continuez à rechercher les nœuds enfants gauche et droit en fonction du nœud racine, prenez la valeur maximale parmi les trois nœuds et échangez des positions avec le nœud racine.
3. Détection descendante
En partant d'un nœud tour à tour, recherchez les nœuds enfants gauche et droit de chaque nœud, prenez la valeur maximale parmi les trois nœuds et échangez les positions avec le nœud racine.
N'oubliez pas ces trois ordres et tout ira bien.
Conseils:
Suggestions de codage spécifiques : dans la deuxième étape, si vous parcourez en séquence, il y aura un grand nombre de calculs répétés de nœuds. Parce qu'il commence à partir du nœud feuille, chaque nœud a deux nœuds feuilles et sera recherché deux fois. Par conséquent, après chaque recherche, inscrivez simplement -2 et passez directement au nœud racine suivant.
Dans la troisième étape, il est possible que les nœuds feuilles ne soient pas trouvés. Lorsque les nœuds gauche et droit ne peuvent pas être trouvés, sortez simplement de la boucle, ce qui signifie que tous les nœuds racines ont été trouvés. Une fois la racine trouvée, l’ajustement est terminé.
Le dernier est l’ordre d’impression.
[11111114, 2121, 5111, 113, 213, 222, 1, 3, 24, 1, 111, 123] [5111, 2121, 222, 113, 213, 123, 1, 3, 24, 1, 111, 11111114
]
[2121, 213, 222, 113, 111, 123, 1, 3, 24, 1, 5111, 11111114] [222, 213, 123, 113, 111, 1, 1, 3, 24, 2121, 5111, 11111114
]
[213, 113, 123, 24, 111, 1, 1, 3, 222, 2121, 5111, 11111114] [123, 113, 3, 24, 111, 1, 1, 213, 222, 2121, 5111, 11111114
]
[113, 111, 3, 24, 1, 1, 123, 213, 222, 2121, 5111, 11111114] [111, 24, 3, 1, 1, 113, 123, 213, 222, 2121, 5111, 11111114
]
[24, 1, 3, 1, 111, 113, 123, 213, 222, 2121, 5111, 11111114] [3, 1, 1, 24, 111, 113, 123, 213, 222, 2121, 5111, 11111114
]
[1, 1, 3, 24, 111, 113, 123, 213, 222, 2121, 5111, 11111114]
[1, 1, 3, 24, 111, 113, 123, 213, 222, 2121, 5111, 11111114]
Le processus de tri en tas.
La première étape :
créez un tas avec des éléments [0, N) dans le tableau à chaque fois. Une fois la construction terminée, le plus grand nombre se trouve à la position d'index 0.
Étape 2 : échangez l'indice 0 avec le dernier élément du tableau. Après échange, le plus grand nombre est en dernière position
Étape 3 : N=N-1, répétez la première étape, N=1 sortez simplement de la boucle
Résumer:
Il est préférable d'utiliser Java pour répondre aux questions, mais ce n'est pas si pratique d'utiliser C++. Plus tard, j'irai aux 200 questions pour interviewer MS.