Estructura de datos----Estructura--Estructura lineal--Cadena

Estructura de datos ---- estructura - estructura lineal - cadena

1. Cómo definir una cadena

La primera:

char* str1="Hello"

El segundo tipo:

char  str2[]="Hello";

la diferencia

1. La zona es diferente

//str1在常量区

//str2在这里的写法是在栈区

2. Si el elemento se puede cambiar.

//str1中的元素不可改

//str2中的元素可改

//第一种
//用下标进行修改
    
//第二种
//用strcpy函数进行修改

3. Si se pueden cambiar str1 y str2

//str1可改，它是指针可以改变指向
str1="Haha";

//str2不可改，它是地址不可改

4. Diferentes tamaños

sizeof(str1);//4个字节

sizeof(str2);//6个字节

2. Preguntas sobre el reemplazo de cuerdas

tema:

Reemplace los espacios de una cadena suficientemente larga con win, la cadena original es "solo los amantes quedan vivos" (esta cadena es infinitamente larga con un espacio infinito después del carácter 'e')

método:

1. Solicite violentamente un nuevo espacio cuyo tamaño sea strlen (cadena) + espacio adicional para usar

​ Atravesar la cadena original y guardarla en win en el nuevo espacio cuando encuentra un espacio, o guardar el carácter original en el nuevo espacio

​ Complejidad temporal O(n) Complejidad espacial O(n)

2. Corte y empalme de hilos

La función de corte es strtok.

​ La función conectada es strcat

​ Complejidad temporal O(n) Complejidad espacial O(n)

3. Complejidad del tiempo de pila O (n) Complejidad del espacio O (n)

4. Complejidad del tiempo de cola O (n) Complejidad del espacio O (n)

5. Violencia (optimización)

1. Defina dos punteros en el espacio original.

2. Uno apunta a la posición del último carácter y el otro apunta a la posición después de reemplazar el espacio (esta posición es strlen (cadena) + espacio adicional para usar)

3. Los dos punteros avanzan al mismo tiempo y, cuando se encuentra un espacio, lo reemplazan con win en la posición señalada por el último puntero (primero reemplaza n y luego el puntero avanza, y así sucesivamente hasta que se completa el reemplazo). ), y si no es un espacio, apunte el puntero anterior a Reemplazar el contenido de la posición con la posición señalada por el siguiente puntero, y luego los dos punteros avanzan juntos hasta que el siguiente del puntero anterior no sea un elemento en esta cadena.

​ Complejidad temporal O(n) Complejidad espacial O(1)

3. Acerca de la inversión de palabras en cadena

tema:

Invierta una cadena de caracteres "sólo los amantes quedan vivos" en "sólo los amantes vivos"

método:

1. matriz

Defina dos punteros, uno apunta al primer carácter que no es un espacio desde la parte posterior hacia el frente de la cadena, y el otro apunta a esto al principio y luego avanza. Cuando se encuentra un espacio, coloque todos los caracteres en este párrafo En la nueva matriz, el siguiente puntero llega a la posición del primer puntero, y luego encuentra el primer carácter que no está un espacio hacia adelante nuevamente desde esta posición, y luego otro también apunta aquí, y luego atraviesa adelante, y cuando se encuentre un espacio, coloque todos los caracteres de este párrafo en una nueva matriz

​ Los dos punteros han ido repitiendo el proceso anterior hasta que el puntero anterior apunte al primer elemento de la cadena, para ver si los dos punteros apuntan al mismo elemento, si no, coloque todos los caracteres de este párrafo en un nuevo array y complételo al revés. En caso afirmativo, se realiza la inversión.

​ Complejidad temporal O(n) Complejidad espacial O(n)

2. inversión

​ Primero invierta toda la cadena, luego invierta cada palabra

​ Complejidad temporal O(n) Complejidad espacial O(1)

3. Lista enlazada

