数据结构探险系列—栈篇-学习笔记

最新推荐文章于 2024-07-27 17:57:54 发布
最新推荐文章于 2024-07-27 17:57:54 发布
阅读量88 收藏
点赞数
文章标签： 数据结构与算法
原文链接：https://yq.aliyun.com/articles/631013
版权

数据结构探险—栈篇

什么是栈？
古代栈就是牲口棚的意思。

栈是一种机制：后进先出 LIFO（last in first out）

电梯

栈要素

空栈。栈底，栈顶。没有元素的时候，栈顶和栈底指向同一个元素，如果加入新元素，栈顶不断升高。取出数据时栈顶不断地降低。栈顶和栈底都称之为栈要素。

  • 通过demo说明栈的基本原理
  • 热身运动-进制转换：十进制转换到二进制，八进制，十六进制
N = (N div d) * d + N mod d
  • 步步为营- 括号匹配检测：检测一个字符串中的各种括号是否匹配
[()]  [()()]  [()[()]]

实例介绍

栈要求

mystack.h:

#ifndef MYSTACK_H
#define MYSTACK_H
class MyStack
{
public:
    MyStack(int size);      //分配内存初始化栈空间，设定栈容量，栈顶
    ~MyStack();             //回收栈空间内存
    bool stackEmpty();      //判断栈是否为空
    bool stackFull();       //判断栈是否为满
    void clearStack();      //清空栈
    int stackLength();      //栈中元素的个数
    bool push(char elem);   //将元素压入栈中，栈顶上升
    bool pop(char &elem);   //将元素推出栈，栈顶下降
    void stackTraverse(bool isFromButtom);  //遍历栈中元素并输出
private:
    int m_iTop;             //栈顶，栈中元素个数
    int m_iSize;            //栈容量
    char *m_pBuffer;        //栈空间指针
};


#endif

mystack.cpp:

#include "Mystack.h"
#include <iostream>
using namespace std;

MyStack::MyStack(int size)
{
    m_iSize = size;
    m_pBuffer = new char[size];
    m_iTop = 0;
}
MyStack::~MyStack()
{
    delete[]m_pBuffer;
    m_pBuffer = NULL;
    
}
bool MyStack::stackEmpty()
{
    if (m_iTop == 0)//if(0 == m_iTop)
    {
        return true;
    }
    else
    {
        return false;
    }
}
bool MyStack::stackFull()
{
    if ( m_iTop == m_iSize)//>=
    {
        return true;
    }
    else
    {
        return false;
    }
}

void MyStack::clearStack()
{
    m_iTop = 0;//原栈中所有值无效
}

int MyStack::stackLength()
{
    return m_iTop;
}

bool MyStack::push(char elem)//放入栈顶
{
    if (stackFull())
    {
        return false;
    }
    m_pBuffer[m_iTop] = elem;
    m_iTop++;
    return true;
}
bool MyStack::pop(char &elem)
{
    if (stackEmpty())
    {
        return false;
    }
    m_iTop--;//因为入栈时做了++，使栈顶指向下一个空位置
    elem = m_pBuffer[m_iTop];
    return true;
}

//char MyStack::pop()
//{
//  if (stackEmpty())
//  {
//      throw 1;
//  }
//  else
//  {
//      m_iTop--;
//      return m_pBuffer[m_iTop];
//  }
//}

void MyStack::stackTraverse(bool isFromButtom)
{
    if (isFromButtom)
    {
        for (int i = 0; i < m_iTop; i++)
        {
            cout << m_pBuffer[i] << ",";
        }
    }
    else
    {
        for (int i = m_iTop - 1; i >= 0; i--)
        {
            cout << m_pBuffer[i] << ",";
        }
    }
    
}

main.cpp:

