[Leetcode -844. Compara cadenas que contienen retrocesos -1047. Elimina todos los duplicados adyacentes en cadenas]

Leetcode -844 Compara cadenas que contienen espacios de retroceso

Tema : Dadas dos cadenas s y t, cuando se ingresan respectivamente en un editor de texto en blanco, si son iguales, devuelve verdadero. # representa el carácter de retroceso.
Nota: Si ingresa un carácter de retroceso para un texto vacío, el texto seguirá estando vacío.

Ejemplo 1:
Entrada: s = “ab#c”, t = “ad#c”
Salida: verdadero
Explicación: s y t se convertirán en “ac”.

Ejemplo 2:
Entrada: s = “ab##”, t = “c#d#”
Salida: verdadero
Explicación: s y t se convertirán en “”.

Ejemplo 3:
Entrada: s = “a#c”, t = “b”
Salida: falso
Explicación: s se convertirá en “c”, pero t seguirá siendo “b”.

Consejo:
1 <= s.length, t.length <= 200
s y t solo contienen letras minúsculas y el carácter '#'

Idea : cree dos pilas para almacenar los caracteres válidos de la cadena s y la cadena t respectivamente. Si es un carácter de retroceso, sáquelo de la pila; de lo contrario, empújelo hacia la pila; finalmente compare las dos pilas para ver si Ellos son iguales;

		bool backspaceCompare(char* s, char* t)
		{
		    // 创建 s 字符串和 t 字符串的栈，存放有效的字符
		    char stackS[201] = "\0";
		    char stackT[201] = "\0";
		
		    //topS 和 topT 记录栈顶
		    int topS = 0, topT = 0;
		    for (int i = 0; i < strlen(s); i++)
		    {
		        //如果是退格符，并且不是第一个字符，就出栈，并补个'\0'
		        if (s[i] == '#')
		        {
		            if (topS)
		            {
		                topS--;
		                stackS[topS] = '\0';
		            }
		        }
		
		        //否则，就入栈
		        else
		        {
		            stackS[topS++] = s[i];
		        }
		
		    }
		
		    //同理，栈T也和栈S一样 
		    for (int i = 0; i < strlen(t); i++)
		    {
		        if (t[i] == '#')
		        {
		            if (topT)
		            {
		                topT--;
		                stackT[topT] = '\0';
		            }
		        }
		
		        else
		        {
		            stackT[topT++] = t[i];
		        }
		
		    }
		
		    //最后比较栈S和栈T是否相同
		    return (bool)!strcmp(stackS, stackT);
		}

Leetcode -1047 Elimina todos los duplicados adyacentes en una cadena

Pregunta : Dada una cadena S compuesta de letras minúsculas, la operación de eliminación de duplicados seleccionará dos letras adyacentes e idénticas y las eliminará.

Repita la operación de deduplicación en S hasta que ya no sea posible realizar más deduplicación.
Devuelve la cadena final una vez completadas todas las operaciones de deduplicación. Se garantiza que la respuesta será única.

Ejemplo:
Entrada: "abbaca"
Salida: "ca"
Explicación:
Por ejemplo, en "abbaca", podemos eliminar "bb" Dado que las dos letras son adyacentes e idénticas, este es el único duplicado que se puede eliminar en este momento. Luego obtenemos la cadena "aaca", de la cual sólo "aa" puede realizar la eliminación de duplicados, por lo que la cadena final es "ca".

Consejo:
1 <= S.length <= 20000
S consta únicamente de letras minúsculas en inglés.

Idea : abra una pila con un tamaño de s y agregue uno a la longitud de la cadena; si es la primera posición o el elemento superior de la pila no es igual al carácter de la cadena actual, empújelo hacia la pila; de lo contrario, sáquelo de la pila y agregue '\0'; agregue también '\0' al final;

		char* removeDuplicates(char* s)
		{
		    //开辟 s 字符串长度加一的空间大小
		    char* Stack = (char*)malloc(sizeof(char) * (strlen(s) + 1));
		
		    //pos为当前栈的位置
		    int pos = 0;
		
		    //遍历字符串
		    for (int i = 0; i < strlen(s); i++)
		    {
		        //如果是第一个位置或者栈顶元素不等于当前字符，就入栈
		        if (pos == 0 || Stack[pos - 1] != s[i])
		        {
		            Stack[pos++] = s[i];
		        }
		
		        //否则，就出栈，并补上'\0'
		        else
		        {
		            pos--;
		            Stack[pos] = '\0';
		        }
		    }
		
		    //在最后加上'\0'
		    Stack[pos] = '\0';
		    return Stack;
		}