Preguntas de cepillado de Likou Plan de los cien días Día 14 El K-ésimo elemento más grande de la matriz Banco de preguntas de Likou n.° 215 C# Puntero doble Dificultad media

objetivo de aprendizaje:

¡Continuaré actualizando mis ideas únicas de algoritmos, con la esperanza de traerles una expansión de pensamiento diferente!
Si lo encuentra útil, por favor, siga y apoye!
Su aliento es lo que me mantiene en marcha!
! ! !

Banco de preguntas de Likou Pregunta 215 Enlace oficial

Contenido de aprendizaje:

K-ésimo elemento más grande en una matriz

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

Ejemplo 1:

Entrada: [3,2,1,5,6,4] y k = 2
Salida: 5
Ejemplo 2:

Entrada: [3,2,3,1,2,4,5,5,6] y k = 4
Salida: 4

提示：

1 <= k <= nums.length <= 104
-104 <= nums[i] <= 104

Fuente: LeetCode
Enlace: https://leetcode-cn.com/problems/kth-largest-element-in-an-array

tiempo de estudio:

2022.1.27

---

Salida de aprendizaje:

idea uno

ordenación rápida

Ideas para resolver problemas
Use la ordenación rápida para ordenar la matriz y luego obtenga el valor de la posición de la matriz correspondiente de acuerdo con el número más grande

1. Primero, recordemos la idea del algoritmo de clasificación rápida. Primero, hay dos punteros a la izquierda y a la derecha, y luego una dirección base apunta a la dirección 0. Luego, el puntero izquierdo se mueve a la derecha y el puntero derecho se mueve a la izquierda. La primera es mover el puntero derecho hacia la izquierda. Si el valor del puntero derecho es menor que el valor de la dirección base, mueva el puntero izquierdo. El puntero izquierdo se mueve hacia la derecha.Si el valor del puntero izquierdo es mayor que el valor de la dirección base en este momento, entonces se intercambia el valor al que apuntan los punteros izquierdo y derecho. Hasta que los dos punteros se encuentran, se completa una clasificación. El lugar donde se encuentran los dos punteros es la nueva dirección base, y la dirección base apunta a la nueva dirección base.
2. Después de completar la operación 1, el lado izquierdo de la dirección base es el valor menor que la dirección base, y el lado derecho es el valor mayor que la dirección base
3. Luego clasificamos el lado izquierdo de la dirección base como una nueva matriz. El que está a la derecha de la dirección base se ordena como una nueva matriz. Luego repita el proceso de 123, podemos obtener una matriz ordenada
4. Luego devolvemos la posición en la matriz correspondiente al k-ésimo valor más grande que queremos

public class Solution {
    
    
    public int FindKthLargest(int[] nums, int k) {
    
    
        QuickSort(nums,0,nums.Length-1);//快速排序
        return nums[nums.Length-k];
    }

    void QuickSort(int[] nums, int begin, int end)
    {
    
    
        if(begin>=end)return; //如果长度为1 或者小于1 那就没有快速排序的必要
        int temp=nums[begin];  //暂存begin位置的值
        int index=begin;  //暂存begin的值
        int left=begin;  //左边的值  左指针
        int right=end;   //右边的值   右指针
        while(begin<end){
    
            //一直循环到左边指针和右边指针相遇
            if(nums[end]>=temp&& begin < end){
    
          //右指针找到一个比begin指针小的值
                end--;
                continue;
            }
            if(nums[begin]<=temp&& begin < end){
    
        //左指针找到一个比begin指针大的值
                begin++;
                continue;
            }
            //到这里 左指针已经找到比begin指针大的值  右指针也找到比begin指针小的值
            //所以 交换左右指针的值 达到目的 
            //让比begin指针大的值全去右边 比begin指针小的值全去左边
            int cur=nums[end];
            nums[end]=nums[begin];
            nums[begin]=cur;
        }
		
		//while循环完 则左右指针相遇
		//则把begin暂存的值和现在左右指针的位置的值进行交换即可
        nums[index]=nums[end];
        nums[end]=temp;
		
		//现在end位置就是中间点，小于end，就是比end指向的值小。 大于end就是比end指向的值大
        QuickSort(nums,left,end-1);  //继续排end左边的数组
        QuickSort(nums,begin+1,right);   //继续排end右边的数组

    }
}

