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));
}
}
Начнем с кода.Сортировка кучи всегда вызывала путаницу. Я нашел видео и сразу понял это, поэтому начал мастурбировать сам.
Обычно массив используется для построения отношений кучи. в массиве
Индекс каждого корневого узла
корневой_индекс = левый_дочерний_индекс/2
root_index = right_child_index/2 -1;
left_child_index = 2*root_index+1;
правый_детский_индекс = 2*корневой_индекс+2;
Запомните эту взаимосвязь и затем выполните в порядке построения i-кучи:
1. Построить бинарное дерево, то есть построить его в соответствии с указанным выше соотношением позиций.
2. Обнаружение снизу вверх:
Начиная с последнего узла, найдите корневой узел каждого узла, а затем продолжите поиск левого и правого дочерних узлов на основе корневого узла и возьмите максимальное значение среди трех узлов и поменяйтесь позициями с корневым узлом.
3. Обнаружение сверху вниз
Начиная с одного узла по очереди, найдите левый и правый дочерние узлы каждого узла, возьмите максимальное значение среди трех узлов и поменяйтесь местами с корневым узлом.
Просто запомните эти три приказа, и все будет в порядке.
Советы:
Конкретные предложения по кодированию: на втором этапе, если вы перемещаетесь последовательно, произойдет большое количество повторных вычислений узлов. Поскольку он начинается с листового узла, каждый узел имеет два конечных узла и будет проверяться дважды.Поэтому после каждого поиска просто подпишите индекс -2 и перейдите непосредственно к следующему корневому узлу.
На третьем этапе возможно, что листовые узлы не могут быть найдены. Когда левый и правый узлы не могут быть найдены, просто выйдите из цикла, что означает, что все корневые узлы были найдены. Как только корень найден, настройка завершена.
Последнее — порядок печати.
[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]
Процесс пирамидальной сортировки.
Первый шаг:
каждый раз создайте кучу с элементами [0, N) в массиве. После завершения построения наибольшее число располагается на позиции индекса 0.
Шаг 2: Поменяйте индекс 0 последним элементом массива. После замены наибольшее число оказывается в последней позиции.
Шаг 3: N=N-1, повторяем первый шаг, N=1 просто выходим из цикла
Подведем итог:
Для ответа на вопросы лучше использовать Java, а вот C++ использовать не так удобно. Позже я перейду к 200 вопросам, чтобы взять интервью у М.С.