Inducción del algoritmo de estructura de datos

Pensamiento recursivo

Por ejemplo: Secuencia de Fibonacci: 1 1 2 3 5 8 13 …… Requisito: Encuentre el valor correspondiente a la posición N especificada.
Vaya a la página de configuración del blog , elija un elemento de código que resalte el estilo que le guste, el mismo resaltado se muestra a continuación 代码片.

//递推思想
//需求 1 1 2 3 5 8 13 ...... 求出指定位置N对应的值是多少

$f[1] = 1;
$f[2] = 1;
//列出数组元素
$des = 15;
for($i = 3;$i <= $des;$i++){
    
    
    $f[$i] = $f[$i-1] + $f[$i-2];
}

echo '<pre>';
print_r($f);
//建立函数寻找
function my_recursive($des){
    
    
    if($des == 1 || $des == 2) return 1;

    //开始计算
    $f[1] = 1;
    $f[2] = 1;

    for($i = 3;$i <= $des;$i++){
    
    
        $f[$i] = $f[$i-1] + $f[$i-2];
    }
    return $f[$des];
}

echo '第15个元素的值为：' . my_recursive(15);

Imagen de efecto:

Pensamiento recursivo

Los puntos importantes del pensamiento recursivo : puntos recursivos y salidas recursivas .
Punto de recursividad : Se encuentra que el problema actual puede tener una función para resolver el problema actual, para resolver el problema de menor escala que el actual. Por ejemplo: F (N) = F (N-1) + F (N-2);
Salida recursiva : cuando se resuelve el problema actual, se ha alcanzado el subproblema óptimo (debe tener) y no se puede volver a llamar a la función.
Esencia : espacio para el tiempo

//递归思想
//用递归的思想求斐波那契数列
//递归一定有函数

function recursion($n){
    
    
    //递归出口
    if($n ==1 || $n == 2) return 1;

    //递归点：求N得值，与求N-1的值一模一样，只是N-1的规模比N小
    return recursion($n-1) + recursion($n-2);
}

//调用
echo recursion(15);

Ordenamiento de burbuja

Bubble Sort (Bubble Sort) es un algoritmo de clasificación relativamente simple en el campo de la informática. Visitó repetidamente la secuencia para clasificar, comparó dos elementos a la vez y los intercambió si estaban en el orden incorrecto. El trabajo de visitar la secuencia se repite hasta que no hay necesidad de intercambiar, es decir, se ha ordenado la secuencia.

Ideas burbujeantes:
1. Compare elementos adyacentes, si el primero no es tan grande como el segundo, cámbielos por dos
2. Haga el mismo trabajo para cada elemento adyacente, desde el primer par al principio hasta el último al final Correcto. En este punto, el último elemento debería ser el número más grande.
3. Repita los pasos anteriores para todos los elementos, excepto el último
4. Continúe repitiendo los pasos anteriores para cada vez menos elementos hasta que no haya un par de números para comparar.

//数组排序算法：冒泡排序

$arr = array(1,4,2,9,7,5,8);
$a = 0;

//2、想办法让下面可以每次找出最大的代码重复执行
for($i = 0; $i < count($arr)-1; $i++){
    
    
//1、想办法将最大的值放到右边
    for($j = 0; $j < count($arr)-1-$i; $j++){
    
    
        if($arr[$j] > $arr[$j+1]){
    
    
            $temp = $arr[$j];
            $arr[$j] = $arr[$j+1];
            $arr[$j+1] = $temp;
        }
        $a++;
    }
}


echo '<pre>';
print_r($arr);
echo '计算次数：' . $a;

Imagen de efecto:

Seleccionar ordenar

La clasificación por selección (clasificación por selección) es un algoritmo de clasificación simple e intuitivo. Su principio de funcionamiento es seleccionar el elemento más pequeño (más grande) de los elementos de datos que se ordenarán cada vez y almacenarlo al comienzo de la secuencia hasta que todos los elementos de datos ordenados estén ordenados. La clasificación por selección es el método de clasificación más inestable (como la secuencia [5,5,3]). Los primeros 5 y 3 se intercambian por primera vez, lo que hace que los primeros 5 se muevan detrás del segundo 5.
Ideas:
1. Supuesto El primer elemento es el elemento más pequeño, escriba el subíndice
2. Busque los elementos restantes a la derecha, si hay uno más pequeño, vuelva a escribir el último subíndice
3. Si hay uno nuevo más pequeño, intercambie los dos elementos
4. Ir Repita los pasos anteriores a la derecha hasta que el elemento en sí sea el último

//数组排序算法：选择排序

