HJ26 Clasificación de cadenas ●●

HJ26 Clasificación de cadenas ●●

describir

Escriba un programa para ordenar los caracteres en la cadena de entrada de acuerdo con las siguientes reglas.

Regla 1: las letras en inglés están ordenadas de la A a la Z, sin distinguir entre mayúsculas y minúsculas.

Por ejemplo, entrada: Escriba salida: epTy

Regla 2: Cuando las mayúsculas y minúsculas de la misma letra en inglés existen al mismo tiempo, se ordenarán según el orden de entrada.

Por ejemplo, entrada: BabA salida: aABb

Regla 3: Otros caracteres que no sean letras inglesas permanecen en sus posiciones originales.

Por ejemplo, entrada: By?e salida: Be?y

Rango de datos: la longitud de la cadena de entrada satisface 1 \le n \le 1000 \1≤n≤1000

Introduzca una descripción:

cadena de entrada

Descripción de salida:

cadena de salida

ejemplo

Canción: Un dicho famoso: Mucho ruido y pocas nueces (2012/8). Canción
: A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8).

respuesta

1. Clasificación de cubos

Cuente el orden de aparición de 26 letras y realice un llenado transversal.
Complejidad temporal: O(n)
Complejidad espacial: O(1)

#include <iostream>
#include <string>
#include <vector>
using namespace std;

bool isLetter(char ch){
    
    
    return toupper(ch) <= 'Z' && toupper(ch) >= 'A';
}

void bucketSort(string& str){
    
    
    vector<string> buckets(26, "");
    for(char ch : str){
    
    
        if(isLetter(ch)){
    
    
            buckets[toupper(ch)-'A'].push_back(ch);		// 对26个字母进行记录，有相对顺序
        }
    }
    int str_idx = 0, buck_idx = 0, num_idx = 0;
    while(str_idx < str.length()){
    
    
        if(isLetter(str[str_idx])){
    
    
            if(buck_idx < buckets[num_idx].size()){
    
    		// 填充当前字母
                str[str_idx++] = buckets[num_idx][buck_idx++];	
            }else{
    
    				// 当前字母遍历填充完成，跳到下一个字母
                buck_idx = 0;
                ++num_idx;		
            }
        }else{
    
    
            ++str_idx;			// 非字母位置，跳过
        }
    }    
}

int main(){
    
    
    string str;
    getline(cin, str);
    bucketSort(str);
    cout << str;
    return 0;
}

2. Combinar clasificación

La idea de la clasificación por fusión es juzgar y omitir posiciones que no sean letras.
La complejidad de nlogn requiere espacio adicional y la recursividad se agota cuando los datos son grandes.

#include <iostream>
#include <string>
#include <vector>
using namespace std;

bool isLetter(char ch){
    
    
    return toupper(ch) <= 'Z' && toupper(ch) >= 'A';
}

void mergeSort(string& str, string& sorted, int start, int end){
    
    
    if(start >= end) return;
    int mid = start + (end - start) / 2;
    mergeSort(str, sorted, start, mid);
    mergeSort(str, sorted, mid+1, end);
    int left = start, right = mid+1;
    int idx = start;
    while(idx <= end){
    
    
        if(isLetter(str[left]) == false){
    
    
            ++left;
        }else if(isLetter(str[right]) == false){
    
    
            ++right;
        }else if(isLetter(str[idx]) == false){
    
    
            ++idx;
        }else if(left > mid){
    
    
            sorted[idx++] = str[right++];
        }else if(right > end){
    
    
            sorted[idx++] = str[left++];
        }else if(toupper(str[left]) > toupper(str[right])){
    
    
            sorted[idx++] = str[right++];
        }else if(toupper(str[left]) < toupper(str[right])){
    
    
            sorted[idx++] = str[left++];
        }else{
    
    
            sorted[idx++] = str[left++];
        }
    }
    for(int i = start; i <= end; ++i) str[i] = sorted[i];
}

int main(){
    
    
    string str;
    getline(cin, str);
    string sorted = str;
    mergeSort(str, sorted, 0, str.length()-1);
    cout << str;
    return 0;
}