LeetCode pila cepillo de título

preguntas de la entrevista. 03.04 de la pila para el equipo

MyQueue implementar una clase que implementa una pila con dos colas.
.
.
Ejemplo:
.
MyQueue MyQueue nueva nueva cola = ();
.
Queue.push; queue.push (2); queue.peek (); // Devuelve 1 queue.pop (); // (1.)
Devuelve 1 de colas. vacía (); // devuelve falso
.
Nota:
.
sólo puede utilizar las operaciones de la pila estándar - es decir, sólo el empuje para arriba, ojeada / pop desde la parte superior, el tamaño está vacío y
la operación es legal. El idioma que está utilizando no sea compatible con la pila. Puede utilizar la lista o la deque (deque) para simular una pila, siempre y cuando una operación de pila lata estándar.
Suponiendo que todas las operaciones son válidos (por ejemplo, no una cola vacía o la operación peek llamado pop).
.
Fuente: estancia botón (LeetCode) "entrevista programador de oro (Sexta Edición)"
dificultad: simple
enlace: https: //leetcode-cn.com/problems/implement-queue-using-stacks-lcci
los derechos de autor del botón del cuello de la red todos. reimpresión comercial póngase en contacto con la reimpresión autorizada oficial, no comercial por favor indique la fuente.

Idea: Para eliminar cola de un extremo (es decir, el equipo), el otro extremo de la inserción (es decir, en cola) estructura de datos.
Preguntas hechas dos espacio de pila, entonces hacemos un límite a la única operación pop, solamente una operación de empuje, imitando el equipo y el equipo de operaciones de la cola.
pop apilar hemos llamado frontStack, empuje la pila nombramos rearStack, el siguiente código de aplicación ha detallado notas.

#define MAXSIZE 30
#define OK 1
#define ERR 0

typedef struct Stack
{
    int top;
    int data[MAXSIZE];
}Stack, * StackPtr;

typedef struct {
    Stack* rearStack;
    Stack* frontStack; 
} MyQueue, * MyQueuePtr;

bool myQueueEmpty(MyQueue* obj);

/** Initialize your data structure here. */

MyQueue* myQueueCreate() {
    
    //初始化队列空间
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    if (!obj)
        goto err1;
    memset(obj, 0, sizeof(MyQueue));

    //初始化push栈空间
    obj->rearStack = (Stack*)malloc(sizeof(Stack));
    if (!obj->rearStack)
        goto err2;
    memset(obj->rearStack, 0, sizeof(Stack));
    obj->rearStack->top = -1;

    //初始化pop栈空间
    obj->frontStack = (Stack*)malloc(sizeof(Stack));
    if (!obj->frontStack)
        goto err3;
    memset(obj->frontStack, 0, sizeof(Stack));
    obj->frontStack->top = -1;


    return obj;


    //集中处理malloc失败的情况。
err3:
    if (obj->frontStack)
        free(obj->frontStack);
err2:
    if (obj->rearStack)
        free(obj->rearStack);
err1:
    if (obj)
        free(obj);

    return NULL;
}

/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {   
        //判断是否队满
    if (obj->rearStack->top == MAXSIZE - 1)
        return;

    //将pop栈的数据转移到push栈，若没有则直接退出
    while (obj->frontStack->top != -1)
    {
        obj->rearStack->data[++obj->rearStack->top] = obj->frontStack->data[obj->frontStack->top--];
    }
    
    //将数据push
    obj->rearStack->data[++obj->rearStack->top] = x;
}

/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
    //判断队列是否为空
    if (myQueueEmpty(obj))
        return ERR;
    
    //将push栈的数据转移到pop栈，若没有则直接退出
    while (obj->rearStack->top != -1)
    {
        obj->frontStack->data[++obj->frontStack->top] = obj->rearStack->data[obj->rearStack->top--];
    }

    //pop出去，并返回。
    return obj->frontStack->data[obj->frontStack->top--];
}

/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
    if (myQueueEmpty(obj))
        return ERR;

    //判断现在数据在哪个栈空间。
    if (obj->frontStack->top == -1)
    {
        return obj->rearStack->data[0]; //在rear栈中，此时rear指向rear栈的top次，front指向0处
    }
    else
    {
        return obj->frontStack->data[obj->frontStack->top]; //front栈中，直接返回即可
    }
}

/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
    return (obj->frontStack->top == -1 && obj->rearStack->top == -1) ? true : false;
}

//逐一free内存
void myQueueFree(MyQueue* obj) {
    free(obj->frontStack);
    free(obj->rearStack);
    free(obj);
}

09. preguntas de la entrevista con dos pilas de espera

Una cola se implementa con dos pilas. La siguiente cola de declaración, implementar sus dos funciones appendTail y deleteHead
, se completaron en el extremo de la inserción de cola y número entero número entero de eliminación en la cabeza de la función de cola. (Si no hay ningún elemento de la cola, deleteHead operación vuelve -1)

Fuente: Botón de estancia (LeetCode) "gana la oferta (Segunda Edición)"
dificultad: simple
enlace: https: //leetcode-cn.com/problems/yong-liang-ge-zhan-shi-xian-dui-lie- lcof
el botón del cuello de autor toda la red. reimpresión comercial póngase en contacto con la reimpresión autorizada oficial, no comercial por favor indique la fuente.