#include "Mystack.h"
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(void)
{
    MyStack *pStack = new MyStack(5);

    pStack->push('h');//底
    pStack->push('e');
    pStack->push('l');
    pStack->push('l');
    pStack->push('o');//顶

    pStack->stackTraverse(true);
    char elem = 0;
    pStack->pop(elem);

    cout << endl;
    cout << elem << endl;

    //pStack->clearStack();
    pStack->stackTraverse(false);

    cout << pStack->stackLength() << endl;
    if (pStack->stackEmpty())
    {
        cout << "栈为空" << endl;
    }
    if (pStack->stackFull())
    {
        cout << "栈为满" << endl;
    }



    delete pStack;
    pStack = NULL;
    system("pause");
    return 0;
}

运行结果：

栈运行结果

案例改造。

要求：


栈改造要求 
#ifndef MYSTACK_H
#define MYSTACK_H
#include "Coordinate.h"
class MyStack
{
public:
    MyStack(int size);      //分配内存初始化栈空间，设定栈容量，栈顶
    ~MyStack();             //回收栈空间内存
    bool stackEmpty();      //判断栈是否为空
    bool stackFull();       //判断栈是否为满
    void clearStack();      //清空栈
    int stackLength();      //栈中元素的个数
    bool push(Coordinate elem); //将元素压入栈中，栈顶上升
    bool pop(Coordinate &elem); //将元素推出栈，栈顶下降
    void stackTraverse(bool isFromButtom);  //遍历栈中元素并输出
private:
    int m_iTop;             //栈顶，栈中元素个数
    int m_iSize;            //栈容量
    Coordinate *m_pBuffer;      //栈空间指针
};
#endif

#include "Mystack.h"
#include <iostream>
using namespace std;

MyStack::MyStack(int size)
{
    m_iSize = size;
    m_pBuffer = new Coordinate[size];
    m_iTop = 0;
}
MyStack::~MyStack()
{
    delete[]m_pBuffer;
    m_pBuffer = NULL;
    
}
bool MyStack::stackEmpty()
{
    if (m_iTop == 0)//if(0 == m_iTop)
    {
        return true;
    }
    else
    {
        return false;
    }
}
bool MyStack::stackFull()
{
    if ( m_iTop == m_iSize)//>=
    {
        return true;
    }
    else
    {
        return false;
    }
}

void MyStack::clearStack()
{
    m_iTop = 0;//原栈中所有值无效
}

int MyStack::stackLength()
{
    return m_iTop;
}

bool MyStack::push(Coordinate elem)//放入栈顶
{
    if (stackFull())
    {
        return false;
    }
    m_pBuffer[m_iTop] = elem;
    //因为这里的coordinate是一个简单的复制。所以使用默认拷贝函数就可以了
    m_iTop++;
    return true;
}
bool MyStack::pop(Coordinate &elem)
{
    if (stackEmpty())
    {
        return false;
    }
    m_iTop--;//因为入栈时做了++，使栈顶指向下一个空位置
    elem = m_pBuffer[m_iTop];
    return true;
}

//char MyStack::pop()
//{
//  if (stackEmpty())
//  {
//      throw 1;
//  }
//  else
//  {
//      m_iTop--;
//      return m_pBuffer[m_iTop];
//  }
//}

void MyStack::stackTraverse(bool isFromButtom)
{
    if (isFromButtom)
    {
        for (int i = 0; i < m_iTop; i++)
        {
            //cout << m_pBuffer[i] << ",";
            m_pBuffer[i].printCoordinate();
        }
    }
    else
    {
        for (int i = m_iTop - 1; i >= 0; i--)
        {
            //cout << m_pBuffer[i] << ",";
            m_pBuffer[i].printCoordinate();
        }
    }
    
}

#ifndef COORDINATE_H
#define COORDINATE_H
class Coordinate
{
public:
    Coordinate(int x=0,int y=0);
    void printCoordinate();
private:
    int m_iX;
    int m_iY;
};
#endif

#include "Coordinate.h"
#include <iostream>
using namespace std;

Coordinate::Coordinate(int x, int y)
{
    m_iX = x;
    m_iY = y;
}
void Coordinate::printCoordinate()
{
    cout << "(" << m_iX << "," << m_iY << ")" << endl;
}

main.cpp:

