[Preguntas diarias sobre el algoritmo de scratching (8)] La longitud de la última palabra|Reorganizar la cadena

---

1. La longitud de la última palabra

haz clic en mí directamente ~

Idea 1: atravesar de atrás hacia adelante

• Recorra de atrás hacia adelante, primero encuentre la última letra y luego continúe recorriendo hacia adelante hasta que encuentre un espacio, simplemente devuelva la longitud.
• Los detalles son los siguientes:
• Si es un espacio que se recorre de atrás hacia adelante, simplemente sáltelo.
• De lo contrario, comience a contar directamente, comenzando desde la última letra, después del cálculo, definitivamente encontrará un espacio o la posición inicial de la cadena, es decir, la posición del subíndice 0, solo devuelva la longitud.

El código específico es el siguiente:

class Solution {
    
    
public:
//思路：从后往前遍历，先找到最后一个字母，然后继续往前遍历，直到遇到空格，返回长度即可。
    int lengthOfLastWord(string s) 
    {
    
    
        //情况1：
        //如果从后开始是空格，那就跳过
        int end = s.size() -1;
        while(s[end]==' ')
            --end;
        
        //此时遇到了最后一个单词的最后一个字母
        int len = 0;
        while(end>=0 && s[end]!=' ')
        {
    
    
            ++len;
            --end;
        }
        return len;
    }
};

时间复杂度O(n)，空间复杂度O(1)

Idea 2:

Solo mira esta idea, no recomendable.

• La situación general es la misma, pero hay una diferencia.
• Sabemos que debe haber un espacio entre cada dos palabras, entonces podemos hacer esto:
• Recorriendo de atrás hacia adelante, si la primera iposición es un carácter y la primera i-1posición es un espacio, significa que ila posición es la primera letra de la última palabra, solo deténgase en este momento.
• Sin embargo, se encuentra impotente ante la siguiente situación:
• ¿Qué sucede si solo hay una palabra y ningún otro espacio? Tomaremos la iniciativa de agregar un espacio al comienzo de la cadena.
• Antes de agregar un espacio, debe mover la cadena hacia atrás un poco como un todo.
• Por ejemplo Hello, se convierte Hello

eso es todo.

El código específico es el siguiente:

class Solution {
    
    
public:

    int lengthOfLastWord(string s) 
    {
    
    
        int len = 0;
        int flag = 0;

        //手动在后面开一个空间，再向后挪动数据。
        //然后在0位置处加一个'\0'
        s.push_back(' ');
        for(int i = s.size()-1;i>0;--i)
        {
    
    
            s[i] = s[i-1];
        }
        s[0] = ' ';
        for(int i = s.size()-1;i>=0;--i)
        {
    
    
            //如果一开始就是空格，跳过即可，直到遇到字母。
            //计算完最后一个单词的长度后，后面肯定是空格
            if(isalpha(s[i]))
            {
    
    
                ++len;
                if(s[i-1] == ' ')
                    break;
            }
        }
        return len;
    }
};

时间复杂度O(n),空间复杂度O(1)

2. Reorganizar cadenas

haz clic en mí directamente ~

tren de pensamiento

• Para cualquier conjunto de datos, como

45670213
codeleet

• Lo que tenemos que hacer es:
• Coloque el carácter c correspondiente al subíndice 4 en la posición del subíndice 4 de una nueva cadena.

Está terminado.

El proceso es el siguiente:

El código específico es el siguiente:

//思路，顺序表（indices）中的第i个元素是多少，就放到对应的ret的ret[indices[i]]的位置上，这个位置就放s[i]
//比如s[0]的字符c，对应的indices[0] = 4，那就将字符'c'放入到ret的第4个下标位置。
//时间复杂度O(N),空间复杂度O(N)
    string restoreString(string s, vector<int>& indices) 
    {
    
    
        //首次开辟s.size()大小的空间,初始化成任何字符均可。
        string ret(s.size(),'a');
        for(int j =0; j < s.size(); ++j)
        {
    
    
            ret[indices[j]] = s[j];
        }
        return ret;
    }
};

Aviso:

Aquí string ret(s.size(),'a');
es para inicializar una clase de cadena ret, dado el espacio de s.size() La

sobrecarga específica es como la anterior, y los siguientes caracteres se pueden inicializar a lo que sea.

时间复杂度:O(n)，遍历字符串的长度个字符，空间复杂度O(n)，需要新开辟n大小的空间。