驾驭栈和队列,首先逃不开这些(有效括号、栈和队列相互模拟、循环队列)

一.有效括号

. - 力扣（LeetCode）

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

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

提示：

  • 1 <= s.length <= 104
  • s 仅由括号 '()[]{}' 组成

typedef char StackData;

typedef struct Stack

{

    StackData* data;

    int top;

    int size;

}Stack;

//初始化栈

void initStack(Stack* st)

{

    assert(st);

    st->data = NULL;

    st->top = 0;

    st->size = 0;

}

//销毁栈

void destroyStack(Stack* st)

{

    assert(st);

    free(st->data);

    st->data = NULL;

    st->size = st->top = 0;

}

//栈是否为空

bool isEmpty(Stack* st)

{

    assert(st);

    return st->top == 0;

}

//出栈

void popStack(Stack* st)

{

    assert(st);

    assert(!isEmpty(st));

    st->top--;

}

//入栈

void pushStack(Stack* st, StackData data)

{

    assert(st);

    if (st->top == st->size)

    {

        int newsize = st->size == 0 ? 4 : 2 * st->size;

        StackData* temp = (StackData*)realloc(st->data, sizeof(StackData) * newsize);

        if (temp != NULL)

        {

            st->data = temp;

            st->size = newsize;

        }

    }

    st->data[st->top] = data;

    st->top++;

}

//取出栈顶元素

StackData topStack(Stack* st)

{

    assert(st);

    assert(!isEmpty(st));

    return st->data[st->top - 1];

}

//栈的大小

int sizeStack(Stack* st)

{

    assert(st);

    return st->top;

}

bool isValid(char* s) {

    Stack st;

    initStack(&st);

    int lcount = 0, rcount = 0;

    for (int i = 0; s[i] != '\0'; i++)

    {

        if (s[i] == '(' || s[i] == '[' || s[i] == '{')

            {

                pushStack(&st, s[i]);

                lcount++;

            }

        else

        {

            rcount++;

            if (isEmpty(&st))

            {

                destroyStack(&st);

                return false;

            }

            char str = topStack(&st);

            if ((s[i] == ')' && str == '(') ||

                (s[i] == ']' && str == '[') ||

                (s[i] == '}' && str == '{'))

            {

                popStack(&st);

            }

        }

    }

    return isEmpty(&st) && rcount == lcount;

}

二.用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（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（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

  • 1 <= x <= 9
  • 最多调用 100 次 push、pop、peek 和 empty
  • 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

进阶：

  • 你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <stdbool.h>

#include <string.h>

typedef char StackData;

typedef struct Stack

{

    StackData* data;

    int top;

    int size;

}Stack;

//初始化栈

void initStack(Stack* st)

{

    assert(st);

    st->data = NULL;

    st->top = 0;

    st->size = 0;

}

//销毁栈

void destroyStack(Stack* st)

{

    assert(st);

    free(st->data);

    st->data = NULL;

    st->size = st->top = 0;

}

//栈是否为空

bool isEmpty(Stack* st)

{

    assert(st);

    return st->top == 0;

}

//出栈

void popStack(Stack* st)

{

    assert(st);

    assert(!isEmpty(st));

    st->top--;

}

//入栈

void pushStack(Stack* st, StackData data)

{

    assert(st);

    if (st->top == st->size)

    {

        int newsize = st->size == 0 ? 4 : 2 * st->size;

        StackData* temp = (StackData*)realloc(st->data, sizeof(StackData) * newsize);

        if (temp != NULL)

        {

            st->data = temp;

            st->size = newsize;

        }

    }

    st->data[st->top] = data;

    st->top++;

}

//取出栈顶元素

StackData topStack(Stack* st)

{

    assert(st);

    assert(!isEmpty(st));

    return st->data[st->top - 1];

}

//栈的大小

int sizeStack(Stack* st)

{

    assert(st);

    return st->top;

}


 

typedef struct {

  Stack st1;

  Stack st2;  

} MyQueue;


 

MyQueue* myQueueCreate() {

    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));

    initStack(&obj->st1);

    initStack(&obj->st2);

    return obj;

}