#include "Mystack.h"
#include <iostream>
#include <stdlib.h>
using namespace std;
int main(void)
{
    MyStack *pStack = new MyStack(5);

    pStack->push(Coordinate(1,2));//底
    pStack->push(Coordinate(3, 4));

    pStack->stackTraverse(true);
    
    pStack->stackTraverse(false);

    cout << pStack->stackLength() << endl;

    delete pStack;
    pStack = NULL;
    system("pause");
    return 0;
}

运行结果：

改造后运行结果

经过改造我们使栈满足了coordinate对象的入栈出栈。

将普通栈改为类模板栈。使其可以适用于任何数据类型
类模板栈实现要求

上面我们实现过两遍对于栈的实现。一次是实现char数组的栈。一次是实现coordinate对象的。两次除过数据类型。差别不是很大。所以本次我们使用类模板实现适用任何数据类型的栈

mystack.h:(因为编译器不支持类模板分开编译。所以cpp为空)

#ifndef MYSTACK_H
#define MYSTACK_H
#include <iostream>
using namespace std;
template <typename T>
class MyStack
{
public:
    MyStack(int size);      //分配内存初始化栈空间，设定栈容量，栈顶
    ~MyStack();             //回收栈空间内存
    bool stackEmpty();      //判断栈是否为空
    bool stackFull();       //判断栈是否为满
    void clearStack();      //清空栈
    int stackLength();      //栈中元素的个数
    bool push(T elem);  //将元素压入栈中，栈顶上升
    bool pop(T &elem);  //将元素推出栈，栈顶下降
    void stackTraverse(bool isFromButtom);  //遍历栈中元素并输出
private:
    int m_iTop;             //栈顶，栈中元素个数
    int m_iSize;            //栈容量
    T *m_pBuffer;       //栈空间指针
};

template <typename T>
MyStack<T>::MyStack(int size)
{
    m_iSize = size;
    m_pBuffer = new T[size];
    m_iTop = 0;
}
template <typename T>
MyStack<T>::~MyStack()
{
    delete[]m_pBuffer;
    m_pBuffer = NULL;

}
template <typename T>
bool MyStack<T>::stackEmpty()
{
    if (m_iTop == 0)//if(0 == m_iTop)
    {
        return true;
    }
    else
    {
        return false;
    }
}
template <typename T>
bool MyStack<T>::stackFull()
{
    if (m_iTop == m_iSize)//>=
    {
        return true;
    }
    else
    {
        return false;
    }
}
template <typename T>
void MyStack<T>::clearStack()
{
    m_iTop = 0;//原栈中所有值无效
}
template <typename T>
int MyStack<T>::stackLength()
{
    return m_iTop;
}
template <typename T>
bool MyStack<T>::push(T elem)//放入栈顶
{
    if (stackFull())
    {
        return false;
    }
    m_pBuffer[m_iTop] = elem;
    //因为这里的coordinate是一个简单的复制。所以使用默认拷贝函数就可以了
    m_iTop++;
    return true;
}
template <typename T>
bool MyStack<T>::pop(T &elem)
{
    if (stackEmpty())
    {
        return false;
    }
    m_iTop--;//因为入栈时做了++，使栈顶指向下一个空位置
    elem = m_pBuffer[m_iTop];
    return true;
}

//char MyStack::pop()
//{
//  if (stackEmpty())
//  {
//      throw 1;
//  }
//  else
//  {
//      m_iTop--;
//      return m_pBuffer[m_iTop];
//  }
//}
template <typename T>
void MyStack<T>::stackTraverse(bool isFromButtom)
{
    if (isFromButtom)
    {
        for (int i = 0; i < m_iTop; i++)
        {
            cout << m_pBuffer[i];
            //m_pBuffer[i].printCoordinate();
        }
    }
    else
    {
        for (int i = m_iTop - 1; i >= 0; i--)
        {
            cout << m_pBuffer[i];
            //m_pBuffer[i].printCoordinate();
        }
    }

}
#endif


#ifndef COORDINATE_H
#define COORDINATE_H
#include <ostream>
using namespace std;
class Coordinate
{
    friend ostream &operator<<(ostream &out, Coordinate &coor);
public:
    Coordinate(int x=0,int y=0);
    void printCoordinate();
private:
    int m_iX;
    int m_iY;
};
#endif


