栈和队列OJ（面试高频题 - 看完包！！！拿捏）

已于 2024-04-19 16:59:56 修改
阅读量668 收藏 20
点赞数 11
分类专栏： 数据结构 文章标签： c语言 数据结构 面试
于 2024-04-19 15:25:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66330442/article/details/137949257
版权

目录

题目一：括号匹配问题（来源）

        题目描述

        题目思路及实现

题目二：用队列实现栈（来源）

        题目描述

        题目思路及实现

题目三：用栈实现队列（来源）

        题目描述

        题目思路及实现

题目四：设计循环队列（来源）

        题目描述

        题目思路及实现

题目一：括号匹配问题（来源）

        题目描述

        给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

        有效字符串需满足：

        1、左括号必须用相同类型的右括号闭合。

        2、左括号必须以正确的顺序闭合。

        3、每个右括号都有一个对应的相同类型的左括号。

        题目思路及实现

        该题是栈的典型应用，满足后进先出的规则（后入栈的前括号将优先与先出现的后括号相匹配）。

        遍历字符串，遇到前括号直接入栈。遇到后括号，判断该后括号与栈顶的前括号是否匹配（若此时栈为空，则字符串无效），若不匹配则字符串无效；若匹配则删除栈顶元素，继续遍历字符串，直到字符串遍历完毕。当字符串遍历完后，检测栈是否为空，若为空，则字符串有效，若不为空，说明有前括号未匹配，字符串无效。

typedef char STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}Stack;

//初始化栈
void StackInit(Stack* pst)
{
	assert(pst);

	pst->a = (STDataType*)malloc(sizeof(STDataType)* 4);
	pst->top = 0;
	pst->capacity = 4;
}

//销毁栈
void StackDestroy(Stack* pst)
{
	assert(pst);

	free(pst->a);
	pst->a = NULL;
	pst->top = 0;
	pst->capacity = 0;
}

//入栈
void StackPush(Stack* pst, STDataType x)
{
	assert(pst);

	if (pst->top == pst->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType)*pst->capacity * 2);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		pst->a = tmp;
		pst->capacity *= 2;
	}
	pst->a[pst->top] = x;
	pst->top++;
}

//检测栈是否为空
bool StackEmpty(Stack* pst)
{
	assert(pst);

	return pst->top == 0;
}

//出栈
void StackPop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));

	pst->top--;
}

//获取栈顶元素
STDataType StackTop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));

	return pst->a[pst->top - 1];
}


/*---以上代码是栈的基本功能实现，以下代码是题解主体部分---*/

bool isValid(char * s)
{
    // 初始化一个栈st，用于存储遇到的打开的括号
    Stack st;
    StackInit(&st);

    // 创建指向当前字符的指针cur
    char* cur = s;

    // 遍历输入字符串s中的每个字符
    while(*cur)
    {
        // 如果当前字符是打开的括号
        if(*cur == '(' || *cur == '{' || *cur == '[')
        {
            // 将其压入栈中
            StackPush(&st, *cur);

            // 移动到下一个字符
            cur++;
        }

        // 否则，如果当前字符是关闭的括号
        else
        {
            // 若栈为空，则说明没有对应的打开括号与之匹配，直接返回false
            if(StackEmpty(&st))
            {
                StackDestroy(&st);
                return false;
            }

            // 获取栈顶元素（即最近进入栈内的打开括号）
            char top = StackTop(&st);

            // 检查栈顶元素与当前关闭括号是否匹配
            if((top == '(' && *cur != ')') ||
               (top == '{' && *cur != '}') ||
               (top == '[' && *cur != ']'))
            {
                // 不匹配，则返回false
                StackDestroy(&st);
                return false;
            }

            else
            {
                // 匹配成功，弹出栈顶元素（即消耗一个括号对）
                StackPop(&st);
                // 移动到下一个字符
                cur++;
            }
        }
    }

    // 遍历结束后，若栈为空，则说明所有括号都已正确匹配，返回true；否则返回false
    bool ret = StackEmpty(&st);
    StackDestroy(&st);
    return ret;
}

        此函数利用了栈这一数据结构的特性：对于任何有效的括号序列，当扫描到一个关闭括号时，栈顶的元素一定是与其相匹配的打开括号。遍历完字符串后，栈应为空，表示所有的打开括号都有相应的关闭括号与之匹配。 

