Notas de estudio de algoritmos (C++): clasificación y búsqueda

Notas de estudio de algoritmos (C++): clasificación y búsqueda

para ordenar

La clasificación está integrada en el algoritmo en C++, y se puede invocar escribiendo sort.El valor predeterminado es la clasificación ascendente de tipo int, y el método de clasificación Comparar se puede definir de acuerdo con las necesidades.

---

A continuación se muestra un ejemplo de uso.

Tema:
Ingrese el nombre y el puntaje del estudiante, y espere generar el nombre y el puntaje del estudiante en orden descendente o ascendente. Cuando los puntajes de los estudiantes sean los mismos, espere que el estudiante que ingresó primero salga primero.

Entrada:
el número de estudiantes en la primera línea n
el método de clasificación de la segunda línea (0 en orden descendente, 1 en orden ascendente)
y las siguientes n líneas son: nombre + espacio + puntaje

Salida (n líneas):
el contenido de cada línea es: (ordenado por el método especificado) nombre + espacio + puntaje

Nota:
la clasificación predeterminada es el orden ascendente de tipo Int.
En esta pregunta, dado que el nombre, la calificación y el orden de entrada deben guardarse juntos, la estructura Estudiante está encapsulada y se debe usar la función Comparar definida por uno mismo.

# include <cstdio>
# include <iostream>
# include <algorithm>
# include <string>

using namespace std;

struct Student{
    
    
	string name;
	int score;
	int order;
};

// increasing, type 1
bool AscendingCompare(Student a, Student b){
    
    
	if (a.score == b.score){
    
    
		return a.order < b.order;
	}
	else{
    
    
		return a.score < b.score;
	}
}

// decreasing, type 0
bool DescendingCompare(Student a, Student b){
    
    
	if (a.score == b.score){
    
    
		return a.order < b.order;
	}
	else{
    
    
		return a.score > b.score;
	}
}

int main(){
    
    
	// total number of student and compare method
	int number, type;
	cin >> number >> type;
	Student arr[number];
	// load name, score and order
	for (int i=0; i<number; ++i){
    
    
		cin >> arr[i].name;
		cin >> arr[i].score;
		arr[i].order = i;
	}
	// compare with appointed method
	if(type){
    
    
		sort(arr, arr+number, AscendingCompare);
	}
	else{
    
    
		sort(arr, arr+number, DescendingCompare);
	}
	// output
	for (int i=0;i<number; ++i){
    
    
		cout << arr[i].name << " " << arr[i].score << endl;
	}
	
	
	return 0;
}

Ejemplo:

---

buscar

Uno de los significados de ordenar en la sección anterior es ayudar a las personas a buscar de manera más eficiente. Las secuencias ordenadas pueden acelerar la eficiencia de recuperación sin comparar elementos uno por uno. Esto es muy obvio cuando se busca varias veces en la misma secuencia.

Con respecto a la búsqueda, aquí presentamos la estrategia de búsqueda binaria.

// binary search

# include <cstdio>
# include <iostream>
# include <algorithm>

using namespace std;
const int MAXN = 100;

int arr[MAXN];

bool binarySearch(int len, int target){
    
    
	int left = 0;
	int right = len-1;
	while(left <= right){
    
    
		int middle = (left + right) / 2;
		if (arr[middle] < target){
    
    			// drop the left half of arr
			left = middle + 1;
		}
		else if (arr[middle] > target){
    
    		// drop the right half of arr
			right = middle - 1;
		}
		else{
    
    								// find it
			return true;
		}
	}
	return false;
}


int main(){
    
    
	int len;
	int n;
	while(scanf("%d", &len) != EOF){
    
    
		// load data
		for (int i=0; i<len; ++i){
    
    
			cin >> arr[i];
		}
		// sort in Ascending
		sort(arr, arr+len);
		// binary search
		cin >> n;
		int target;
		while (n--){
    
    
			cin >> target;
			if (binarySearch(len, target)){
    
    
				printf("True\n");
			}
			else{
    
    
				printf("False\n");
			}
		}
	}
	return 0;
}