Almacene cada palabra en una lista vinculada y luego use el método de interpolación de encabezados de adelante hacia atrás para convertir la lista vinculada en una nueva lista vinculada

​ Complejidad temporal O(n) Complejidad espacial O(n)

4. pila

(1) Una pila + matriz

Coloque la cadena en la pila, si encuentra un espacio, coloque los elementos en la pila y colóquelos en la matriz (la matriz ha solicitado espacio con anticipación)

Si la cadena está vacía, coloque los elementos en la pila y colóquelos en la matriz.

​ Complejidad temporal O(n) Complejidad espacial O(n)

(2) Dos pilas

​ Coloque todas las cadenas en la primera pila, luego coloque los elementos de la primera pila en la segunda pila,

Si se encuentra un espacio, reemplace el elemento en la segunda pila con la posición correspondiente de la cadena original (aquí habrá un puntero para reemplazar el carácter, y cada vez que se reemplaza un carácter, el puntero retrocederá un bit, El puntero inicialmente apunta al primer elemento de la cadena) y luego se extraen los elementos de la primera pila.

​ Hasta que no haya elementos en la primera pila, si hay elementos en la segunda pila, todos los elementos de la segunda pila aparecerán y se reemplazarán en las posiciones correspondientes en la cadena original.

​ Complejidad temporal O(n) Complejidad espacial O(n)

5. Corte y empalme de hilos