题目二：用队列实现栈（来源）

        题目描述

        请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

        实现 MyStack 类：

        void push(int x) 将元素 x 压入栈顶。

        int pop() 移除并返回栈顶元素。

        int top() 返回栈顶元素。

        boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

        题目思路及实现

        使用两个队列，始终保持一个队列为空。                                                                                       当我们需要进行压栈操作时，将数据压入不为空的队列中（若两个都为空，则随便压入一个队列）。当需要进行出栈操作时，将不为空的队列中的数据导入空队列，仅留下一个数据，这时将这个数据返回并且删除即可。判断栈是否为空，即判断两个队列是否同时为空。

typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QListNode;

typedef struct Queue
{
	QListNode* head;
	QListNode* tail;
}Queue;

//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->head = NULL;
	pq->tail = NULL;
}

//销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq);

	QListNode* cur = pq->head;
	while (cur)
	{
		QListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = NULL;
	pq->tail = NULL;
}

//队尾入队列
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QListNode* newnode = (QListNode*)malloc(sizeof(QListNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

//检测队列是否为空
bool QueueEmpty(Queue* pq)
{
	assert(pq);

	return pq->head == NULL;
}

//队头出队列
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = NULL;
		pq->tail = NULL;
	}
	else
	{
		QListNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}

//获取队列头部元素
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

//获取队列尾部元素
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

//获取队列中有效元素个数
int QueueSize(Queue* pq)
{
	assert(pq);

	QListNode* cur = pq->head;
	int count = 0;
	while (cur)
	{
		count++;
		cur = cur->next;
	}
	return count;
}

/*---以上代码是队列的基本功能实现，以下代码是题解主体部分---*/

// 定义一个结构体MyStack，它包含两个队列q1和q2，用以模拟栈的功能
typedef struct 
{
    Queue q1; // 第一个辅助队列
    Queue q2; // 第二个辅助队列
} MyStack;

// 创建并初始化一个MyStack类型的栈对象
MyStack* myStackCreate() 
{
    MyStack* pst = (MyStack*)malloc(sizeof(MyStack)); // 分配内存空间
    QueueInit(&pst->q1); // 初始化第一个队列
    QueueInit(&pst->q2); // 初始化第二个队列

    return pst; // 返回新创建的栈对象
}

// 将整数x压入栈顶
void myStackPush(MyStack* obj, int x) 
{
    // 判断哪个队列非空，就将元素压入哪个队列
    if (!QueueEmpty(&obj->q1))
    {
        QueuePush(&obj->q1, x); // 如果q1非空，则将元素压入q1
    }
    else
    {
        QueuePush(&obj->q2, x); // 否则将元素压入q2
    }
}

// 弹出并返回栈顶元素
int myStackPop(MyStack* obj) 
{
    Queue* pEmpty = &obj->q1; // 初始化一个指向空队列的指针
    Queue* pNoEmpty = &obj->q2; // 初始化一个指向非空队列的指针

    // 如果q1非空，则交换两个指针指向的队列
    if (!QueueEmpty(&obj->q1))
    {
        pEmpty = &obj->q2;
        pNoEmpty = &obj->q1;
    }

    // 把非空队列的所有元素依次转移到空队列，保持栈的后进先出性质
    while (QueueSize(pNoEmpty) > 1)
    {
        QueuePush(pEmpty, QueueFront(pNoEmpty)); // 将非空队列的第一个元素移至空队列末尾
        QueuePop(pNoEmpty); // 删除非空队列的第一个元素
    }

    // 获取并返回非空队列的最后一个元素（即栈顶元素）
    int front = QueueFront(pNoEmpty);
    QueuePop(pNoEmpty); // 删除已获取的栈顶元素

    return front;
}

// 返回栈顶元素但不弹出
int myStackTop(MyStack* obj) 
{
    // 根据队列状态获取栈顶元素
    if (!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1); // 若q1非空，则返回q1最后一个元素（栈顶元素）
    }
    else
    {
        return QueueBack(&obj->q2); // 否则返回q2最后一个元素（栈顶元素）
    }
}