#include "Coordinate.h"
#include <iostream>
using namespace std;

Coordinate::Coordinate(int x, int y)
{
    m_iX = x;
    m_iY = y;
}
void Coordinate::printCoordinate()
{
    cout << "(" << m_iX << "," << m_iY << ")" << endl;
}

ostream &operator<<(ostream &out, Coordinate &coor)
{
    out << "(" << coor.m_iX << "," << coor.m_iY << ")" << endl;
    return out;
}

main.cpp:

#include "Mystack.h"
#include <iostream>
#include <stdlib.h>
#include "Coordinate.h"
using namespace std;
int main(void)
{
    MyStack<Coordinate> *pStack = new MyStack<Coordinate>(5);

    pStack->push(Coordinate(1,2));//底
    pStack->push(Coordinate(3, 4));

    pStack->stackTraverse(true);
    
    pStack->stackTraverse(false);

    cout << pStack->stackLength() << endl;
    MyStack<char> *pStack2 = new MyStack<char>(5);

    pStack2->push('h');//底
    pStack2->push('e');
    pStack2->push('l');
    pStack2->push('l');
    pStack2->push('o');//顶

    pStack2->stackTraverse(true);
    delete pStack;
    pStack = NULL;
    system("pause");
    return 0;
}
类模板栈运行结果

可以看到我们的类模板已经将栈改造成了通用数据类型的栈。

栈应用-进制转换

进制转换

短除法。不停除以进制数。保留余数。然后商继续除以进制保留余数。直到商为0
栈的应用：将每次的余数4 0 5 2 入栈。然后从栈顶开始打印。

#ifndef MYSTACK_H
#define MYSTACK_H
#include <iostream>
using namespace std;
template <typename T>
class MyStack
{
public:
    MyStack(int size);      //分配内存初始化栈空间，设定栈容量，栈顶
    ~MyStack();             //回收栈空间内存
    bool stackEmpty();      //判断栈是否为空
    bool stackFull();       //判断栈是否为满
    void clearStack();      //清空栈
    int stackLength();      //栈中元素的个数
    bool push(T elem);  //将元素压入栈中，栈顶上升
    bool pop(T &elem);  //将元素推出栈，栈顶下降
    void stackTraverse(bool isFromButtom);  //遍历栈中元素并输出
private:
    int m_iTop;             //栈顶，栈中元素个数
    int m_iSize;            //栈容量
    T *m_pBuffer;       //栈空间指针
};

template <typename T>
MyStack<T>::MyStack(int size)
{
    m_iSize = size;
    m_pBuffer = new T[size];
    m_iTop = 0;
}
template <typename T>
MyStack<T>::~MyStack()
{
    delete[]m_pBuffer;
    m_pBuffer = NULL;

}
template <typename T>
bool MyStack<T>::stackEmpty()
{
    if (m_iTop == 0)//if(0 == m_iTop)
    {
        return true;
    }
    else
    {
        return false;
    }
}
template <typename T>
bool MyStack<T>::stackFull()
{
    if (m_iTop == m_iSize)//>=
    {
        return true;
    }
    else
    {
        return false;
    }
}
template <typename T>
void MyStack<T>::clearStack()
{
    m_iTop = 0;//原栈中所有值无效
}
template <typename T>
int MyStack<T>::stackLength()
{
    return m_iTop;
}
template <typename T>
bool MyStack<T>::push(T elem)//放入栈顶
{
    if (stackFull())
    {
        return false;
    }
    m_pBuffer[m_iTop] = elem;
    //因为这里的coordinate是一个简单的复制。所以使用默认拷贝函数就可以了
    m_iTop++;
    return true;
}
template <typename T>
bool MyStack<T>::pop(T &elem)
{
    if (stackEmpty())
    {
        return false;
    }
    m_iTop--;//因为入栈时做了++，使栈顶指向下一个空位置
    elem = m_pBuffer[m_iTop];
    return true;
}

