手撕算法题3 (附源码和思路)

最新推荐文章于 2024-09-06 10:38:06 发布
最新推荐文章于 2024-09-06 10:38:06 发布
阅读量452 收藏 10
点赞数 3
文章标签： 算法 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yusei_0523/article/details/140849848
版权

算法

1.有效的括号

在这里插入图片描述
有效的括号

思路
借助栈这样的数据结构，将所有左括号进行入栈，所有右括号与出栈的括号比较，相同循环继续，不同直接返回false。循环结束后检查栈是否为空，为空说明已经全部匹配了，若栈不为空说明并没有一一对应返回false，以上都没问题返回true。

设计程序
定义一个栈，字符串遍历若是左括号则入栈字符++，否则取栈顶元素出栈与此时的字符比较

（当然比较的条件这里我是用ASCII码写的，因为我查表发现它们的ASCII码差只为1或2），
注意取栈顶元素一定要栈不为空（如果此时栈为空说明绝对不匹配）

遍历完字符串，若果都一一对应了栈应该为空否则就不匹配，判断一下进行相应返回就行

编写代码

typedef char STDataType;
typedef struct Stack {
    STDataType* arr;
    int capacity; // 栈的空间大小
    int top;      // 栈顶
} ST;
void STInitialise(ST* ps) {
    assert(ps);
    ps->arr = NULL;
    ps->capacity = ps->top = 0;
}

void STDestroy(ST* ps) {
    assert(ps);
    if (ps->arr)
        free(ps->arr);
    ps->arr = NULL;
    ps->top = ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x) {
    assert(ps);
    // 判断空间是否充足
    if (ps->top == ps->capacity) {
        // 增容//0*2 = 0
        // 若capacity为0，给个默认值，否则×2倍
        int NewCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
        STDataType* tmp =
            (STDataType*)realloc(ps->arr, NewCapacity * sizeof(STDataType));
        if (tmp == NULL) {
            perror("realloc fail!");
            exit(1);
        }
        ps->arr = tmp;
        ps->capacity = NewCapacity;
    }
    ps->arr[ps->top++] = x;
}

bool StackEmpty(ST* ps) {
    if (ps->top) {
        return true;
    }
    return false;
}

void StackPop(ST* ps) {
    assert(ps);
    assert(StackEmpty(ps));
    ps->top--;
}

STDataType StackTop(ST* ps) {
    assert(ps);
    assert(StackEmpty(ps));
    return ps->arr[ps->top - 1];
}
//
bool isValid(char* s) {
    char*tmp=s;
    ST ps;
    STInitialise(&ps);
    while(*tmp)
    {
        if(*tmp=='('||*tmp=='{'||*tmp=='[')
        {
            StackPush(&ps,*tmp);
        }
        else
        {
            if(!StackEmpty(&ps))
            return false;
            char top=StackTop(&ps);
            StackPop(&ps);
            if(*tmp-top!=1&&*tmp-top!=2)
            return false;
        }
        tmp++;
    }
    if(StackEmpty(&ps))
    return false;
    return true;
}

2.用队列实现栈

在这里插入图片描述
用队列实现栈

思路
在这里插入图片描述

设计程序

借助两个队列实现栈
在不为空的队列中入数据（都为空我们默认在q2入数据），
出栈我们定义好空栈和非空栈（会变化），将非空栈的size-1个元素导入空栈中，取空栈栈顶元素出栈
取栈顶元素直接返回非空队列的队尾元素

编写代码

typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QueueNode;
typedef struct Queue
{
	QueueNode* phead;
	QueueNode* ptail;
	int size;
}Queue;
void QueueInitialise(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	if (pq->phead == NULL && pq->ptail == NULL)
	{
		return false;
	}
	return true;
}
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* NewNode = (QueueNode*)malloc(sizeof(QueueNode));
	if (NewNode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	NewNode->data = x;
	NewNode->next = NULL;
	if (pq->phead == NULL)
	{
		pq->phead = pq->ptail = NewNode;
	}
	else
	{
		pq->ptail->next = NewNode;
		pq->ptail = NewNode;
	}
	pq->size++;
}
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(QueueEmpty(pq));
	QueueNode* Next = pq->phead->next;
	if (pq->phead == pq->ptail)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	free(pq->phead);
	pq->phead = NULL;
	pq->phead = Next;
	pq->size--;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(QueueEmpty(pq));
	return pq->ptail->data;
}
int QueueSize(Queue* pq)
{
	assert(pq);
	/*size_t size = 0;
	QueueNode* pcur = pq->phead;
	while (pcur)
	{
		size++;
		pcur = pcur->next;
	}*/
	return pq->size;
}
void QueueDestroy(Queue* pq)
{
	assert(pq);
	//assert(QueueEmpty(pq));

	QueueNode* pcur = pq->phead;
	while (pcur)
	{
		QueueNode* Next = pcur->next;
		free(pcur);
		pcur = Next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(QueueEmpty(pq));
	return pq->phead->data;
}
///
typedef struct{
    Queue q1;
    Queue q2;
}MyStack;
MyStack* myStackCreate() {
    MyStack*pst=(MyStack*)malloc(sizeof(MyStack));
    QueueInitialise(&pst->q1);
    QueueInitialise(&pst->q2);

    return pst;
}

void myStackPush(MyStack* obj, int x) {
    if(QueueEmpty(&obj->q1))
    {
       QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    //找不为空的队列
    Queue*empQ=&obj->q1;
    Queue*noneQ=&obj->q2;
    if(QueueEmpty(&obj->q1))
    {
        noneQ=&obj->q1;
        empQ=&obj->q2;
    }
    while(QueueSize(noneQ)>1)
    {
        int front=QueueFront(noneQ);
        QueuePush(empQ,front);
        QueuePop(noneQ);
    }
    int pop=QueueFront(noneQ);
    QueuePop(noneQ);
    return pop;
}

int myStackTop(MyStack* obj) {
    if(QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    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);
    obj=NULL;
}

/**
 * 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.用栈实现队列

在这里插入图片描述
用栈实现队列

思路
在这里插入图片描述
这样就实现了队列的先进先出了，程序思路大体与上述相同不过简单的是我们空队列和非空列是固定的。

编写代码

typedef int STDataType;
typedef struct Stack
{
	STDataType*arr;
	int capacity;//栈的空间大小
	int top;//栈顶
}ST;
void STInitialise(ST* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->capacity = ps->top = 0;
}

void STDestroy(ST* ps)
{
	assert(ps);
	if (ps->arr)
		free(ps->arr);
	ps->arr = NULL;
	ps->top = ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//判断空间是否充足
	if (ps->top == ps->capacity)
	{
		//增容//0*2 = 0
		//若capacity为0，给个默认值，否则×2倍
		int NewCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->arr, NewCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = NewCapacity;
	}
	ps->arr[ps->top++] = x;
}

bool StackEmpty(ST* ps)
{
	if (ps->top)
	{
		return true;
	}
	return false;
}

void StackPop(ST* ps)
{
	assert(ps);
	assert(StackEmpty(ps));
	ps->top--;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(StackEmpty(ps));
	return ps->arr[ps->top - 1];
}

int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
//

typedef struct {
    ST pushST;
    ST popST;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue*pst=(MyQueue*)malloc(sizeof(MyQueue));
    STInitialise(&pst->pushST);
    STInitialise(&pst->popST);

    return pst;
}

void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->pushST,x);
}

int myQueuePop(MyQueue* obj) {
    if(!StackEmpty(&obj->popST))
    {
        while(StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    int ret=StackTop(&obj->popST);
    StackPop(&obj->popST);
    return ret;
}

int myQueuePeek(MyQueue* obj) {
    if(!StackEmpty(&obj->popST))
    {
        while(StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    return StackTop(&obj->popST);
}

bool myQueueEmpty(MyQueue* obj) {
    return !StackEmpty(&obj->pushST)&&!StackEmpty(&obj->popST);
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->pushST);
    STDestroy(&obj->popST);
    free(obj);
    obj=NULL;

}

/**
 * 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);
*/

3.设计循环队列

在这里插入图片描述
设计循环队列

思路
用数组实现循环队列，因为数组连续且不像链表需要自己去连接。其次数组实现的循环队列标识队列已满好实现，而链表实现的循环队列标识队列已满不好实现。

这就引出了这道题的难点怎么标识队列满了，接下来我们来实现

设计程序

在这里插入图片描述
rear=front时队列为空
在这里插入图片描述
（rear+1）%（capacity+1）==front我们表示为队列满了，比如我们队列的长度为4，多申请一个结点，当rare走到如图的黑色位置时（4+1）%(4+1)=0等于front此时就为空了，但是不是说当rare走到这个位置队列为满。
而是通过（rear+1）%（capacity+1）==front这个公式来判断是否为满，随着front的改变（队头出数据会导致front++），哨兵位置也会改变，但是我们申请的空间一定有一个结点来标识哨兵位。
我们对front++，rear++可能会越界它是一个循环队列所以要%=capacity，同时返回队尾元素，一定是rear-1，当rear为0减应该对应的元素为capacity的位置，如果是跟着我博客学习的粉丝可能对这道题有点遗憾，因为我们用链表实现队列的时候是返回队尾数据就直接返回了，不需要-1，但是严格来说队列不是只能队尾入数据吗而不是取数据，所以队尾是插入数据的地方而不是取数据的地方，希望这些能对大家有所帮助，如果还不能理解的话可以咨询博主。




typedef struct {
    int*arr;
    int front;
    int rear;
    int capacity;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->arr=(int*)malloc(sizeof(int)*(k+1));
    obj->rear=obj->front=0;
    obj->capacity=k;
    return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front==obj->rear;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear+1)%(obj->capacity+1) == obj->front;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
    return false;
    obj->arr[obj->rear++]=value;
    obj->rear%=obj->capacity+1;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    return false;
    obj->front++;
    obj->front%=obj->capacity+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;
    int prev = obj->rear-1;
    if(obj->rear==0)
    prev=obj->capacity;
    return obj->arr[prev];
}


void myCircularQueueFree(MyCircularQueue* obj) {
    obj->capacity=obj->front=obj->rear=0;
    free(obj->arr);
    obj->arr=NULL;
    free(obj);
    obj=NULL;
}

/**
 * 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);
*/
Yusei_0523
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python:实现sobel边缘检测算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-31 999
Python:实现sobel边缘检测算法(附完整源码)
python：TOPK算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-28 231
python：TOPK算法(附完整源码)
手撕算法题2（附源码和思路）
Yusei_0523的博客
07-30 980
1.移除链表元素 2.反转链表 2.链表的中间结点 3.合并两个有序链表 4.链表分割 5.链表的回文结构 6.相交链表 7.环形链表 8.环形链表II 9.随机链表的复制
手撕算法题4（附思路和源码）
Yusei_0523的博客
08-05 634
1.单值二叉树 2.相同的树 3.另一棵树的子树 4.二叉树的前序遍历 5.二叉树的中序遍历 6.二叉树的后序遍历 7.二叉树遍历 8.TopK问题
大厂高频手撕算法题
2401_84097798的博客
04-22 672
点击这里即可免费获取，包括答案解析。ed) return;resolve(x);// PromiseA+ 2.3.3.2 如果检索属性x.then抛出异常e，则以e为原因拒绝promise// PromiseA+ 2.3.3.4 如果调用then抛出异常，但是resolvePromise或rejectPromise已经执行，则忽略它reject(e);} else {// PromiseA+ 2.3.4 如果x不是一个对象或函数，状态变为fulfilled并传值xresolve(x);
几率大的现场手撕算法面试题（含答案）
睶
05-01 1万+
现场手撕算法面试题个人经历比较少，但会收集网上面经，一般线下要求手撕算法的次数更多，其次就是来个共享链接自己在电脑上写代码。这个系列将会持续更新。 先提前了解一些常用的类以及方法： 类 Scanner： 从控制台输入： 方法一： Scanner sc = new Scanner(System.in); //构造一个Scanner对象实例 String queue = sc.next(); //接受...
算法题：手撕LRU
2301_78668865的博客
05-25 150
首先就是数据结构的选择，LRU算法需要一个链表来实现，而题目要求时间复杂度为常数级，那么我们就要用到哈希表，哈希表我们可以选择数组来实现，也可以选择用java封装好的HashSet或HashMap，由于这道题需要用到链表，那么封装好的HashMap难以实现链表功能。数据结构的进一步思考：链表我们用单向还是双向的？由于我们要在常数级删除一个节点，那么我们除了要在常数级找到他，还得在常数级删除他，这里显然需要用双向链表来实现快速删除，这里我们维护两个额外的节点，哑结点（头结点）和尾结点，统一插入和删除操作。
手撕面试题算法（1）——LRU算法
Yuc0114的博客
09-06 619
目录前言一、设计思想二、实现后的效果三、实现步骤1. 类定义2. 方法定义1）置入数据操作put方法2）获取数据的get方法3）打印缓存中key的方法4）返回缓存中的数据个数四、总结 前言 LRU(Least Recently Used)，即最近最少使用之意，是一种缓存淘汰策略，当需要淘汰一个数据时（如缓存空间已满），其将一个未使用时间最长的数据淘汰（删除） 本文只介绍最常用的LRU手写实现方法，即HashMap+链表的实现方法 一、设计思想 利用链表存储被存入容器的key，每当有一个数据被放入容器，则
如何备战面试中的手撕算法
我的博客
04-24 5989
最近，很多同学在微信私聊时提到：“面试中的手撕算法好难啊，网上面经中的算法题基本都不会写，更别提在面试时面对面的十几分钟写出实现代码了…这块到底要怎么准备啊”。 细问下去发现又到一年的春招和实习招聘季节了。距离秋招也就五个月了，五个月的时间看似很长，但等待你们的事情也很多：五个月中你得看厚厚一堆的书籍，并且大部分是得看两到三遍，还有各类框架、源码、数据库、并发、设计模式、操作系统、linux、项目...
OD算法真题目录
热门推荐
程序员阿甘的博客
11-18 37万+
华为OD机考算法题目录，A卷，B卷，C卷，D卷，E卷
H5游戏源码 手撕鬼子.zip
10-15
5. 数据结构与算法：游戏源码中会涉及各种数据结构（如数组、链表、队列、堆）和算法（如搜索、排序、碰撞检测），这些是优化游戏性能的关键。 6. 状态管理：游戏的状态管理是确保游戏流程顺畅的关键。这可能包括...
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 902
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【大数据分析与挖掘算法】matlab实现——Apriori关联规则算法
Robbi_的博客
09-04 688
四、实验结果。
C语言：刷题笔记
weixin_45930573的博客
09-04 414
c语言刷题记录
树状数组记录
最新发布
volcan的博客
09-06 625
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 381
力扣刷题--1534. 统计好三元组【简单】
【算法】单词出现次数和位置统计
Hanbuhuic的博客
09-04 389
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
【滑动窗口】将 x 减到 0 的最小操作数
qq_42150700的博客
09-03 1141
当然也是没有必要的, 因为你要求区间里面的和至少要 target. 你刚刚区间, 就恰好是 >= target 的边界. 也就是说, 左边的值应该都是 <= target 的, 也就是下面这个图蓝色区间的和, 肯定是小于 target 的. 因为是正好加了右侧指针的值才 >= target 停下的。更新结果: 结果的更新, 可以说是最好写的一个部分, 你要什么, 你就在什么时候更新. 我们要的是 sum = target 的长度, 那我们就在 sum = target 的时候更新长度不就行了?
专题一_双指针_算法专题详细总结
2301_80636070的博客
09-06 917
利用双指针，cur=0，dest=-1，只要nums[cur]==0 dest就走两格；否则 dest走一格；但是无论怎么样cur都走一格。直到dest到达结尾处n-1 停止，即 判断dest>=n-1 处 break；
2023华为od面试手撕代码真题
12-05
2023华为OD面试手撕代码真题要求应聘...因此，应聘者需要在面试前认真准备，多做一些手写代码的练习题，提高自己的编程水平和解决问题的能力。同时，还要保持自信，冷静应对面试过程中的挑战，展现出自己的实力和潜力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值