void myQueuePush(MyQueue* obj, int x) {

    pushStack(&obj->st1, x);

}

int myQueuePop(MyQueue* obj) {

    int top = myQueuePeek(obj);

    popStack(&obj->st2);

    return top;

}

int myQueuePeek(MyQueue* obj) {

    if(isEmpty(&obj->st2))

    {

        while(!isEmpty(&obj->st1))

        {

            int top = topStack(&obj->st1);

            popStack(&obj->st1);

            pushStack(&obj->st2, top);

        }

    }

    return topStack(&obj->st2);

}

bool myQueueEmpty(MyQueue* obj) {

    return isEmpty(&obj->st1) && isEmpty(&obj->st2);

}

void myQueueFree(MyQueue* obj) {

    destroyStack(&obj->st1);

    destroyStack(&obj->st2);

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

*/

三.用队列实现栈

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

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

  • 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
  • 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

  • 1 <= x <= 9
  • 最多调用100 次 push、pop、top 和 empty
  • 每次调用 pop 和 top 都保证栈不为空

进阶：你能否仅用一个队列来实现栈。

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include <stdbool.h>

typedef int QueueData;

typedef struct QueueNode

{

    QueueData data;

    struct QueueNode* next;

}QNode;

//可以用带头链表，也可以传入二级指针

typedef struct Queue

{

    struct QueueNode* phead;

    struct QueueNode* ptail;

    int size;

}Queue;

//队列的初始化

void initQueue(Queue* pq)

{

    assert(pq);

    pq->phead = pq->ptail = NULL;

    pq->size = 0;

}

//队列的销毁

void destroyQueue(Queue* pq)

{

    assert(pq);

    QNode* cur = pq->phead;

    while (cur)

    {

        QNode* next = cur->next;

        free(cur);

        cur = next;

    }

}

//建立节点

QNode* createQNode(QueueData data)

{

    QNode* pcur = (QNode*)malloc(sizeof(QNode));

    if (pcur == NULL)

        perror("malloc fail");

    else

    {

        pcur->data = data;

        pcur->next = NULL;

    }

    return pcur;

}

//插入元素

void pushQueue(Queue* pq, QueueData data)

{

    assert(pq);

    QNode* newNode = createQNode(data);

    if (pq->phead == NULL)

        pq->phead = pq->ptail = newNode;

    else

    {

        pq->ptail->next = newNode;

        pq->ptail = pq->ptail->next;

    }

    pq->size++;

}

//删除元素

void popQueue(Queue* pq)

{

    assert(pq);

    assert(pq->phead);

    if (pq->phead->next == NULL)

    {

        free(pq->phead);

        pq->phead = pq->ptail = NULL;

    }

    else

    {

        QNode* next = pq->phead->next;

        free(pq->phead);

        pq->phead = next;

    }

    pq->size--;

}

//取出队首元素

QueueData topQueue(Queue* pq)

{

    assert(pq);

    assert(pq->phead);

    return pq->phead->data;

}

//取出队尾元素

QueueData backQueue(Queue* pq)

{

    assert(pq);

    assert(pq->phead);

    return pq->ptail->data;

}

//计算队列长度

int sizeQueue(Queue* pq)

{

    assert(pq);

    return pq->size;

}

bool isEmpty(Queue* pq)

{

    assert(pq);

    return !pq->phead;

}

void printQueue(Queue* pq)

{

    assert(pq);

    QNode* cur = pq->phead;

    while (cur)

    {

        printf("%d ", cur->data);

        cur = cur->next;

    }

}

typedef struct {

    Queue q1;

    Queue q2;

} MyStack;


 

MyStack* myStackCreate() {

    MyStack* obj = (MyStack*)malloc(sizeof(MyStack));

    initQueue(&obj->q1);

    initQueue(&obj->q2);

    return obj;

}

void myStackPush(MyStack* obj, int x) {

    if(!isEmpty(&obj->q1))

    pushQueue(&obj->q1, x);

    else return pushQueue(&obj->q2, x);

}

int myStackPop(MyStack* obj) {

    Queue* emptyQ = &obj->q1;

    Queue* noemptyQ = &obj->q2;

    if(!isEmpty(&obj->q1))

    {

        emptyQ = &obj->q2;

        noemptyQ = &obj->q1;

    }

    while(sizeQueue(noemptyQ) > 1)

    {

        int temp = topQueue(noemptyQ);

        popQueue(noemptyQ);

        pushQueue(emptyQ, temp);

    }

    int top = topQueue(noemptyQ);

    popQueue(noemptyQ);

    return top;

}

int myStackTop(MyStack* obj) {

    if(!isEmpty(&obj->q1))

    return backQueue(&obj->q1);

    else return backQueue(&obj->q2);

}

bool myStackEmpty(MyStack* obj) {

    return isEmpty(&obj->q1) && isEmpty(&obj->q2);

}

void myStackFree(MyStack* obj) {

    destroyQueue(&obj->q1);

    destroyQueue(&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);

*/

四.循环队列

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

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

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

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 检查循环队列是否为空。
  • isFull(): 检查循环队列是否已满。

示例：

MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1);  // 返回 true
circularQueue.enQueue(2);  // 返回 true
circularQueue.enQueue(3);  // 返回 true
circularQueue.enQueue(4);  // 返回 false，队列已满
circularQueue.Rear();  // 返回 3
circularQueue.isFull();  // 返回 true
circularQueue.deQueue();  // 返回 true
circularQueue.enQueue(4);  // 返回 true
circularQueue.Rear();  // 返回 4

提示：

  • 所有的值都在 0 至 1000 的范围内；
  • 操作数将在 1 至 1000 的范围内；
  • 请不要使用内置的队列库。

typedef struct {

    int* queue;

    int head;

    int rear;

    int k;

} MyCircularQueue;


 

MyCircularQueue* myCircularQueueCreate(int k) {

    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));

    int* q = (int*)malloc(sizeof(int) * (k+1));

    obj->queue = q;

    obj->k = k;

    obj->head = 0;

    obj->rear = 0;

    return obj;

}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {

    return (obj->rear)%(obj->k+1) == (obj->head)%(obj->k+1);

}