//char MyStack::pop()
//{
//  if (stackEmpty())
//  {
//      throw 1;
//  }
//  else
//  {
//      m_iTop--;
//      return m_pBuffer[m_iTop];
//  }
//}
template <typename T>
void MyStack<T>::stackTraverse(bool isFromButtom)
{
    if (isFromButtom)
    {
        for (int i = 0; i < m_iTop; i++)
        {
            cout << m_pBuffer[i];
            //m_pBuffer[i].printCoordinate();
        }
    }
    else
    {
        for (int i = m_iTop - 1; i >= 0; i--)
        {
            cout << m_pBuffer[i];
            //m_pBuffer[i].printCoordinate();
        }
    }

}
#endif

#include "Mystack.h"
#include <iostream>
#include <stdlib.h>
using namespace std;

#define BINARY 2
#define OCTONARY 8
#define HEXADECIMAL 16

int main(void)
{
    MyStack<int> *pStack = new MyStack<int>(30);
    int N = 1348;
    int mod = 0;
    while (N !=0)
    {
        mod = N % BINARY;
        pStack->push(mod);
        N = N / BINARY;
    }
    pStack->stackTraverse(false);

    delete pStack;
    pStack = NULL;
    system("pause");
    return 0;
}

二进制和8进制都没有问题了，16进制还需要进一步改造。

运行结果：