$arr = array(1,5,2,9,6,3,4);

//1、确定要交换多少次，一次只能找到一个最小的，需要找到数组长度对应的次数
for($i = 0,$len = count($arr); $i < $len; $i++){
    
    
    //2、假设当前第一次已经排好序了
    $min = $i;
    //3、拿该最小的取比较剩余的其他
    for($j = $i+1; $j < $len; $j++){
    
    
        //4、比较当前最小值和指定值
        if($arr[$j] < $arr[$min]){
    
    
            //说明当前指定的min不合适
            $min = $j;
        }
    }

    //5、交换最小值的小标
    if($min != $i){
    
    
        $temp = $arr[$i];
        $arr[$i] = $arr[$min];
        $arr[$min] = $temp;
    }
}
echo '<pre>';
print_r($arr);

Imagen de efecto:

Tipo de inserción

La ordenación por inserción consiste en insertar un dato en los datos ordenados que se han ordenado.
Ideas:
1. Determinar que el primer elemento ha sido ordenado
2. Sacar el segundo elemento como los datos a insertar
3. Iniciar la comparación con el más a la derecha de la matriz ordenada
4. Si este último es más pequeño que el anterior: Explique que el elemento de la matriz que se ordenó antes no está en la posición correcta (mueva un bit hacia atrás) y luego complete el nuevo elemento.
5. Repita los pasos anteriores: hasta que el elemento actual se inserte en la posición correcta

//php数组排序：插入排序
$arr = array(4,2,6,8,9,5);

//1、确定要插入的次数（同时假设第一个位置是对的）
for($i = 1, $len = count($arr); $i < $len; $i++){
    
    
    //2、取出当前要插入的元素值
    $temp = $arr[$i];

    //标记：默认说明当前要插入的数组位置是对的
    $change = false;
    //3、让该数据与前面已经排好序的数组元素重复比较，直到位置正确
    for($j = $i - 1;$j >= 0; $j--){
    
    
        //比较
        if($arr[$j] > $temp){
    
    
            $arr[$j+1] = $arr[$j];
            //$arr[$j] = $temp;

            //说明前面顺序位置有不合适的位置
            $change = true;
        }else{
    
    
            //说明当前带插入元素，比前面大，位置正确
            break;
        }
    }
    //判断位置是否有变动
    if($change){
    
    
        //有数据移动：占错位置了
        $arr[$j+1] = $temp;
    }
}

echo '<pre>';
print_r($arr);

Ordenación rápida

La clasificación rápida (clasificación rápida) es una mejora de la clasificación de burbujas. Divida los datos para clasificarlos en dos partes independientes clasificando, una parte de la cual todos los datos son más pequeños que la otra parte, y luego, de acuerdo con este método para clasificar rápidamente las dos partes, todo el proceso de clasificación puede ser recursivo, para lograr el todo Los datos se convierten en una secuencia ordenada.
Idea del algoritmo:
1. Seleccione un elemento de la matriz (generalmente el primero) como referencia
2. Defina dos matrices y compare los elementos restantes en la matriz de destino con el elemento de referencia uno por uno; coloque una matriz para el más pequeño y una matriz para el más grande
3. 、 Después de la ejecución, el orden de las matrices anterior y posterior es incierto, pero su posición está determinada.
4. Repita la matriz pequeña resultante de 1 a 3.
5. Retroceda la matriz más pequeña (1 elemento)

//php数组排序：快速排序

$arr = array(5,6,3,4,9,2,7,8);

//快速排序
function quick_sort($arr){
    
    
    //递归出口
    $len = count($arr);
    if($len <= 1) return $arr;

    //取出某个元素。然后将剩余的数组元素，分散到两个不同的数组中
    $left = $right = array();

    for($i = 1; $i < $len; $i++){
    
    
        //第一个元素作为比较元素
        //比较：小的放left，大的放right中
        if($arr[$i] < $arr[0]){
    
    
            $left[] = $arr[$i];
        }else{
    
    
            $right[] = $arr[$i];
        }
    }

    //left和right没有排好序：递归点
    $left = quick_sort($left);
    $right = quick_sort($right);

    //合并三个“数组”
    return array_merge($left,(array)$arr[0],$right);

}

echo '<pre>';
print_r(quick_sort($arr));

Combinar ordenación

Clasificación por combinación La clasificación por
combinación (clasificación por combinación) es un algoritmo de clasificación eficaz basado en la operación de combinación. Este algoritmo es una aplicación típica de dividir y conquistar. Combine las subsecuencias ordenadas existentes para obtener una secuencia completamente ordenada; es decir, primero use cada subsecuencia para ordenar, y luego haga que la subsecuencia termine en orden, y luego combine las dos listas ordenadas en una lista ordenada, que se convierte en dos Carretera fusionada.