Ideas: Definimos dos espacio de pila, trasera y frontal, respectivamente, como una de la parte superior del puntero de pila. Se define un espacio de pila trasera solamente se empuja en el equipo, mientras que el frente sólo se saca la pila es un equipo con el fin de utilizar dos pilas para imitar la cola.
Las siguientes áreas clave de código se les dio un comentario.

#define MAXSIZE 300
#define REAR 1
#define FRONT 0

typedef struct CQueue
{
    //设置2个数组，即2个栈空间，分别定义2个宏REAR，FRONT现性的指明。
	int data[2][MAXSIZE];
	int front, rear;
} CQueue;


CQueue* cQueueCreate() {
	
	CQueue* obj = (CQueue*)malloc(sizeof(CQueue));
	if (!obj)
		return NULL;
	memset(obj, 0, sizeof(CQueue));
	obj->rear = obj->front = -1;	//rear和front分别为一个栈空间的栈顶指针,初始化指向栈底。

	return obj;
}

void cQueueAppendTail(CQueue* obj, int value) {
	//判断是否满队
	if (obj->rear == MAXSIZE - 1 || obj->front == MAXSIZE - 1)
		return;

	//如果数据在front栈，则转移数据到rear栈中
	while (obj->front != -1)
	{
		obj->data[REAR][++obj->rear] = obj->data[FRONT][obj->front--];
	}
	obj->data[REAR][++obj->rear] = value;
}

int cQueueDeleteHead(CQueue* obj) {
	if (obj->rear == obj->front)
		return -1;

	//如果数据在rear栈，则转移数据到front栈中
	while (obj->rear != -1)
		obj->data[FRONT][++obj->front] = obj->data[REAR][obj->rear--];

	return obj->data[FRONT][obj->front--];
}

void cQueueFree(CQueue* obj) {
	free(obj);
}

1047. elimina todas las entradas duplicadas adyacentes en una cadena

Edición en: March 2020 22:10:39 17

Cadena S está dado por las letras minúsculas, duplicados de borrado y selecciona dos cartas idénticas adyacentes a, y eliminarlos.

Realizado en el S duplica varias veces su eliminación, no puede continuar hasta que se eliminan.

Devuelve la cadena final después de la finalización de todos los duplicados eliminación. La única garantía de respuesta.

Ejemplo:

Intro: "abbaca" Salida: "ca" interpretación: por ejemplo, en "abbaca", podemos eliminar el "BB",
ya que las dos letras adyacentes y el mismo, esta es la única duplica este tiempo puede llevar a cabo operaciones de borrado. Después de recibir la cadena "AACA", que sólo tiene "AA"
puede realizar duplicados eliminar, por lo que la cadena final es "ca".

consejos:

1 <= s.length <= 20000 S sólo por las letras minúsculas.

Fuente: Botón de estancia (LeetCode)
Dificultad: Fácil
enlace: https: //leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string
propiedad de la deducción de todas las redes. reimpresión comercial póngase en contacto con la reimpresión autorizada oficial, no comercial por favor indique la fuente.

1 Al principio pensé que la idea es muy simple. Mantener una pila, continuar para leer datos en la pila, los datos de la pila si hay una repetición de pila de datos adyacente.
Sentimiento: pero terminó un poco insatisfecho, vio un recordatorio de un hermano mayor, epifanía. Sintiendo bajo el código optimizado.
2 Ideas: podemos utilizar el índice para recorrer siempre menor que el extremo superior de la pila que el valor objetivo S que apunta a la naturaleza de este espacio de memoria como un espacio de pila.
La razón es simple comienzo de la expansión espacio de pila y transversal velocidad es la misma, pero la forma en que continuará impulsando fuera de la pila, lo que hace que la expansión de la velocidad de recorrido de pila nunca puede superar la velocidad.
El llamado de recorrido es una colección de todos se accede de nuevo los elementos. Que la parte superior sólo puede manipular los datos que hemos visitado, pero no podemos prescindir de los datos operativos no visitados, así que esto no afecta el recorrido.

//最初的版本
#define MAXSIZE 20000

char* removeDuplicates(char* S) {
    //设立栈
    int top = -1;
    char data[MAXSIZE] = { 0 };

    for (int i = 0; S[i]; i++)
    {
        //判断栈是否满。加1是为了预留'\0'字符
        if (top + 1 == MAXSIZE - 1)
            return NULL;

        data[++top] = S[i];     //字符串s字符逐一入栈
        if (top > 0 && data[top] == data[top - 1])  //查找是否有重复，若有出栈
            top -= 2;
        if(top >= 0)
            S[top] = data[top];
    }
    S[top + 1] = '\0';

    return S;
}

//优化后的C代码

char* removeDuplicates(char* S) {
    int top = 0;
    for (int read = 0; S[read]; read++, top++)
    {
        S[top] = S[read];     //字符串s字符逐一入栈
        if (top > 0 && S[top] == S[top - 1])  //查找是否有重复，若有出栈
            top -= 2;
    }
    S[top] = '\0';

    return S;
}