¿Qué puedes aprender?
① Complejidad temporal ② Complejidad espacial ③ Qué es la estabilidad del algoritmo ④ Ideas e implementación de código de cinco algoritmos clásicos
Algoritmo de clasificación de aprendizaje (implementado por código js)
Los algoritmos de clasificación son muy comunes en el trabajo y el estudio. Hoy en día, el js principal implementa la clasificación por burbujas, la clasificación por inserción, la clasificación por selección, la clasificación por fusión y la clasificación rápida.
Nota:
① La complejidad del espacio generalmente se refiere a la complejidad del espacio adicional.
② Estabilidad del algoritmo: Suponga que hay varios registros con la misma clave en la secuencia de registros que se van a ordenar. Si se ordena, el orden relativo de estos registros permanece sin cambios. El algoritmo es se dice que es estable.
Ordenamiento de burbuja
Complejidad temporal promedio: O (n2) Complejidad espacial O (1) Muy estable
function bubbleSort(arr){
for (let i = 0; i < arr.length; i++) {
for (let j = arr.length; j > i; j--) {
if(arr[j]<arr[j-1]){
//两值互换
arr[j]=arr[j]^arr[j-1]
arr[j-1]=arr[j-1]^arr[j]
arr[j]=arr[j]^arr[j-1]
}
}
}
return arr
}
Sentimiento de uno mismo: comprensión simple, alta complejidad en el tiempo
Tipo de inserción
Complejidad temporal promedio: O (n2) Complejidad espacial O (1) Muy estable
function insertSort(arr){
for (let index = 1; i < arr.length; index++) {
for (let i = index-1; i >=0&&arr[i]>arr[i+1]; i--) {
arr[i] = arr[i]^arr[j]
arr[j] = arr[i]^arr[j]
arr[i] = arr[i]^arr[j]
}
}
return arr
}
Sentimiento propio: comprensión simple, alta complejidad, puede consultar el proceso de clasificación de las cartas
Seleccionar ordenar
Complejidad de tiempo promedio: O (n2) Complejidad espacial O (1) Inestable
function selectSort(arr){
for (let i= 0; i < arr.length-1; i++) {
let min = i
for(let j = i+1;j<arr.length;j++){
if(arr[j]<arr[min]){
min = j
}
}
arr[i] = arr[i]^arr[min]
arr[min]= arr[min]^arr[i]
arr[i] = arr[i]^arr[min]
}
return arr
}
Sentimiento propio: cada vez que completa un ciclo, encontrará un mínimo relativo
Combinar ordenación
Complejidad de tiempo promedio: O (nlog2n) La complejidad del espacio O (n) es muy estable
function mergeSort(arr,l,r){
if(l == r){
return [arr[l]]
}
let mid = parseInt((l+r)/2)
let arrleft = mergeSort(arr,l,mid)
let arrRight = mergeSort(arr,mid+1,r)
return merge(arrleft,arrRight)
}
function merge(arrleft,arrRight){
let i = 0
let j = 0
let temp =[]
while(i<arrleft.length||j<arrRight.length){
if(arrleft[i]<arrRight[j]||j>=arrRight.length){
temp.push(arrleft[i])
i++
}else if(arrleft[i]>=arrRight[j]||i>=arrleft.length){
temp.push(arrRight[j])
j++
}
}
return temp
}
Sentimiento propio: primero divida la matriz de forma continua, divídala en la unidad más pequeña y luego fusione (ordene al fusionar). Utilice "punteros duales" para agregar a la nueva matriz en comparación.
Ordenación rápida
Complejidad de tiempo promedio: O (nlog2n) Complejidad espacial O (nlog2n) inestable
function quickSort(arr,l,r){
if(l==r){
return;
}
let i = l
let j = r
let key = i
while(i<j){
while(i<j&&arr[i]<arr[key]){
i++
}
while(i<j&&arr[j]>=arr[key]){
j--
}
if(i!=j){
arr[i] = arr[i]^arr[j]
arr[j] = arr[j]^arr[i]
arr[i] = arr[i]^arr[j]
i++;
j--
}
}
quickSort(arr,l,i)
quickSort(arr,j+1,r)
}
//简单测试
let arr1 = [8,2,6,3,4,7,9]
quickSort(arr1,0,arr1.length-1)
console.log(arr1)
Sentimiento propio: la clasificación rápida se basa en un cierto valor de la matriz, ordenando y luego recursivamente a la unidad más pequeña, el orden saldrá naturalmente
Dirección de descarga de código
Tienes que hacerlo tu mismo
agradecer
Si sientes que es útil para tu trabajo de estudio, compártelo con quienes lo necesiten, o dale me gusta y anímalo, gracias por
tu apoyo. Puedes agregar un favorito y continuaré actualizándolo. . .
