¿Cómo encontrar los 10 números más grandes o más pequeños en datos en Excel?

Cómo encontrar los 10 números más grandes o más pequeños en datos en Excel:

Por ejemplo, si tienes todos estos datos en la columna A, entonces:

= LARGE(A:A,N) ?--El enésimo valor máximo

=SMALL(A:A,N)--El enésimo valor mínimo.

Datos en columnas A1:A100

Entrada B1

= *** all(a$1:a$100,fila ( a1))

Complete 10 filas para obtener los 10 números más pequeños

Entrada C1

=large(a$1：a$100, fila( a1))

Complete 10 filas y obtenga los 10 números más grandes Cómo encontrar el valor mínimo en múltiples datos en Excel

=Min(K5, L5, M5, S5) Cómo encontrarlo. ¿El número más pequeño en una matriz?

Programación ¿Cómo encontrar los valores máximo y mínimo en una tabla de Excel?

La determinación de encontrar el valor máximo en excel se puede lograr mediante la función max() o min().

Primero seleccione el rango de datos a consultar. El proceso de operación específico tiene las dos situaciones siguientes, a saber:

Situación 1. El rango de datos es continuo

1 Para las celdas de destino con contenido de rango de datos continuo, ingrese el siguiente contenido respectivamente:

=max (a1:z10) significa el valor máximo desde la celda a1 hasta la celda z10;

=min (a1:z10) representa el valor mínimo desde la celda a1 hasta la celda z10

2. De esta forma, el contenido de la celda objetivo se dará como "a1; :z10" Los valores máximo y mínimo del área.

Escenario 2. El rango de datos no es continuo

1. Si el rango de datos no es continuo, puede ingresar en la celda de destino

=max ( posición de celda 1 , posición de celda 2, ..., posición de celda n)

o

=min (posición de celda 1, posición de celda 2, .... .., celda posición n);

2. De esta forma, el contenido de la celda objetivo dará los valores máximo y mínimo del área "a1:z10". Esto dará los valores máximo y mínimo del rango "a1:z10" en el contenido de la celda de destino. Cómo seleccionar el n más grande o el más pequeño del N más grande

Primero, asumimos que n y N son accesibles en memoria, es decir, N se puede cargar en la memoria a la vez y almacenarse en la forma de una matriz (si debe existir en forma de lista enlazada, probablemente sea otro problema difícil). Comenzando con el caso más simple, si n = 1, entonces no hay duda de que se deben realizar N-1 comparaciones para obtener el número más grande, y iterar a través de N números también es simple. ¿Qué pasa si n=2? Por supuesto, puede atravesar directamente N matrices dos veces y obtener el número más grande max1 por primera vez. Sin embargo, cuando encuentre el segundo número más grande max2 por segunda vez, debe determinar el subíndice extraído de los N elementos cada vez. No es un subíndice igual a max1, lo que aumentará considerablemente el número de comparaciones. Hay una solución para esto. Puede dividir la matriz N en dos partes, usar max1 como punto de división, luego atravesar los dos números más grandes en las dos partes y luego tomar una de las dos partes para obtener max2. También puede resolver el problema atravesándolo una vez. Primero mantenga los dos elementos max1 y max2 (max1 = max2), tome uno de los números en N y compárelo con max1 primero si es mayor que Max1 (debe ser). mayor que max2), reemplácelo directamente max1; de lo contrario, compárelo con max2 para determinar si se reemplaza max2.

