背景
通过对经典编程题练习总结,培养解题思维,锻炼解题能力。
一、题目大纲
1 有效的括号
题目描述
题目:给定一个只包括 ‘(’,‘)’,‘{’,‘}’,‘[’,‘]’ 的字符串 s ,判断字符串是否有效。
1、左括号必须用相同类型的右括号闭合。
2、左括号必须以正确的顺序闭合。
3、每个右括号都有一个对应的相同类型的左括号。
Example:
思路
有效的括号OJ链接
1、遍历字符串,左括号入栈,右括号进行匹配(晚入栈的括号先匹配)
2、注意:数量要匹配,右括号比左括号多时,要单独处理
code (调用自己写的栈接口)
bool isValid(char * s){
ST ps;
STInit(&ps); //初始化栈
while(*s != '\0') //注意是'\0'
{
if( //左括号入栈
(*s == '(')
||(*s == '{')
||(*s == '[')
)
{
STPush(&ps,*s);
}
else //右括号进行匹配
{
//数量不匹配,右括号比左括号多
if(STEmpty(&ps)) //STEmpty返回值为bool 0 -1都为假呀
{
STDestroy(&ps);
return false;
}
//左括号与右括号匹配
if(
((STTop(&ps) == '(')&&(*s == ')'))
||((STTop(&ps) == '{')&&(*s == '}'))
||((STTop(&ps) == '[')&&(*s == ']'))
)
{
STPop(&ps); //匹配成功出栈顶
}
else
{ //否则的话没能匹配到,返回false
STDestroy(&ps);
return false;
}
}
++s;
}
//如果栈为空说明都匹配了 返回true
if(STEmpty(&ps))
{
STDestroy(&ps);
return true;
}
else
{
STDestroy(&ps);
return false;
}
}
2 用队列实现栈
题目描述
题目:请你仅使用两个队列实现一个后入先出(LIFO)的栈,并支持普通栈的全部四种操作(push、top、pop 和 empty)。
实现 MyStack 类:
void push(int x) 将元素 x 压入栈顶。
int pop() 移除并返回栈顶元素。
int top() 返回栈顶元素。
boolean empty() 如果栈是空的,返回 true ;否则,返回 false 。
思路
用队列实现栈
入队列:入不为空的队列,如果两个队列都为空,则可以任意入一个队列
出队列:将不为空的队列中前N-1个元素依次尾插(入)到空队列中,删除剩余元素。
Notice: 入队列在栈上的表现为入栈,通过两个队列入出队列,最终要达到删除栈顶元素的效果。
code:
typedef struct {
Que q1;
Que q2;
} MyStack;
//初始化队列
MyStack* myStackCreate() {
MyStack* stack = (MyStack*)malloc(sizeof(MyStack));
QueueInit(&stack->q1);
QueueInit(&stack->q2);
return stack;
}
void myStackPush(MyStack* obj, int x) {
//往不为空的队列中尾插数据
if(QueueEmpty(&obj->q1))
{
QueuePush(&obj->q2, x);
}
else
{
QueuePush(&obj->q1, x);
}
}
int myStackPop(MyStack* obj) {
Que* empty = &obj->q1;
Que* nonempty = &obj->q2;
if(QueueEmpty(&obj->q2))
{
nonempty = &obj->q1;
empty = &obj->q2;
}
while(QueueSize(nonempty)-1>0)
{
//将非空队列中的前size-1个元素插你到空队列中
QueuePush(empty,QueueFront(nonempty));
QueuePop(nonempty);
}
int topval = QueueFront(nonempty);
QueuePop(nonempty); //返回栈顶元素,pop最后一个数据
return topval;
}
int myStackTop(MyStack* obj) {
//返回不为空队列的栈顶元素
if(!QueueEmpty(&obj->q1))
{
return QueueBack(&obj->q1);
}
else
{
return QueueBack(&obj->q2);
}
}
bool myStackEmpty(MyStack* obj) {
return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}
void myStackFree(MyStack* obj) {
//先释放两个子队列,然后释放整体
QueueDestroy(&obj->q1);
QueueDestroy(&obj->q2);
free(obj);
}
/**
* Your MyStack struct will be instantiated and called as such:
* MyStack* obj = myStackCreate();
* myStackPush(obj, x);
* int param_2 = myStackPop(obj);
* int param_3 = myStackTop(obj);
* bool param_4 = myStackEmpty(obj);
* myStackFree(obj);
*/
3 用栈实现队列
题目描述
题目:请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(push、pop、peek、empty):
实现 MyQueue 类:
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空,返回 true ;否则,返回 false
说明:
你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque(双端队列)来模拟一个栈,只要是标准的栈操作即可。
思路
用栈实现队列
code
typedef struct {
ST pushst;
ST popst;
} MyQueue;
MyQueue* myQueueCreate() {
MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue)); //初始化队列,其实就是初始化两个栈,因为是用栈实现队列
STInit(&q->pushst);
STInit(&q->popst);
return q;
}
void myQueuePush(MyQueue* obj, int x) {
STPush(&obj->pushst, x); //注意STPush()第一个形参是一个指针,所以这里的pushst要取地址传入
}
int myQueuePeek(MyQueue* obj) {
if(STEmpty(&obj->popst))
{
//如果popst栈不为空,倒数据到popst栈
while(!STEmpty(&obj->pushst))
{
STPush(&obj->popst,STTop(&obj->pushst)); //将pushst栈中的数据倒入到popst栈中
STPop(&obj->pushst);
}
}
//放回栈顶元素
return STTop(&obj->popst);
}
int myQueuePop(MyQueue* obj) {
if(STEmpty(&obj->popst))
{
while(!STEmpty(&obj->pushst))
{
STPush(&obj->popst,STTop(&obj->pushst));
STPop(&obj->pushst);
}
}
int front = myQueuePeek(obj); //po栈顶元素之气先保存栈顶元素到front
STPop(&obj->popst);
return front; //返回栈顶元素
}
bool myQueueEmpty(MyQueue* obj) {
return STEmpty(&obj->pushst)&&STEmpty(&obj->popst); //popst与pushst栈均为空才说明这个队列为空
}
void myQueueFree(MyQueue* obj) {
STDestroy(&obj->popst); //先局部释放然后整体释放
STDestroy(&obj->pushst);
free(obj);
}
/**
* Your MyQueue struct will be instantiated and called as such:
* MyQueue* obj = myQueueCreate();
* myQueuePush(obj, x);
* int param_2 = myQueuePop(obj);
* int param_3 = myQueuePeek(obj);
* bool param_4 = myQueueEmpty(obj);
* myQueueFree(obj);
*/
4 循环队列
题目描述
题目:设计你的循环队列实现。 循环队列是一种线性数据结构,其操作表现基于 FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里,一旦一个队列满了,我们就不能插入下一个元素,即使在队列前面仍有空间。但是使用循环队列,我们能使用这些空间去存储新的值。
实现 MyQueue 类:
MyCircularQueue(k): 构造器,设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空,返回 -1 。
Rear: 获取队尾元素。如果队列为空,返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。
说明:
所有的值都在 0 至 1000 的范围内;
操作数将在 1 至 1000 的范围内;
请不要使用内置的队列库。
思路
循环队列
code
typedef struct {
int* arr;
int k;
int front;
int rear;
} MyCircularQueue;
//初始化
MyCircularQueue* myCircularQueueCreate(int k) {
MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
obj->arr = (int*)malloc(sizeof(int)*(k+1));
obj->k = k;
obj->front = 0;
obj->rear = 0;
return obj;
}
//判断是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
return obj->front == obj->rear;
}
//判断是否为满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
return (obj->rear+1)%(obj->k+1) == obj->front;
}
//队尾插入数据
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
if(myCircularQueueIsFull(obj))
return false;
obj->arr[obj->rear] = value;//每尾插一个数据,尾指针rear往后移动一位。
++(obj->rear);
obj->rear%=obj->k+1;
return true;
}
//删除数据
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
return false;
++(obj->front); //每删除一个数据,头指针front向后移动一位。
obj->front %= obj->k+1;
return true;
}
//找到队首元素
int myCircularQueueFront(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
return -1;
return obj->arr[obj->front];
}
//找到队尾元素
int myCircularQueueRear(MyCircularQueue* obj) {
if(myCircularQueueIsEmpty(obj))
{
return -1;
}
else
{ //当数组为满的时候要进行单独处理
return obj->arr[(obj->rear + obj->k)%(obj->k+1)];
}
}
void myCircularQueueFree(MyCircularQueue* obj) {
free(obj->arr);
free(obj);
}
/**
* Your MyCircularQueue struct will be instantiated and called as such:
* MyCircularQueue* obj = myCircularQueueCreate(k);
* bool param_1 = myCircularQueueEnQueue(obj, value);
* bool param_2 = myCircularQueueDeQueue(obj);
* int param_3 = myCircularQueueFront(obj);
* int param_4 = myCircularQueueRear(obj);
* bool param_5 = myCircularQueueIsEmpty(obj);
* bool param_6 = myCircularQueueIsFull(obj);
* myCircularQueueFree(obj);
*/