// 检查栈是否为空
bool myStackEmpty(MyStack* obj) 
{
    // 若两个队列均为空，则栈为空
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

// 销毁栈并释放内存
void myStackFree(MyStack* obj) 
{
    QueueDestroy(&obj->q1); // 销毁并释放q1队列资源
    QueueDestroy(&obj->q2); // 销毁并释放q2队列资源
    free(obj); // 释放栈对象本身占用的内存
}

        这段代码中，通过两个队列巧妙地实现了栈的功能。其中，压入操作总是把元素添加到非空队列的末尾，而弹出操作时，会先确保所有元素都在同一个队列内，并且按照栈的“后进先出”原则进行操作。

题目三：用栈实现队列（来源）

        题目描述

        请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

        实现 MyQueue 类：

        void push(int x) 将元素 x 推到队列的末尾

        int pop() 从队列的开头移除并返回元素

        int peek() 返回队列开头的元素

        boolean empty() 如果队列为空，返回 true ；否则，返回 false

        题目思路及实现

        使用两个栈，第一个栈只用于数据的输入，第二个栈只用于数据的输出。当需要输出数据，但第二个栈为空时，先将第一个栈中的数据一个一个导入到第二个栈，然后第二个栈再输出数据即可。

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}Stack;

//初始化栈
void StackInit(Stack* pst)
{
	assert(pst);

	pst->a = (STDataType*)malloc(sizeof(STDataType)* 4);
	pst->top = 0;
	pst->capacity = 4;
}

//销毁栈
void StackDestroy(Stack* pst)
{
	assert(pst);

	free(pst->a);
	pst->a = NULL;
	pst->top = 0;
	pst->capacity = 0;
}

//入栈
void StackPush(Stack* pst, STDataType x)
{
	assert(pst);

	if (pst->top == pst->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType)*pst->capacity * 2);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		pst->a = tmp;
		pst->capacity *= 2;
	}
	pst->a[pst->top] = x;
	pst->top++;
}

//检测栈是否为空
bool StackEmpty(Stack* pst)
{
	assert(pst);

	return pst->top == 0;
}

//出栈
void StackPop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));

	pst->top--;
}

//获取栈顶元素
STDataType StackTop(Stack* pst)
{
	assert(pst);
	assert(!StackEmpty(pst));

	return pst->a[pst->top - 1];
}

//获取栈中有效元素个数
int StackSize(Stack* pst)
{
	assert(pst);

	return pst->top;
}

/*---以上代码是栈的基本功能实现，以下代码是题解主体部分---*/

// 定义一个名为MyQueue的结构体，该结构体包含两个栈：pushST（用于插入元素）和popST（用于取出元素），用来模拟队列的功能
typedef struct 
{
    Stack pushST; // 用于插入元素的栈
    Stack popST;  // 用于取出元素的栈
} MyQueue;

// 创建并初始化一个MyQueue类型的队列对象
MyQueue* myQueueCreate() 
{
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue)); // 动态分配内存
    StackInit(&obj->pushST); // 初始化插入元素的栈
    StackInit(&obj->popST);  // 初始化取出元素的栈

    return obj; // 返回新创建的队列对象
}

// 将整数x推入队列尾部（实际操作是将其压入pushST栈顶）
void myQueuePush(MyQueue* obj, int x) 
{
    StackPush(&obj->pushST, x); // 将元素x压入pushST栈顶
}