El algoritmo de clasificación de combinación es:
1.
Divida la matriz en dos matrices 2. Repita el paso 1 para dividir la matriz en dos unidades más pequeñas
3. Solicite espacio para hacer que el tamaño de las dos secuencias ordenadas sea la suma, y ​​este espacio se usa para almacenar la combinación Después de la secuencia
4. Establezca dos punteros, las posiciones iniciales son las posiciones iniciales de las dos secuencias ordenadas respectivamente.
5. Compare los elementos señalados por los dos punteros, seleccione elementos relativamente pequeños y colóquelos en el espacio de fusión, y mueva los punteros a Siguiente posición
6. Repita el paso 3 hasta que un puntero exceda el final de la secuencia
7. Copie todos los elementos restantes de la otra secuencia directamente y combine el final de la secuencia

//PHP数组算法：归并排序

/**二路归并*/
$arr1 = array(1,3,5);
$arr2 = array(2,4,6);

//取出数组用于归并空间
$arr3 = array();

while(count($arr1) && count($arr2)){
    
    
    //如果数组中都还有数据，则循环
    $arr3[] = $arr1[0] < $arr2[0] ? array_shift($arr1) :array_shift($arr2);
}
//print_r(array_merge($arr3,$arr1,$arr2));

/**归并排序*/
$arr = array(4,7,2,1,5,9,3,5,6);

//归并排序函数
function merge_sort($arr){
    
    
    //递归出口
    $len = count($arr);
    if($len <= 1) return $arr;

    //拆分
    $middle = floor($len/2);
    $left = array_slice($arr,0,$middle);
    $right = array_slice($arr,$middle);

    //递归出口
    $left = merge_sort($left);
    $right = merge_sort($right);

    //假设左边和右边都已经排序好了
    $arr3 = array();
    while(count($left) && count($right)){
    
    
        //只要$left和$right都还有元素
        $arr3[] = $left[0] < $right[0] ? array_shift($left) :array_shift($right);
    }
    return array_merge($arr3,$left,$right);
}
echo '<pre>';
$t1 = microtime(true);
print_r(merge_sort($arr));
$t2 = microtime(true);
echo '耗时' . round($t2 - $t1,3).;

Algoritmo de búsqueda

Significado del algoritmo de búsqueda:
Buscar es encontrar un elemento de información específico en una gran cantidad de información. En las aplicaciones informáticas, la búsqueda es una operación básica común. El algoritmo de búsqueda se refiere al nudo de código correspondiente en el proceso de búsqueda. Sirve para ubicar rápidamente el elemento deseado en una gran variedad.

Algoritmo de búsqueda secuencial :
La búsqueda secuencial también se llama búsqueda lineal. Comienza desde una sección de la tabla lineal de estructura de datos y escanea secuencialmente. Compara la clave de nodo escaneada con el valor k dado. Si son iguales, la búsqueda es exitosa. Encuentre un nodo con una palabra clave igual a k, lo que indica que la búsqueda falló

Algoritmo de búsqueda binaria : la
búsqueda binaria requiere que los nodos de la tabla lineal estén ordenados en orden ascendente o descendente de palabras clave, y el valor k dado se utiliza para comparar las palabras clave del nodo intermedio. El nodo intermedio divide la tabla lineal en dos subtablas. La búsqueda es exitosa; si no son iguales, determine qué subtabla buscar a continuación de acuerdo con el resultado de la comparación de ky la clave del nodo intermedio, y proceda de forma recursiva hasta que la búsqueda finalice y no exista tal nodo en la tabla.

Código de búsqueda binaria:

//二分法查找
$arr = array(1,2,3,4,5,6,7);
$res = 100;

function check_break($arr,$res){
    
    
    //1、得到数组边界
    $right = count($arr)-1;
    $left = 0;

    //2、循环匹配
    while($right >= $left){
    
    
        //3、得到中间位置
        $middle = floor(($right + $left)/2);

        //4、匹配数据
        if($arr[$middle] == $res){
    
    
            return $middle + 1;
        }

        //没有找到
        if($arr[$middle] < $res){
    
    
            //值在右边
            $left = $middle + 1 ;
        }else{
    
    
            //值在左边
            $right  = $middle - 1;
        }
    }
    return false;
}

echo '<pre>';
var_dump(check_break($arr,$res));

Si te ayuda, ¡me gusta!