pilha escova LeetCode do título

As perguntas da entrevista 03.04. da pilha para a equipe

MyQueue implementar uma classe que implementou uma pilha com duas filas.
.
.
Exemplo:
.
MyQueue MyQueue nova fila de novo = ();
.
Queue.push; queue.push (2); queue.peek (); // retorna uma queue.pop (); // (1.)
Devolução uma fila. empty (); // retorna falso
.
Nota:
.
você só pode usar as operações de pilha padrão - ou seja, apenas o impulso para cima, auge / pop de topo, o tamanho está vazio e
a operação é legal. O idioma que você está usando pode não suportar pilha. Você pode usar a lista ou o deque (deque) para simular uma pilha, enquanto uma lata operação pilha padrão.
Partindo do princípio de que todas as operações são válidos (por exemplo, não uma fila vazia ou espiada operação chamada pop).
.
Fonte: estadia botão (LeetCode) "entrevista de Ouro programador (sexta edição)"
Dificuldade: Simple
link: https: //leetcode-cn.com/problems/implement-queue-using-stacks-lcci
copyright do botão colar de rede todos. reimpressão comercial entre em contato com a reimpressão autorizado oficial, não-comercial por favor, indicar a fonte.

Ideia: estrutura de dados para excluir um fila final (isto é, a equipa), a outra extremidade da inserção (isto é, fila de espera).
Perguntas feitas duas espaço de pilha, em seguida, fazemos um limite para única operação pop, apenas uma operação de push, imitando a equipe ea fila equipe de operações.
pop empilhar chamamos frontStack, empurre a pilha chamamos rearStack, a seguinte implementação de código detalhou 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. perguntas da entrevista com fila de duas pilhas

Uma fila é implementado com duas pilhas. A seguinte declaração fila, implementar as suas duas funções appendTail e deleteHead
, foram completados na extremidade do inserto de fila e número inteiro número inteiro de eliminação na cabeça da fila função. (Se não houver um elemento de fila, a operação retorna deleteHead -1)

Fonte: botão estadia (LeetCode) "ganha a oferta (Segunda Edição)"
Dificuldade: Simple
link: https: //leetcode-cn.com/problems/yong-liang-ge-zhan-shi-xian-dui-lie- lcof
o botão do colarinho copyright toda a rede. reimpressão comercial entre em contato com a reimpressão autorizado oficial, não-comercial por favor, indicar a fonte.

Idéias: Nós definimos dois espaço de pilha, traseira e frontal, respectivamente, como um dos melhores do ponteiro de pilha. Nós definimos um espaço de pilha traseira é apenas empurrar para a equipe, enquanto a frente pop somente a pilha é uma equipe a fim de utilizar duas pilhas para imitar a fila.
As seguintes áreas-chave de código foram dadas um comentário.

#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. exclui todas as entradas duplicadas adjacentes em uma string

Edição em: março 2020 22:10:39 17

Corda S é dada pelas letras minúsculas, duplicados excluir e selecciona duas cartas idênticas adjacentes a, e removê-los.

Realizada no S duplica repetidamente eliminação, não pode continuar até excluído.

Retorna a string final após a conclusão de todas as duplicatas exclusão. A única garantia resposta.

exemplo:

Enter: "abbaca" Saída: "ca" interpretação: por exemplo, em "abbaca", podemos remover a "bb"
como as duas letras adjacentes e o mesmo, este é o único duplica este tempo pode executar operações de exclusão. Depois de obter a string "AACA", que tem apenas "aa"
pode executar duplicatas de exclusão, de modo a cadeia final é "ca".

dicas:

1 <= s.length <= 20000 S apenas pelas letras minúsculas.

Fonte: botão estadia (LeetCode)
Dificuldade: Simple
link: https: //leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string
protegidas por copyright dedução de todas as redes. reimpressão comercial entre em contato com a reimpressão autorizado oficial, não-comercial por favor, indicar a fonte.

1 Inicialmente eu pensei que a idéia é muito simples. Manter uma pilha, continuar a ler dados na pilha, os dados da pilha, se houver uma repetição de dados pilha adjacente.
Sentimento: mas terminou um pouco insatisfeito, ele viu um lembrete de um irmão mais velho, epifania. Sentindo sob o código otimizado.
2 idéias: podemos usar o índice para percorrer sempre menor que a extremidade superior da pilha como o valor alvo S apontando para a natureza deste espaço de memória como um espaço de pilha.
A razão é simples início da expansão espaço de pilha e travessia de velocidade é a mesma, mas a forma como vamos continuar a empurrar para fora da pilha, o que torna a expansão da pilha velocidade travessia não pode nunca exceder a velocidade.
O chamado travessia é uma coleção de todos os elementos são acessados novamente. Isso topo só pode manipular os dados que visitamos, mas não podemos fazer sem dados operacionais não visitados, então isso não afeta a travessia.

//最初的版本
#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;
}