// 查看队列头部元素但不删除
int myQueuePeek(MyQueue* obj) 
{
    // 如果popST栈为空，则将pushST栈中的所有元素依次弹出并压入popST栈
    if(StackEmpty(&obj->popST))
    {
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST, StackTop(&obj->pushST)); // 将pushST栈顶元素移动到popST栈顶
            StackPop(&obj->pushST);                          // 弹出pushST栈顶元素
        }
    }
    // 返回popST栈顶元素（此时为队列头部元素）
    return StackTop(&obj->popST);
}

// 从队列头部弹出并返回元素
int myQueuePop(MyQueue* obj) 
{
    int top = myQueuePeek(obj); // 获取队列头部元素
    StackPop(&obj->popST);      // 弹出popST栈顶元素（队列头部元素）
    return top;                 // 返回已弹出的头部元素
}

// 判断队列是否为空
bool myQueueEmpty(MyQueue* obj) 
{
    // 当插入元素的pushST栈和取出元素的popST栈都为空时，队列为空
    return StackEmpty(&obj->pushST) && StackEmpty(&obj->popST);
}

// 销毁队列并释放内存
void myQueueFree(MyQueue* obj) 
{
    StackDestroy(&obj->pushST); // 销毁并释放pushST栈的内存
    StackDestroy(&obj->popST);  // 销毁并释放popST栈的内存
    free(obj);                  // 释放MyQueue对象本身的内存
}

        这段代码通过两个栈来模拟队列功能，当插入元素时，将元素压入pushST栈。当需要查看或删除队列头部元素时，首先确保popST栈非空，若为空则将pushST栈中的元素全部转移至popST栈，从而保证popST栈顶元素始终为队列头部元素。这样，通过两个栈的配合，可以实现队列的先进先出（FIFO）特性。 

题目四：设计循环队列（来源）

        题目描述

        设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

        循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

        你的实现应该支持如下操作：

        MyCircularQueue(k): 构造器，设置队列长度为 k 。

        Front: 从队首获取元素。如果队列为空，返回 -1 。

        Rear: 获取队尾元素。如果队列为空，返回 -1 。

        enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。

        deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。

        isEmpty(): 检查循环队列是否为空。

        isFull(): 检查循环队列是否已满。

 

        题目思路及实现

        在环形队列中，队列为空时，队头队尾指向同一个位置。当队列不为空时，队头指向插入的第一个数据，队尾指向最后一个数据的下一个位置。

        当tail+1等于front时，说明环形队列已满。

        注意：环形队列的队尾不能像常规队列中队尾一样指向最后一个数据，如果这样的话，我们将不能区别环形队列的状态是空还是满，因为此时队头和队尾都指向同一个位置。这就意味着，我们必须留出一个空间，这个空间不能存放数据，这样我们才能很好的区别环形队列的状态是空还是满。

        如果用一个数组来实现这个环形队列的话，上面这三种状态就对应于以下三种状态：

        可以看出，此时这个数组和环形完全扯不上关系，这其实很简单，我们只需注意判断两个地方：

        1.当指针指向整个数组的后方的时候，让该指针重新指向数组的第一个元素。

        2.当指针指向整个数组的前方的时候，让该指针直接指向数组最后一个有效元素的后面。

// 定义一个循环队列结构体MyCircularQueue
typedef struct 
{
    int* a;         // 存储队列元素的数组
    int k;          // 队列的最大容量
    int front;      // 队列的头部索引
    int tail;       // 队列的尾部索引
} MyCircularQueue;

// 创建一个容量为k的循环队列
MyCircularQueue* myCircularQueueCreate(int k) 
{
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int) * (k + 1)); // 为元素数组分配内存，预留一个额外位置便于循环

    obj->front = 0;  // 初始化头部索引
    obj->tail = 0;   // 初始化尾部索引
    obj->k = k;      // 设置队列容量

    return obj;
}

// 判断循环队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    return obj->front == obj->tail;
}