Utilizando un método similar, también se pueden procesar n = 2, 3 y 4. La complejidad temporal de este algoritmo es O (nN). A medida que n se hace cada vez más grande (no puede exceder N/2, de lo contrario se convierte en un problema por pares de encontrar N-n números mínimos), el algoritmo se vuelve cada vez menos eficiente. Pero cuando n es relativamente pequeño (es difícil decir qué tan pequeño), este algoritmo es simple y no tiene pérdidas del sistema como llamadas recursivas, por lo que la eficiencia real debería ser muy buena. Montón: ¿Qué algoritmo se utiliza cuando n es grande? Primero, analicemos el algoritmo anterior. Cuando obtenemos un nuevo número m de N, debemos compararlo con max1, max2 y max3max n en secuencia hasta encontrar un máximo x menor que m. Use m para reemplazar max x. Comparación de promedios El grado es n/2. ¿Se puede lograr el reemplazo con menos comparaciones? El método más intuitivo es utilizar el montón, que también se promueve mediante artículos en línea. El montón tiene algunas ventajas: 1. Es un árbol binario completo, la profundidad del árbol es la más pequeña entre los árboles binarios del mismo nodo y la eficiencia de mantenimiento es alta 2. Se puede implementar a través de una matriz; el nodo padre p y los nodos secundarios izquierdo y derecho l y r son. La relación de subíndice de matriz entre es s[l] = 2*s[p] +1 y s[r] = 2*s[p] + 2. Además, la matriz puede ser aleatoria y la eficiencia es muy alta. 3. La complejidad temporal de la operación de extracción del montón, es decir, tomarla desde la parte superior del montón y mantener el montón, es O (logn), donde n es el tamaño del montón. Específico para nuestro problema, ¿cómo implementarlo específicamente? Primero abra un área de matriz A de tamaño n, lea n números de N y complételos en A, y luego mantenga A como un montón pequeño superior (es decir, A [0] en la parte superior del montón almacena el número más pequeño en A ). Luego tome el siguiente número de N, es decir, el n + 1º número m, compare m con la parte superior del montón A [0], si m <= A [0], descarte m directamente; de ​​lo contrario, m debe reemplazarse con A[ 0] en m. Pero en este momento, es posible que el atributo del montón de A se haya destruido y el montón debe volver a mantenerse: comenzando desde A [0], compare A [0] con los dos nodos secundarios izquierdo y derecho respectivamente (es importante Tenga en cuenta que aquí se requieren dos comparaciones) Para determinar el valor máximo, lo compararé con el árbol perdedor más adelante. Si A [0] es más pequeño que los nodos secundarios izquierdo y derecho, se puede garantizar el atributo de montón y no existe). debe continuar; de lo contrario, si el nodo izquierdo (derecho) es el más grande, intercambie y compare A [0] con el nodo izquierdo (derecho) y continúe manteniendo el subárbol izquierdo (derecho). Ese es el principio básico de la clasificación del montón, el único truco es mantener un montón superior pequeño en lugar de uno grande. Si no lo entiendes, piénsalo por un momento. La complejidad temporal de mantener un montón es O (logn) y la complejidad general es O (Nlogn). Por lo tanto, cuando n es lo suficientemente grande, la eficiencia del montón es definitivamente mayor que la O (nN) anterior. Por supuesto, formar directamente un montón con N números y luego extraer la parte superior del montón n veces puede obtener el resultado. La complejidad es O (nlogN), que será mucho más rápido cuando n no sea particularmente pequeño. Pero para los datos en línea, no hay forma. Por ejemplo, N no se puede cargar en la memoria, e incluso una secuencia no sabe cuántos N hay. Loser Tree: ¿Existen otros algoritmos? Permítanme empezar con el árbol perdedor. Quizás algunas personas no comprendan el árbol de perdedores. De hecho, es un método de clasificación externa más clásico, es decir, hay archivos ordenados x y se combinan en una secuencia ordenada. La idea del árbol perdedor parece un poco complicada a primera vista, pero en realidad sirve para reducir el número de comparaciones. Primero, presentemos brevemente el árbol perdedor: los nodos hoja del árbol perdedor son nodos de datos y luego se agrupan en pares (si el número total de nodos no es una potencia de 2, se puede crear una estructura de árbol similar al árbol completo). se usará), y los nodos internos se usan para registrar la información en el árbol de perdedores. El ganador en los subárboles izquierdo y derecho (tenga en cuenta que el perdedor se registra), el ganador se pasa hacia arriba y se continúa comparando hasta el final. al nodo raíz. Si nuestro ganador es el menor de los dos números, el nodo raíz registrará el perdedor de la última comparación, que es el segundo más pequeño de todos los nodos hoja, y el número más pequeño se registrará en una variable separada. Cabe señalar aquí que el nodo interno no solo registra el valor del perdedor, sino que también registra el nodo hoja correspondiente. Si el árbol se forma utilizando una lista enlazada, entonces los nodos internos deben tener punteros a los nodos hoja.