bool myCircularQueueIsFull(MyCircularQueue* obj) {

    return (obj->rear+1)%(obj->k+1)==(obj->head)%(obj->k+1);

}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {

    if(myCircularQueueIsFull(obj))

    return false;

    else

    {

        obj->queue[obj->rear] = value;

        obj->rear++;

        (obj->rear) %= (obj->k+1);

        return true;

    }

}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {

    if(myCircularQueueIsEmpty(obj))

    return false;

    else

    {

        obj->head++;

        (obj->head) %= (obj->k+1);

        return true;

    }

}

int myCircularQueueFront(MyCircularQueue* obj) {

    if(myCircularQueueIsEmpty(obj))

    return -1;

    else return obj->queue[(obj->head) % (obj->k+1)];

}

int myCircularQueueRear(MyCircularQueue* obj) {

    if(myCircularQueueIsEmpty(obj))

    return -1;

    else return obj->queue[(obj->rear+obj->k)%(obj->k+1)];

}

void myCircularQueueFree(MyCircularQueue* obj) {

    free(obj->queue);

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

*/

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/425380.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

力扣74. 搜索二维矩阵（二分查找）

力扣74. 搜索二维矩阵（二分查找）

Problem: 74. 搜索二维矩阵 文章目录 题目描述思路复杂度Code 题目描述 思路 思路1&#xff1a;映射为一维数组二分查找 1.由于题目矩阵中的元素整体是升序的&#xff0c;我们可以将其放置在一个大小为 m n m \times n mn的一维数组array中进行二分查找 2.对应的映射关系是ar…
阅读更多...
微信小程序,h5端自适应登陆方式

微信小程序,h5端自适应登陆方式

微信小程序端只显示登陆(获取opid),h5端显示通过账户密码登陆 例如: 通过下面的变量控制: const isWeixin ref(false); // #ifdef MP-WEIXIN isWeixin.value true; // #endif
阅读更多...
（C语言）qsort函数模拟实现

（C语言）qsort函数模拟实现

前言 我们需先了解qsort函数 qsort函数详解&#xff1a;http://t.csdnimg.cn/rTNv9 qsort函数可以排序多种数据类型&#xff0c;很是神奇&#xff0c;这是为什么&#xff0c;我们在里模拟实现这样的功能 目录 1. qsort函数模拟实现 2. 我们使用bubble_sort函数排序整形数…
阅读更多...
ruoyi 图片等文件资源读取

ruoyi 图片等文件资源读取

老是忘&#xff0c;记录一下 ResourcesConfig 文件下 /** 本地文件上传路径 */ registry.addResourceHandler(Constants.RESOURCE_PREFIX "/**").addResourceLocations("file:" RuoYiConfig.getProfile() "/"); /*** 资源映射路径 前缀*/ …
阅读更多...
【Web安全靶场】xss-labs-master 1-20

【Web安全靶场】xss-labs-master 1-20

xss-labs-master 其他靶场见专栏 文章目录 xss-labs-masterlevel-1level-2level-3level-4level-5level-6level-7level-8level-9level-10level-11level-12level-13level-14level-15level-16level-17level-18level-19level-20 level-1 第一关没有进行任何限制&#xff0c;get请求…
阅读更多...
python复盘（1）

python复盘（1）

1、变量名的命名规则 #3、变量名的命名规则&#xff1a;可以用中文作为变量名&#xff1b;其他和go语言一样 # 变量名可以用数字、字母、下划线组成&#xff0c;但是数字不能作为开头 # 变量名不能使用空格&#xff0c;不能使用函数名或关键字 # 变量名最好能表示出他的作用2、…
阅读更多...
Qt/事件分发器/事件过滤器

Qt/事件分发器/事件过滤器

事件分发器 //事件分发器bool event(QEvent* e); //事件分发器&#xff1a;&#xff1a;用途 分发事件 bool MyLabel::event(QEvent* e) {if(e->type() QEvent::MouseButtonPress){//如果是鼠标摁下 拦截事件 不向下分发QMouseEvent* ev static_cast<QMouseEvent*>…
阅读更多...
python类型注解，多态详解

python类型注解，多态详解

目录 1.类型注解 1.变量的类型注解 2.函数&#xff08;方法&#xff09;的类型注解 3.union类型 2.多态 抽象类 1.类型注解 1.变量的类型注解 #基础数据类型注解 import randomv1 : int 10 v2 : str "aaa" v3 : bool True#类对象类型注解 class student:p…
阅读更多...
基于springboot+vue的公寓报修管理系统

基于springboot+vue的公寓报修管理系统

博主主页&#xff1a;猫头鹰源码 博主简介&#xff1a;Java领域优质创作者、CSDN博客专家、阿里云专家博主、公司架构师、全网粉丝5万、专注Java技术领域和毕业设计项目实战&#xff0c;欢迎高校老师\讲师\同行交流合作 ​主要内容&#xff1a;毕业设计(Javaweb项目|小程序|Pyt…
阅读更多...
奇舞周刊第521期：“一切非 Rust 项目均为非法”

奇舞周刊第521期：“一切非 Rust 项目均为非法”

奇舞推荐 ■ ■ ■ 拜登&#xff1a;“一切非 Rust 项目均为非法” 科技巨头要为Coding安全负责。这并不是拜登政府对内存安全语言的首次提倡。“程序员编写代码并非没有后果&#xff0c;他们的⼯作⽅式于国家利益而言至关重要。”白宫国家网络总监办公室&#xff08;ONCD&…
阅读更多...
6020一拖二快充线：手机充电的革命性创新

6020一拖二快充线：手机充电的革命性创新

在快节奏的现代生活中&#xff0c;手机已不仅仅是一个通讯工具&#xff0c;更是我们工作、学习和娱乐的得力助手。然而&#xff0c;手机的电量问题一直是困扰着我们的难题。为了解决这个问题&#xff0c;市场上出现了一种名为“一拖二快充线”的充电设备&#xff0c;它不仅具备…
阅读更多...
用JavaScript动态提取视频中的文字

用JavaScript动态提取视频中的文字

现阶段整个社会短视频&#xff0c;中视频为王&#xff0c;文字传播虽然被弱化&#xff0c;但在业务中还是有一定的传播价值&#xff0c;今天就来讲一讲如何使用js动态提取视频中的字幕。 先来看看效果&#xff1a; 屏幕录制2024-02-29 15.40.18 一&#xff0c;tesseract.js介…
阅读更多...
SpringMVC 学习（十一）之数据校验

SpringMVC 学习（十一）之数据校验

目录 1 数据校验介绍 2 普通校验 3 分组校验 4 参考文档 1 数据校验介绍 在实际的项目中&#xff0c;一般会有两种校验数据的方式&#xff1a;客户端校验和服务端校验 客户端校验&#xff1a;这种校验一般是在前端页面使用 JS 代码进行校验&#xff0c;主要是验证输入数据…
阅读更多...
Zookeeper3：客户端命令

Zookeeper3：客户端命令

文章目录 客户端命令连接服务端Zookeeper客户端内置命令 ls - 节点信息 客户端命令 连接服务端Zookeeper //客户端连接服务端zookeeper 默认连的本机2181端口的zookeeper cd /opt/module/zookeeper-3.9.1/bin && sh zkCli.sh//客户端连接远程服务端zookeeper cd /op…
阅读更多...
详细了解C++中的namespace命名空间

详细了解C++中的namespace命名空间

键盘敲烂&#xff0c;月薪过万&#xff0c;同学们&#xff0c;加油呀&#xff01; 目录 键盘敲烂&#xff0c;月薪过万&#xff0c;同学们&#xff0c;加油呀&#xff01; 一、命名空间的理解 二、&#xff1a;&#xff1a;作用域运算符 三、命名空间&#xff08;namespace&…
阅读更多...
Vulnhub靶机：Bellatrix

Vulnhub靶机：Bellatrix

一、介绍 运行环境&#xff1a;Virtualbox 攻击机&#xff1a;kali&#xff08;10.0.2.4&#xff09; 靶机&#xff1a;Bellatrix&#xff08;10.0.2.9&#xff09; 目标&#xff1a;获取靶机root权限和flag 靶机下载地址&#xff1a;https://www.vulnhub.com/entry/hogwa…
阅读更多...
【C++】const成员

【C++】const成员

个人主页 &#xff1a; zxctscl 如有转载请先通知 文章目录 1. 前言2. const成员3. 取地址及const取地址操作符重载 1. 前言 在之前已经已经分享过了关于 【C】类和对象之常引用与运算符重载&#xff0c;这次分享的有关const的内容&#xff0c;话不多说&#xff0c;正文开始。…
阅读更多...
spring-security 项目实战（一）个人健康档案

spring-security 项目实战（一）个人健康档案

spring-security 项目实战&#xff08;一&#xff09;个人健康档案 项目说明项目地址框架信息 代码分析配置类解析默认登录页登录接口执行逻辑登录认证成功之后重定向到main页面过程未登录之前访问 /main生成默认登录页点击登录 登录之后访问 /main执行流程清空认证信息 项目来…
阅读更多...
Leetcoder Day27｜ 贪心算法part01

Leetcoder Day27｜ 贪心算法part01

语言&#xff1a;Java/Go 理论 贪心的本质是选择每一阶段的局部最优&#xff0c;从而达到全局最优。 什么时候用贪心&#xff1f;可以用局部最优退出全局最优&#xff0c;并且想不到反例到情况 贪心的一般解题步骤 将问题分解为若干个子问题找出适合的贪心策略求解每一个子…
阅读更多...
数据类型和变量

数据类型和变量

1.数据类型 在Java中数据类型主要分为两类&#xff1a;基本数据类型和引用数据类型。 基本数据类型有四类八种&#xff1a; 1. 四类&#xff1a;整型、浮点型、字符型以及布尔型 2.八种&#xff1a; 整形是分为如上四种 byte short int long 浮点型分为 float 和double …
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站