!运行结果](http://upload-images.jianshu.io/upload_images/1779926-c6c62f86ff27da42.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

16进制改造

mystack.h与原来一致。

#include "Mystack.h"
#include <iostream>
#include <stdlib.h>
using namespace std;

#define BINARY 2
#define OCTONARY 8
#define HEXADECIMAL 16

int main(void)
{
    char num[] = "0123456789ABCDEF";
    MyStack<char> *pStack = new MyStack<char>(30);
    int N = 2016;
    int mod = 0;
    while (N !=0)
    {
        mod = N % HEXADECIMAL;
        pStack->push(num[mod]);
        N = N / HEXADECIMAL;
    }
    pStack->stackTraverse(false);
    /*for (int i=pStack->stackLength()-1;i>=0;i--)
    {
        num[pStack[i]]
    }*/
    /*int elem = 0;
    while (!pStack->stackEmpty())
    {
        pStack->pop(elem);
        cout << num[elem];
    }*/
    

    delete pStack;
    pStack = NULL;
    system("pause");
    return 0;
}

如果仍使栈为int型。则可以使用注释部分打印出内容。修改为char之后。可使用
pStack->push(num[mod]);

栈应用括号匹配
括号匹配

从前往后扫描。左方括号入栈，左圆括号入栈，当遇到右括号则左圆括号出栈。当遇到右方括号，左方括号出栈。字符串扫描完毕时栈为空则全部匹配。栈中还有东西则不是全部匹配

#include "Mystack.h"
#include <iostream>
#include <stdlib.h>
using namespace std;

int main(void)
{
    MyStack<char> *pStack = new MyStack<char>(30);//已存入的字符

    MyStack<char> *pNeedStack = new MyStack<char>(30);//需要的字符。

    char str[] = "[()]]";
    char currentNeed = 0;

    for (int i=0;i<strlen(str);i++)
    {
        if (str[i] != currentNeed)//如果此时扫描到的字符不是我们所需要的。
        {
            pStack->push(str[i]);//那么将这个字符存入“已存入字符”
            switch (str[i])//对于这个字符，生成它的currentneed
            {
            case '[':
                if (currentNeed !=0)//如果currentneed已经有值，不为初值。
                {
                    pNeedStack->push(currentNeed);//将当前的需要字符入栈。
                }
                currentNeed = ']';//生成当前需要。
                break;
            case  '(':
                if (currentNeed != 0)
                {
                    pNeedStack->push(currentNeed);
                }
                currentNeed = ')';
                break;
            default:
                cout << "字符串不匹配" << endl;
                system("pause");
                return 0;
            }
        }
        else
        {
            char elem;
            pStack->pop(elem);
            if (pNeedStack->pop(currentNeed))
            {
                currentNeed = 0;
            }
            

        }
        
    }
    if (pStack->stackEmpty())
    {
        cout << "字符串括号匹配" << endl;
    }
    delete pStack;
    pStack = NULL;
    delete pNeedStack;
    pNeedStack = NULL;
    system("pause");
    return 0;
}

运行过程：

最开始：currentneed为0.

  • str[0]为"[",此时需要的currentneed为0，不相等。
  • 进入if内部。将"[" 存入栈1。进入switch的case内部。匹配到case:"["
  • 此时判断到当前的currentneed = 0.不满足if。则生成currentneed "]"。并break
    出循环。
  • str[1]为"（"，此时需要的currentneed是"]"，不相等。
  • 进入if内部将"("存入栈1.进入switch的case内部。匹配到case："("
  • 此时判断到当前的currentneed ="]"不等于0.将该字符存入需要栈，因为下面就要对他进行覆盖了、
  • 生成新的的currentneed")"，并break出循环
  • str[2]为")"，正好与我们当前的currentneed一致。
  • 那么我们将栈一的"("弹出。并将needstack里的上一个急需的赋值给currentneed。
  • 进入下一次循环。

也就是currentneed变量里面存放的是当前下一次循环刚开始急需匹配的。
need栈里存放的是历史需要的。

当当前需要的和正在扫描的一致。则将栈1中出栈。

weixin_33842304
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法笔记：图搜索之DFS详解
Wang的专栏
02-08 2460
图搜索 Graph Search 图搜索的分类 BFS广度优先(宽搜) DFS深度优先(深搜) !!!本文详解!!! 深度优先搜索DFS 深度优先遍历DFS, 这个策略其实是非常stupid or simple的，比BSF要简单的多 同样，我们可以通过一个故事来开始 在古希腊神话中, Ariadne是Crete的国王Minos的公主，她给忒修斯(Theseus)一个线团 使得忒修斯成功进入迷宫杀死牛头怪兽，但事后忒修斯抛弃了她 这是一个有道德意义的故事又或者存在不同的版本, 但不是我们的研究的对象
深度学习-甲骨文图片数据集
10-18
在这个场景中，我们关注的是一个专门针对甲骨文图片的深度学习数据集，这为研究者提供了一个宝贵的资源来探索和提升计算机在识别和理解古代文字方面的能力。 甲骨文是中国最早的文字形式，记录在龟甲和兽骨上，主要...
数据结构探险系列—队列篇-学习笔记
weixin_33796177的博客
09-02 94
数据结构探险系列—队列篇 这是c++远征系列的进阶课程。 什么是数据结构？ 一群数据集合和数据之间的关系。 是指相互之间存在一种或多种特定关系的数据元素集合， 我么将学到： 原理 c++实现编码 队列 特定：先入先出（FIFO） 火车站买票。队头队尾。售票员从头开始卖票。先到的人先买到票就可以离开。...
数据结构探险（队列篇）
誓约胜利之舰
07-24 328
一、什么是数据结构 数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。 二、队列原理 1.什么是队列？先入先出（FIFO—— First In First Out）数学模型 2.分类：普通队列、环形队列 3.用途？自动排号机... 三、面向对象的队列设计 //在MyQueue.h文件中 #ifndef MYQUEUE_H #define MYQUEUE_H /**...
12-数据结构探险系列—栈篇
weixin_34293911的博客
07-26 96
数据结构探险—栈篇 本文及代码收录于个人编程笔记(整理中,欢迎Star):https://github.com/mtianyan/Programming-Notebook 什么是栈？ 古代栈就是牲口棚的意思。 栈是一种机制：后进先出 LIFO（last in first out） 比如电梯,先进电梯位于电...
《Redis深度历险学习笔记》：Redis的基本数据结构
天乔巴夏丶
12-10 256
《Redis深度探险：核心原理和应用实践》 写在前面 Redis概述 官网地址：https://redis.io/ Redis命令在线演示地址：https://try.redis.io/ 命令参考：http://doc.redisfans.com/ Redis 是一个开源，高级的键值存储和一个适用的解决方案，用于构建高性能，可扩展的 Web 应用程序。Redis 也被作者戏称为 数据结构服务器 ，这意味着使用者可以通过一些命令，基于带有 TCP 套接字的简单 服务器-客户端 协议来访问一组 可变数据结构.
【学习笔记】程序设计竞赛
jayq1的博客
07-06 940
记录一下本学期的算法笔记
数据结构与算法分析_学习笔记
xietangz
01-19 6725
[首页, 上一页, 下一页;   目录 ] 目录    1  前言        1.1  所选教材        1.2  写作原因        1.3  一些约定        1.4  历史记录        1.5  联系方式    2  单链表        2.1  代码实现        2.2  效率问题        2.3  应用：一元多项式（加法和乘
趣学算法学习笔记2
虾球
09-05 798
问题 3-6 最好的农场 问题描述 背景 在一场反侵略战争中,农夫 William 团结了全国的农民帮助国王抗击侵略者。战争胜利了,国王决定奖赏给农夫 William 一个大农场。 问题 国王将其国土划分成 1×1 见方的 A×B 个格子,每个格子用一对整数作为标识。如图 3-6 所示。不过,并非所有的格子都可奖赏给 William,其中一些已经奖赏给别人,另一些在战争中被摧毁。国王仅列出那些可以作为奖品的格子供 William 选择。当然,William 也不能将这些格子全部用来建造他的农场,他只能选择连
java学习第四章-java面向对象（仅做个人学习笔记用）
Nlsrr的博客
04-05 389
*
深度学习-国旗图像分类数据集
12-11
CNN是一种专门用于处理图像数据的神经网络结构，它通过卷积层、池化层和全连接层来提取图像特征并进行分类。在国旗图像分类中，CNN首先会学习低级特征，如边缘和颜色，然后逐渐学习更高级的特征，如形状和图案。经过...
深度学习-保险公司理赔数据集
02-18
保险公司理赔数据集，保险公司理赔数据集,已对姓名、电话号码进行脱敏处理。 性别 SEX 地区 REGION 年龄 AGE 月收入 MONTHLY_INCOME 年收入 ANNUAL_INCOME 学历 EDUCATIONAL_BACKGROUND 身体状态 PHYSICAL_STATE ...
深度学习-猴痘病识别数据集
10-18
在猴痘病识别任务中，深度学习可以用于训练卷积神经网络（CNN），这是一种专门处理图像数据的网络结构。 首先，数据预处理是深度学习模型训练的关键步骤。在这个数据集中，可能包含不同大小、质量各异的猴痘病图片...
深度学习-shipdata船舶数据集
10-15
本数据集，名为“shipdata”，是专为深度学习模型设计的，旨在帮助研究者和开发者训练和优化算法，以识别和理解船舶相关的图像和信息。 “shipdata”数据集通常包含了大量船舶的图片，这些图片可能被标注了不同的...
2024钉钉杯A题思路详解
全栈川川
07-26 1487
2024钉钉杯思路
【刷题汇总 -- 爱丽丝的人偶、集合、最长回文子序列】
m0_69455439的博客
07-23 702
今日刷题汇总day021 -- 爱丽丝的人偶、集合、最长回文子序列
算法训练 2024.7.27 17：25
最新发布
2301_80011650的博客
07-27 260
给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使合并后的数组仍然是有序的。： 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，返回它们的数组下标。给定一个二维网格，其中 1（表示陆地）和 0（表示水），计算岛屿的数量。： 给定一个包含非负整数的 m x n 网格，找出一条从左上角到右下角的路径，使得路径上的数字总和最小。给定一个只包括 (，)，{，}，[，] 的字符串，判断字符串是否有效。： 反转一个单链表。
STL标准模板库---容器篇(一)
U2396573637的博客
07-24 982
对C风格字符串的封装，也是容器类的“先驱”类，也可以称为“实验品”，但这只是相对而言。字符串类string本身功能还是非常强大的。string str;//声明字符串变量//初始化字符串变量//使用重载后的操作符 + 连接两个字符串字符串类还提供了许多成员函数来操作字符串，以下是一些常用的成员函数：size():返回字符串的长度empty():检查字符串是否为空substr():获取子字符串find():查找子字符串在主字符串中的位置replace():替换字符串中的某些字符。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值