Hay un pequeño truco aquí, es decir, el nodo interno solo registra el nodo hoja correspondiente al perdedor y puede acceder indirectamente al valor específico cuando sea necesario (este método es muy útil cuando se usan matrices para implementar el árbol perdedor, lo cual haré discutiremos más adelante). La clave está aquí: al generar el valor mínimo, debe cambiar el nodo hoja correspondiente al valor mínimo a un nuevo número (o cambiarlo a infinito al fusionar archivos para indicar que el archivo se ha leído). A continuación, mantenga el árbol de perdedores, conéctese desde los nodos de hoja actualizados para compararlos con los nodos internos, actualice los perdedores y continúe la comparación hacia arriba con los ganadores. Dado que el nodo de actualización ocupa el nodo hoja del mínimo anterior, su ruta hasta el nodo raíz es exactamente la misma que la ruta del mínimo anterior. El perdedor registrado por el nodo interno, aunque se denomina perdedor, es el número más pequeño en su subárbol. En otras palabras, siempre que se compare al ganador con el perdedor, es el número más pequeño en el subárbol (esto es un poco confuso, si no lo entiendes, deberías leerlo en un libro, es más fácil de entender). comparando la imagen). Nota: También puede construir un árbol perdedor directamente en N, pero el árbol perdedor no se puede mantener incrementalmente utilizando una matriz como un montón. Cuando cambia el número de nodos hoja, es necesario reconstruir completamente el árbol. Para facilitar la comparación del rendimiento de los montones y los árboles de entrada, a continuación se analizan los montones y los árboles de entrada construidos con n números. En resumen, cuando se mantiene un árbol perdedor, el número de comparaciones es logn+1. A diferencia del montón, el árbol perdedor se mantiene de abajo hacia arriba y solo necesita compararse con el nodo perdedor una vez por cada nivel. El montón se mantiene de arriba a abajo. Cada nivel siguiente debe compararse con los nodos secundarios izquierdo y derecho, que deben compararse dos veces. Desde este punto de vista, el árbol perdedor es mejor que el montón. Sin embargo, cabe señalar que cada mantenimiento del árbol de entrada debe realizarse desde el nodo hoja hasta el nodo raíz, y es imposible detenerse a mitad de camino, mientras que el mantenimiento del montón se puede detener en medio de una capa sin continuar hacia abajo; . De esta manera, aunque el número de comparaciones requeridas para cada nivel del árbol de entrada es el doble que el del montón, el número de niveles por los que ha pasado el montón es menor que el del árbol de entrada. ¿Cuánto menos y qué método es más eficaz en promedio? No sé sobre esto, es un poco complicado de analizar. Cualquiera que esté interesado puede probarlo y discutirlo más tarde. Pero al menos esto muestra que el montón puede no ser óptimo. Específico para nuestra pregunta. Después de leer un nuevo número m de N, compárelo con w. Si es menor que w, deséchelo directamente. De lo contrario, reemplace el valor del nodo hoja donde está w con my luego mantenga el árbol perdedor. Esto se hace en secuencia hasta que se atraviesa N y los n números retenidos en el árbol perdedor son los n números más grandes en N. La complejidad temporal del método de clasificación rápida también es O (Nlogn): la clasificación rápida no es ajena a todos. La idea principal es encontrar un nodo de eje, intercambiar la matriz en dos partes, una parte menor o igual al eje, la otra parte mayor o igual al eje, y luego procesar las dos partes de forma recursiva. La complejidad del tiempo promedio es O (NlogN). Podemos inspirarnos en esto. Si elegimos el eje de coordenadas de modo que el número j de la mayor parte del intercambio sea n, ¿no completaríamos también la tarea de encontrar el mayor número n entre N números? Por supuesto, la selección de ejes no es necesariamente tan precisa. Se puede analizar así, si jn, entonces los n números más grandes deben estar entre estos j números, entonces el problema es encontrar los n números más grandes entre estos j números; de lo contrario, si j