// 判断循环队列是否已满
bool myCircularQueueIsFull(MyCircularQueue* obj) 
{
    int tailNext = obj->tail + 1; // 计算下一个可能的尾部索引
    if (tailNext == obj->k + 1) 
    {
         // 处理索引溢出，实现循环
        tailNext = 0;
    }
    return tailNext == obj->front; // 如果计算后的尾部索引等于头部索引，则队列已满
}

// 往循环队列中入队一个值
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) 
{
    if (myCircularQueueIsFull(obj)) 
    {
        return false; // 队列已满，无法入队
    } 
    else 
    {
        obj->a[obj->tail] = value; // 在尾部索引处插入元素
        obj->tail++; // 更新尾部索引

        if (obj->tail == obj->k + 1) 
        {
            obj->tail = 0; // 处理索引溢出，实现循环
        }

        return true; // 入队成功
    }
}

// 从循环队列中出队一个值
bool myCircularQueueDeQueue(MyCircularQueue* obj) 
{
    if (myCircularQueueIsEmpty(obj)) 
    {
        return false; // 队列为空，无法出队
    } 
    else 
    {
        obj->front++; // 更新头部索引

        if (obj->front == obj->k + 1) 
        {
            obj->front = 0; // 处理索引溢出，实现循环
        }

        return true; // 出队成功
    }
}

// 获取循环队列的头部元素
int myCircularQueueFront(MyCircularQueue* obj) 
{
    if (myCircularQueueIsEmpty(obj)) 
    {
        return -1; // 队列为空，无头部元素
    } 
    else 
    {
        return obj->a[obj->front]; // 返回头部索引处的元素
    }
}

// 获取循环队列的尾部元素
int myCircularQueueRear(MyCircularQueue* obj) 
{
    if (myCircularQueueIsEmpty(obj)) 
    {
        return -1; // 队列为空，无尾部元素
    } 
    else 
    {
        int tailPrev = obj->tail - 1; // 计算上一个可能的尾部索引
        if (tailPrev == -1) 
        {
             // 处理索引负值，实现循环
            tailPrev = obj->k;
        }
        return obj->a[tailPrev]; // 返回尾部索引前一个位置的元素
    }
}

// 释放循环队列所占内存
void myCircularQueueFree(MyCircularQueue* obj) 
{
    free(obj->a); // 释放元素数组内存
    free(obj);    // 释放MyCircularQueue结构体内存
}