Una versión mejorada del problema de inversión de palabras en cadenas (la URL de esta pregunta es https://leetcode.cn/problems/reverse-words-in-a-string/)

tema:

Dada una cadena s, invierta el orden de las palabras en la cadena .

Una palabra es una cadena que consta de caracteres que no son espacios en blanco. Separe las palabrass de la cadena con al menos un espacio .

Devuelve la cadena resultante con las palabras invertidas y unidas con un solo espacio.

**Nota:** sPuede haber espacios al principio, al final o varios espacios entre las palabras de la cadena de entrada. En la cadena de resultado devuelta, las palabras solo deben estar separadas por un espacio y no contener espacios adicionales.

El código para el método de inversión aplicado al análisis anterior es el siguiente:

//这里的代码是c++语言下的
class Solution {
public:
    string reverseWords(string s) {
    //删除首尾的空格
    s.erase(0, s.find_first_not_of(" "));
    s.erase(s.find_last_not_of(" ")+1);
    
    //整体进行翻转
    int begin1 = 0;
    int end1 = s.size() - 1;
    while (begin1 < end1) {
        char a = s[begin1];
        s[begin1] = s[end1];
        s[end1] = a;
        begin1++;
        end1--;
    }
    
    //每个单词进行翻转
    int begin = 0;
    int end = 0;
    char* p = &s[0];
    int index = 0;
    int bool1 = 1;
    int bool2 = 1;
    int bool3 = 0;
    int bool4 = 0;
    int bool5 = 0;
    while (*p != '\0') {
        if (*p != ' ' && *(p + 1) != ' '&&bool1%2==1) {
            begin = index;
            bool1++;
            bool3 = 1;
        }
        if ((*p == ' ' && *(p - 1) != ' ' && bool1 % 2 == 0)) {
            end = index - 1;
            bool1++;
            bool4 = 1;
        }
        
        if (*(p + 1) == '\0' && *p !=' ' && bool1 % 2 == 0) {
            end = index;
            bool1++;
            bool4 = 1;
        }
        int begin2 = begin;
        int end2 = end;
        while (begin2 < end2&& bool3&& bool4) {
            bool5 = 1;
            char a = s[begin2];
            s[begin2] = s[end2];
            s[end2] = a;
            begin2++;
            end2--;
        }
        if (bool5) {
            bool3 = 0;
            bool4 = 0;
            bool5 = 0;
        }
        p++;
        index++;
    }
    //去除字符串间的空格
    string::iterator ite = s.begin();
    while (ite!=s.end()) {
        if (*ite == ' ' && *(ite + 1) == ' ') {
            ite=s.erase(ite);
        }
        else if (*ite == ' ' && *(ite - 1) == ' ') {
            ite = s.erase(ite);
        }
        else {
            ite++;
        }

    }
    return s;
    }
};

4. Una pregunta sobre cuerdas

tema:

​ Una cadena "abcdefgh", ingrese a k, mueva los primeros k caracteres al final de la cadena y el orden de los k caracteres movidos permanece sin cambios, cuando k es igual a 3, la cadena movida es "defghabc"

método:

1. Cola/Pila

2. Lista/matriz vinculada

3. Corte y empalme de hilos

4. Inversión

Primero invierta la cadena completa, luego invierta los caracteres 0 ~ k-1, incluidos los caracteres entre ellos, e invierta el k ~ último carácter, incluidos los caracteres entre ellos.

​ Complejidad temporal O(n) Complejidad espacial O(1)

Cinco Preguntas sobre la búsqueda de cadenas

1. Resuma los siguientes cuatro problemas de búsqueda principales según la experiencia.

1. Encuentra caracteres que cumplan una determinada condición en una cadena.

2. Encuentre una cadena/alguna cadena que cumpla las condiciones en una cadena

3. Encuentre una determinada cadena/alguna cadena en varias cadenas

4. Encuentre algunas cadenas comunes que cumplan las condiciones en las dos cadenas.

1. La primera pregunta de la pregunta de búsqueda.

tema:

Encuentra el primer carácter que aparece solo una vez.

resolver:

1. Cola + contador

2.mapa + recorrido

3.hash+recorrido

2. El segundo mayor problema de búsqueda

tema:

Encuentra la subcadena palindrómica más larga en una cadena

resolver:

1. Determine si una cadena es una subcadena palíndromo, desconéctela del medio, luego voltee la cadena hacia atrás y luego compare las dos cadenas para ver si son iguales.

2. Luego compara la longitud.

3. El algoritmo KMP en el segundo mayor problema de búsqueda.

1. El papel del algoritmo KMP

El algoritmo KMP se utiliza para encontrar la posición (posición del primer elemento) de una cadena (cadena) en otra cadena (cadena principal)

2. Implementación del KMP

1. Primero defina una matriz Siguiente para almacenar la cadena de prefijo y la cadena de sufijo de cada elemento de la cadena con la misma longitud máxima.

1. Defina dos variables adyacentes como subíndices.

2. Si el elemento donde se encuentra el último subíndice es el mismo que el elemento encontrado por el subíndice anterior que actúa como subíndice en la siguiente matriz, entonces el valor de la siguiente matriz donde se encuentra este elemento es el valor del elemento anterior. subíndice encontrado en el valor del siguiente elemento de la matriz +1

3. Si no son iguales y el valor del subíndice del elemento anterior que se encuentra en la siguiente matriz es 0, entonces el valor de la matriz siguiente donde está subíndice este elemento es 0

4. Si no son iguales y el valor del subíndice del elemento anterior que se encuentra en la siguiente matriz no es 0, entonces la variable anterior pasa a ser el valor -1 que se encuentra en el subíndice donde se ubica como subíndice en la siguiente matriz, y luego repita la operación 2 hasta que se encuentre, o no se haya encontrado el nodo principal de la subcadena encontrada.

2. Haga coincidir la subcadena con la cadena principal.

1. Si los elementos de la subcadena son los mismos que los elementos de la cadena principal, continúe comparando

2. Si el elemento de la subcadena no es el mismo que el elemento de la cadena principal, entonces el elemento de la subcadena se convierte en el elemento de la subcadena señalado por la siguiente matriz del subíndice del elemento antes del subíndice del elemento actual, si el elemento principal de la subcadena es alcanzado No es igual, la cadena coincidente comienza desde el principio

3. Hasta que finalice el recorrido de la subcadena o se atraviese la cadena principal, finalice

3. El código KMP es el siguiente

//此代码是使用c写的
#include<stdio.h>
#include<stdlib.h>

int* GetNext(const char* match) {
    
    
	int* pNext = (int*)malloc(sizeof(int) * strlen(match));
	pNext[0] = 0;
	int i = 1;
	int j = i - 1;
	while (i < strlen(match)) {
    
    
		if (match[i] == match[pNext[j]]) {
    
    
			pNext[i] = pNext[j] + 1;
			i++;
			j = i - 1;
		}
		else if (pNext[j] == 0) {
    
    
			pNext[i] = 0;
			i++;
			j = i - 1;
		}
		else {
    
    
			j = pNext[j] - 1;
		}
	}
	return pNext;
} 

int KMP(const char* src, const char* match) {
    
    
	if (src == NULL || match == NULL) return -1;
	//获得Next数组
	int* pNext = GetNext(match);

	//匹配
	int i = 0;
	int j = 0;
	while (i < strlen(match) && j < strlen(src)) {
    
    
		if (src[i] == match[j]) {
    
    
			i++;
			j++;
		}
		else {
    
    
			//匹配串跳转
			if (j == 0) {
    
    
				i++;
			}
			else {
    
    
				j = pNext[j - 1];
			}
		}
	}
	if (j == strlen(match))
	{
    
    
		return i - j;
	}
	else {
    
    
		return -1;
	}
}

int main() {
    
    
	printf("%d\n", KMP("abcabcgweu3abcabcdusabcabcsfh", "abcabc"));//测试样例
	return 0;
}

4. El algoritmo del domingo en el segundo mayor problema de búsqueda.

1. El papel del algoritmo dominical

El algoritmo KMP se utiliza para encontrar la posición (posición del primer elemento) de una cadena (cadena) en otra cadena (cadena principal)

2. Realización del domingo

1. Primero solicite una matriz de tipo inr y luego con 256 espacios (debido a que hay 256 caracteres en total, puede definir una matriz con una longitud limitada)

1. Después de solicitar la matriz, asigne todos los elementos de la matriz a -1

2. Recorra la subcadena una vez, asigne valores a los elementos de la matriz y guarde el subíndice de cada elemento en la subcadena que aparece por primera vez de derecha a izquierda en la subcadena.

2. Haga coincidir la subcadena con la cadena principal.

1. Defina dos variables para atravesar la cadena principal y la subcadena, y una variable de etiqueta para encontrar el subíndice cada vez que la cadena principal coincida con la subcadena.

2. Haga coincidir la cadena principal con la subcadena. Si son iguales, continúe con la siguiente. Si no son iguales, la subcadena comienza desde el principio y la cadena principal es el subíndice de k más la longitud de la subcadena y luego restando los caracteres obtenidos actualmente. El valor que actúa como subíndice en la siguiente matriz comienza

3. Hasta que finalice el recorrido de la subcadena o se atraviese la cadena principal, finalice

3. El código del domingo es el siguiente.

//此代码是使用c++写的
#include <iostream>
#include <string>
using namespace std;

int Next[256];//申请一个Next数组，用来存匹配串中各个元素的下标

void funzhi(string a) {//初始化Next数组
	for (int i = 0; i < a.size(); i++) {
		Next[a[i]] = i;
	}
}
int peidui(string zhu, string pi) {//进行配对
	int i = 0;//主串
	int j = 0;//匹配串
	int length = pi.size();//匹配串长度
	int k = 0;//用来标记匹配串在主串中首元素的下标
	while (1) {
		
		if (zhu[i] != pi[j]) {//如果主串元素与匹配串元素不相同
			
			if (k + length >= zhu.size()) {//如果超出了主串的范围
				return -1;
			}
			k = k + length - Next[zhu[k + length]];
			
			i = k;
			j = 0;
		}
		else {//如果主串元素与匹配串元素相同
			i++;
			j++;
		}
		
		if (j >= pi.size()) {//如果子串遍历完了
			return k;
		}

	}
}