Para el método de clasificación rápida, es un poco más problemático: lea en lotes, asumiendo que hay M números, y luego seleccione los n números más grandes de los M números y guárdelos en caché hasta que todos los N números se procesen en lotes, y luego Los n Los números almacenados en caché en cada lote se combinan, se realiza otra clasificación rápida y finalmente se obtienen los n números más grandes. Durante la operación, si hay demasiados cachés, se pueden fusionar continuamente varios cachés y solo se conservan los n números más grandes de estos cachés. Dado que la complejidad del tiempo similar a la de clasificación rápida es O (N), es muy probable que este enfoque de procesamiento por lotes y fusión supere a los montones y los árboles de entrada. Por supuesto, ocupa más espacio en la memoria. Para resumir: he pensado mucho en esta pregunta, pero creo que hay algunas áreas en las que puedo profundizar más: 1. ¿Qué es mejor, los montones o los árboles de entrada? Puede analizarse teóricamente o compararse experimentalmente. Quizás algunas personas encuentren esto aburrido; 2. ¿Existe un algoritmo de aproximación o un algoritmo probabilístico para resolver este problema? Realmente no estoy familiarizado con este aspecto. Si alguien tiene alguna idea, hágamelo saber. Si hay algún error u omisión en el análisis, por favor dímelo, no tengo miedo de pasar vergüenza, jaja. Finalmente, recuerde siempre que la complejidad del tiempo no es igual al tiempo de ejecución real, y un algoritmo O(logN) con un factor constante grande puede ser mucho más lento que un algoritmo O(N) con un factor constante pequeño. Por lo tanto, los valores precisos de n y N, así como la calidad de la implementación de la programación, afectan la eficiencia real. Escriba un programa que ingrese 10 números cualesquiera, encuentre los números más grandes y más pequeños y proporcione las posiciones de los libros más grandes y más pequeños en la matriz

Para i = 1 a 10

Cambiar a

Para i = 0 a 9

Pruébelo

Vaya... también existe la opción Base 1... .... .

Mira, es así, porque definiste Min = s(1) antes de ingresar, y s(1) = 0 en este momento, siempre que ingreses un número positivo después, no ser menor que 0. Debe definir Min como un número grande, por ejemplo, hacer que el resultado Min = 100, para que no haya errores

Escriba un programa vb para ingresar 10 números cualesquiera y encontrar el números más grandes y más pequeños y proporciona la posición del libro más grande y más pequeño en la matriz

Una mejor manera es ordenar, primero registrar la posición original del número en la matriz y luego ordenar para encontrar el. número más grande y más pequeño, y el resultado de la clasificación de salida es más o menos así:

For i = Min To UBound(Vimt) - 1

For j = i + 1 To UBound(Vimt )

ReDim SerAim(i)

If Vimt(i) > Vimt(j) Then 'Esta declaración ordena la matriz de pequeña a grande. Si Vimt(i) < Vimt(j) Entonces 'Esta declaración ordena la matriz de pequeño a grande. El primer número de la matriz es el número más grande

'Tenga en cuenta que solo se pueden usar las dos declaraciones anteriores. ¡Uno de ellos!

Núm = Vimt(i)

Vimt(i) = Vimt(j)

Vimt(j) = Núm

Fin Si

Si tienes alguna duda

Cómo encontrar los mismos datos en dos columnas en Excel

Puedes usar la función Countif

Por ejemplo, para encontrar columnas idénticas AB.

Por ejemplo, para encontrar los mismos datos en la columna AB, ingresa la fórmula en la columna C

=Countif(A:A,B1) y luego desplázate hacia abajo para completar

Si el valor es mayor que 1, significa que los datos actuales en la columna B son los mismos que los datos de la columna A

Cómo encontrar datos redundantes en Excel.

Parece que tu versión no es alta. Si es alta, usa formato condicional, repite el valor y luego filtra. La versión no es alta y la búsqueda de valores duplicados se puede resolver mediante fórmulas.

Para insertar una columna, ingrese if (match(a1,a:a,0)=row(1:1:), "not repetición", "repetida")