idea dos

Optimización de clasificación rápida

Ideas para resolver problemas

1. Primero, recordemos la idea del algoritmo de clasificación rápida. Primero, hay dos punteros a la izquierda y a la derecha, y luego una dirección base apunta a la dirección 0. Luego, el puntero izquierdo se mueve a la derecha y el puntero derecho se mueve a la izquierda. La primera es mover el puntero derecho hacia la izquierda. Si el valor del puntero derecho es menor que el valor de la dirección base, mueva el puntero izquierdo. El puntero izquierdo se mueve hacia la derecha.Si el valor del puntero izquierdo es mayor que el valor de la dirección base en este momento, entonces se intercambia el valor al que apuntan los punteros izquierdo y derecho. Hasta que los dos punteros se encuentran, se completa una clasificación. El lugar donde se encuentran los dos punteros es la nueva dirección base, y la dirección base apunta a la nueva dirección base.
2. Después de completar la operación 1, el lado izquierdo de la dirección base es el valor menor que la dirección base, y el lado derecho es el valor mayor que la dirección base
3. Entonces, ¿necesitamos ordenar toda la matriz y luego sacar el valor más grande correspondiente?
4. No es necesario, solo necesitamos que la dirección base sea exactamente el valor de índice del tamaño correspondiente, por ejemplo, queremos el segundo valor más grande. Luego, después de la operación 1, la nueva dirección base que obtenemos es exactamente la posición más grande que queremos. Entonces, el lado izquierdo de esta posición es más pequeño que él, y el lado derecho es más grande que él. Entonces, no necesitamos ordenar el resto. Porque esta dirección base es lo que estamos buscando
5. Si la nueva dirección base que obtenemos al ordenar por 1 es más pequeña que el índice que queremos, entonces solo necesitamos ordenar el lado derecho. Si la nueva dirección base resultante es más grande que el índice que queremos, solo tenemos que ordenar el lado izquierdo. Luego continúe clasificando el resto, luego obtenga la nueva dirección base y continúe juzgando.
6. De esta forma, podemos ahorrarnos muchos cálculos innecesarios.

public class Solution {
    
    
    public int FindKthLargest(int[] nums, int k) {
    
    
        k = nums.Length - k;  //找到我们想要的第k大的数据应该在排序完数组的位置
        int l = 0, h = nums.Length - 1;
        while (l < h) {
    
    
            //找到现在排序完的中点位置
            int j = QuickSort(nums, l, h);
            
            if (j == k) {
    
                //如果中点就是我们想要的位置就对了
                break;
            } else if (j < k) {
    
         //如果中点比目标位置小，那就只需要将中点右边的继续排就行了
                l = j + 1; 
            } else {
    
                //如果中点比目标位置大，那就只需要将中点左边的继续排就行了
                h = j - 1;
            }
        }
        return nums[k];
    }


    int QuickSort(int[] nums, int begin, int end)
    {
    
    
        if(begin>=end)return end; //如果长度为1 或者小于1 那就没有快速排序的必要
        int temp=nums[begin];  //暂存begin位置的值
        int index=begin;  //暂存begin的值
        int left=begin;  //左边的值  左指针
        int right=end;   //右边的值   右指针
        while(begin<end){
    
            //一直循环到左边指针和右边指针相遇
            if(nums[end]>=temp&& begin < end){
    
          //右指针找到一个比begin指针小的值
                end--;
                continue;
            }
            if(nums[begin]<=temp&& begin < end){
    
        //左指针找到一个比begin指针大的值
                begin++;
                continue;
            }
            //到这里 左指针已经找到比begin指针大的值  右指针也找到比begin指针小的值
            //所以 交换左右指针的值 达到目的 
            //让比begin指针大的值全去右边 比begin指针小的值全去左边
            int cur=nums[end];
            nums[end]=nums[begin];
            nums[begin]=cur;
        }
		
		//while循环完 则左右指针相遇
		//则把begin暂存的值和现在左右指针的位置的值进行交换即可
        nums[index]=nums[end];
        nums[end]=temp;
		
        return end;


    }
}

idea tres

ordenar en montón

Autor: conejillo de indias Xiaohuihui
Los derechos de autor pertenecen al autor. Para reimpresiones comerciales, comuníquese con el autor para obtener autorización, y para reimpresiones no comerciales, indique la fuente.