Russ_Leo
关注
  • 11
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
newcoder-oj：牛客题霸-算法篇-程序员面试高频题（c ++）
03-04
newcoder-oj牛客题霸-算法篇-程序员面试高频题（c ++）
【数据结构】栈和队列OJ练习(栈和队列相互实现+循环队列实现)
Edward_Asia的博客
11-03 2553
前言 前面在学习了栈和队列的实现之后，相信大家对栈和队列的结构和使用方式都有了一些理解。 下面我们就来进行一些练习，这这章的练习相对于原来在难度上有了一些提升。 原来的题只需要实现一个接口，而今天的练习题需要实现多个接口。 1.用队列实现栈 225. 用队列实现栈 - 力扣（LeetCode） (leetcode-cn.com) 栈：后进先出；队列：先进先出 方法： 创建两个队列，用来来回导数据。 入栈：将数据放入不为空的队列。 出栈：将不为空的队列中的数据以出队入栈的方式.
链表常见面试题( 建议收藏！！)
一朵花花
08-31 3572
链表面试题????1.删除链表中等于给定值 val 的所有节点2.二级目录3.三级目录 1.删除链表中等于给定值 val 的所有节点 题目： 题目链接： https://leetcode-cn.com/problems/remove-linked-list-elements/. 思考： 用tmp记录当前节点，若tmp 的下一个节点不为空且下一个节点的节点值等于给定的 val，则需要删除tmp的下一个节点 2.二级目录 3.三级目录 ...
【数据结构】栈和队列重点知识汇总（附有OJ题）
qq_68993495的博客
09-25 961
Java实现数据结构之栈和队列以及OJ习题，很想对大家有帮助！
C语言【数据结构】栈和队列【OJ题（C++）、选择题】
冰果滴的博客
06-12 2080
目录一.OJ题1.225. 用队列实现栈2.232. 用栈实现队列3.622. 设计循环队列4.20. 有效的括号二.选择题1.下列关于栈的叙述正确的是（B）2.一个栈的入栈序列为ABCDE，则不可能的出栈序列为（D）3.链栈与顺序栈相比，比较明显的优点是（C）4.下列关于用栈实现队列的说法中错误的是（B）5.用无头单链表存储队列，其头指针指向队头结点，尾指针指向队尾结点，则在进行出队操作时（C）6.以下不是队列的基本运算的是（B）7.下面关于栈和队列的说法中错误的是（AB）8.下列关于顺序结构实现循环队列
【C语言】浅_刷 —— 栈 - 队列 OJ题，看了就会~（详解版）
上上谦. 的博客
04-04 1666
有了上面队列的结构，再加上之前实现的栈的结构，我们来做几道OJ练习来加强对知的理解。
【leetcode】学了栈和队列却觉得无用武之地？试试这几道题目吧！
花想云的博客
01-23 1981
这些题目所用语言为C语言，由于C语言未提供栈和队列的数据结构，所以需要我们手动实现栈和队列。此外熟练掌握栈和队列的性质对解题尤为重要。如果忘记了栈和队列的使用方法可在此直接跳转到栈和队列详解篇。＜栈＞的概念&结构&实现【C语言版】＜队列＞的概念&结构&实现【C语言版】
【栈与队列】栈与队列的相互转换OJ题
JLX_1的博客
11-30 1380
栈与对列的相互转换OJ题
Java - 栈和队列
旧时言的博客
01-16 3667
栈和队列 1.栈(Stack) 1.1概念 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈 顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据在栈顶。 1.2实现 1.利用顺序表实现，即使用尾插 +尾删的方式实现 2.利用链表实现，则头尾皆可。（单链表用头插+头删法。或者使用双向链表。） 相对来说，顺序表的实现上要
栈和队列求解迷宫问题（数据结构学习笔记）
热门推荐
省洗发水钱买书
12-14 3万+
文章目录迷宫问题“栈”求解迷宫问题行走规则算法思路算法代码栈的定义算法设计完整代码最终迷宫路径算法总结“队列”求解迷宫问题算法思路算法代码队列定义算法设计完整代码最终迷宫路径（小迷宫）最终迷宫路径（原题迷宫）算法总结 迷宫问题 给定一个M*N的迷宫图、入口与出口、行走规则。求一条从指定入口到出口的路径（这里M=8,N=8）,所求路径必须是简单路径，即路径不重复 (为了方便算法起见，在整个迷宫外围加上一堵墙） 这里分别使用栈和队列两种方法求解迷宫问题，并比较两种算法的具体体现。 “栈”求解迷宫问题 行走
面试准备系列02----面试中的栈和队列题目汇总
毛毛虫的小哈
08-10 1925
面试准备系列02----面试中的栈和队列题目汇总 1.栈的经典应用：括号匹配+表达式计算 http://blog.csdn.net/sheepmu/article/details/21563557 2.两个栈实现队列+两个队列实现栈 http://blog.csdn.net/sheepmu/article/details/38428205 3.实现包含最大最小值的栈O(1) h
leetcode和oj-interview-questions:前端面试题和答案，front-endinterviewquestionsand
06-30
前端面试题和答案 来源 互联网.网络 阿里巴巴、腾讯、京东、百度、网易、谷歌、苹果等各个名门大厂 面试经历 面试经验 面试准备 面试准备 一些站点 * ：还订阅他们的提要以获得指向他们新文章的链接。 不管那些是...
leetcode和oj-Coding-Interview:编程面试
06-30
：Java面试题 : 面试学习表 ：非常好的 stackoverflow 问题，涵盖了计算运行时复杂性的基础知识。 : 面试时要问的问题，以了解更多关于公司的信息。 竞技节目 : 过去的比赛练习题 如果你卡住了 ：订阅他们的每周时事...
oj! Algorithms:数学，线性代数和优化-开源
04-26
哦！ 算法-ojAlgo-是与数学，线性代数和优化有关的开源Java代码； 特别是（但肯定不是排他性的）适合金融领域。
DnuiOJ_oj题库_大连东软信息学院_打包文件_大连东软oj_DnuiOJ_
10-03
这是大连东软信息学院的内部OJ题库，希望大家下载看看
C语言——模拟实现库函数atoi
2302_80250536的博客
05-13 391
INT_MAX 和 INT_MIN 是 C语言 的两个预定义宏，代表了整型变量能够存储的最大正整数21474836472^31 − 1）和最小负整数-2^31这个值是相对于二进制补码表示的，也就是说，负数的范围比正数大 1,这两个宏在头文件中定义。
C语言：设计循环队列
最新发布
Another_Shi的博客
05-18 739
本篇博客是写完LeetCode_662.设计循环队列之后有感而发，于是写下了一些思路和总结。本题用了两种方法来解答——顺序表和链表。
[数据结构——Java]包装类&简单认识泛型
qq_63492484的博客
05-17 845
一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。通俗讲就是：返回的Object数组里面，可能存放的是任何的数据类型，可能是String，可能是Person，运行的时 候，直接转给Integer类型的数组，编译器认为是不安全的。我们不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制 下面的类型擦除部分，我们也会讲到编译器是如何使用裸类型的。（5）注释4处，代码编译报错，此时因为在注释2处指定类当前的类型，此时在注释4处，编译器会在存放元素的时 候帮助我们进行类型检查。
数据结构——堆的定义，堆的数据操作函数以及堆对数组的排序知识点详解！！
hu_ju_hong的博客
05-18 806
堆和使用堆进行数组的排序知识详解！
zzulioj--1832--贪吃的松鼠（位运算好题）
05-14
这是一道经典的位运算题目，考察对二进制的理解和位运算的熟练程度。 题目描述： 给定一个长度为 $n$ 的数组 $a$，初始时每个数的值都为 $0$。现在有 $m$ 个操作，每个操作为一次询问或修改。 对于询问，给出两个整数 $l,r$，求 $a_l \oplus a_{l+1} \oplus \cdots \oplus a_r$ 的值。 对于修改，给出一个整数 $x$，表示将 $a_x$ 的值加 $1$。 输入格式： 第一行两个整数 $n,m$。 接下来 $m$ 行，每行描述一次操作，格式如下： 1 l r：表示询问区间 $[l,r]$ 的异或和。 2 x：表示将 $a_x$ 的值加 $1$。 输出格式： 对于每个询问操作，输出一个整数表示答案，每个答案占一行。 数据范围： $1 \leq n,m \leq 10^5$，$0 \leq a_i \leq 2^{30}$，$1 \leq l \leq r \leq n$，$1 \leq x \leq n$ 输入样例： 5 5 2 1 2 3 1 2 4 2 2 1 1 5 输出样例： 0 2 解题思路： 对于询问操作，可以利用异或的性质，即 $a \oplus b \oplus a = b$，将 $a_l \oplus a_{l+1} \oplus \cdots \oplus a_r$ 转化为 $(a_1 \oplus \cdots \oplus a_{l-1}) \oplus (a_1 \oplus \cdots \oplus a_r)$，因为两个前缀异或后的结果可以相互抵消，最后的结果即为 $a_1 \oplus \cdots \oplus a_{l-1} \oplus a_1 \oplus \cdots \oplus a_r = a_l \oplus \cdots \oplus a_r$。 对于修改操作，可以将 $a_x$ 对应的二进制数的每一位都分离出来，然后对应位置进行修改即可。由于只有加 $1$ 操作，所以只需将最后一位加 $1$ 即可，其余位不变。 参考代码：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值