栈和队列的OJ练习题

news2024/11/17 10:24:45

前言

俗话说：熟能生巧，我们在学习完知识，一定要运用，不运用那么他过段时间就忘了，所以大家还是要认真的看一些题

(1)有效的括号

在这里插入图片描述
在这里插入图片描述

思路：我们可以用栈的知识
将左括号入栈，右括号出栈顶元素然后匹配，如果匹配那么返回真，否则返回假。

bool isValid(char * s){
     ST st;
    StackInit(&st);
    while(*s)
    {
        if(*s=='('||*s=='{'||*s=='[')
        {
            StackPush(&st,*s);
            ++s;
        }
        else
        {
            if(StackEmpty(&st))
            {
                StackDestroy(&st);
                return false;
            }
            char top = StackTop(&st);
            StackPop(&st);
            if((top=='('&&*s!=')')||
                (top=='{'&&*s!='}')||
                (top=='['&&*s!=']') )
            {
                StackDestroy(&st);
                return false;
            } 
            else
            {
                ++s;
            }       
            
        }
    }

    //看栈是否为空
    bool ret=StackEmpty(&st);

    StackDestroy(&st);
    return ret;
}

上面只是我们程序的代码，我们还要引用栈

typedef char STDataType;

typedef struct Stack
{
	STDataType* a;
	int capacity;
	int top;//表示栈顶
}ST;
//栈的初始化
void StackInit(ST* ps);
//栈的销毁
void StackDestroy(ST* ps );
//栈的插入
void StackPush(ST* ps, STDataType x);
//栈的删除
void StackPop(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);
//取栈顶的元素
STDataType StackTop(ST* ps);
//看栈的大小
int StackSize(ST* ps);
//栈的初始化
void StackInit(ST* ps)
{
	assert(ps);
	//ps->a = NULL;
	//ps->sz = 0;
	//ps->top = 0;

	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc error");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;
}


//栈的销毁
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
//栈的插入
void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	//扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity * 2;
		STDataType* ret = (STDataType*)realloc(ps->a,sizeof(STDataType) * newcapacity);
		if (ret == NULL)
		{
			perror("realloc error");
			exit(-1);
		}
		ps->a = ret;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
//栈的删除
void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}
//判断栈是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);
	//if (ps->top == 0)
	//{
	//	return true;
	//}
	//else
	//{
	//	return false;
	//}
	return ps->top == 0;
}
//取栈顶的元素
STDataType StackTop(ST* ps)
{
	assert(ps);
	//返会top下一个元素
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}
//看栈的大小
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
bool isValid(char * s){
       ST st;
    StackInit(&st);
    while(*s)
    {
        if(*s=='('||*s=='{'||*s=='[')
        {
            StackPush(&st,*s);
            ++s;
        }
        else
        {
            if(StackEmpty(&st))
            {
                StackDestroy(&st);
                return false;
            }
            char top = StackTop(&st);
            StackPop(&st);
            if((top=='('&&*s!=')')||
                (top=='{'&&*s!='}')||
                (top=='['&&*s!=']') )
            {
                StackDestroy(&st);
                return false;
            } 
            else
            {
                ++s;
            }       
            
        }
    }

    //看栈是否为空
    bool ret=StackEmpty(&st);

    StackDestroy(&st);
    return ret;
}

(2)用队列实现栈

在这里插入图片描述

思路：我们现在有两个队列，用两个队列实现栈
对列的功能是先进先出，而栈是先出后进
所以我们通过画图可以分析出来
我们有两个队列，一个队列为空，一个队列插入数据，
如果想要删除数据，就将有数据的除了要删除的数据，其他放到空队列中，然后再删除数据，原先插入队列的数据就变为了空队列。
所以两个队列肯定有一个保持空队列，一个插入数据。
其他的功能就很简单了。

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* obj=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);

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

int myStackPop(MyStack* obj) {
    assert(obj);
    Queue* Emptyq=&obj->q1;
    Queue* noEmpty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        Emptyq = &obj->q2;
        noEmpty = &obj->q1;
    }
    while(noEmpty->head!=noEmpty->tail)
    {
        QDataType ret = QueueFront(noEmpty);
        QueuePop(noEmpty);
        QueuePush(Emptyq,ret);
    }
    QDataType del=QueueFront(noEmpty);
    QueuePop(noEmpty);
    return del;
}

int myStackTop(MyStack* obj) {
    assert(obj);
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    assert(obj);
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    assert(obj);
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
}

因为我们是c语言，所以我们写的队列链接进去，所以完整代码入下

typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;

void QueueInit(Queue* pq);
void QueueDestroy(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);
bool QueueEmpty(Queue* pq);
int QueueSize(Queue* pq);


void QueueInit(Queue* pq)
{
	assert(pq);

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

void QueueDestroy(Queue* pq)
{
	assert(pq);

	QNode* cur = pq->head;
	while (cur)
	{
		QNode* del = cur;
		cur = cur->next;

		free(del);
		//del = NULL;
	}

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

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

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

		free(del);
	}

	pq->size--;
}

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

bool QueueEmpty(Queue* pq)
{
	assert(pq);

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

// 1G = 1024MB
// 1024MB = 1024*1024KB
// 1024*1024KB = 1024*1024*1024Byte

int QueueSize(Queue* pq)
{
	assert(pq);

	/*int size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		cur = cur->next;
		++size;
	}

	return size;*/

	return pq->size;
}

typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* obj=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);

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

int myStackPop(MyStack* obj) {
    assert(obj);
    Queue* Emptyq=&obj->q1;
    Queue* noEmpty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        Emptyq = &obj->q2;
        noEmpty = &obj->q1;
    }
    while(noEmpty->head!=noEmpty->tail)
    {
        QDataType ret = QueueFront(noEmpty);
        QueuePop(noEmpty);
        QueuePush(Emptyq,ret);
    }
    QDataType del=QueueFront(noEmpty);
    QueuePop(noEmpty);
    return del;
}

int myStackTop(MyStack* obj) {
    assert(obj);
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    assert(obj);
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    assert(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)用栈实现队列

在这里插入图片描述

思路：我们可以模仿以下上面的思路，但是我们肯定需要做一些改动。
我们通过画图，产生一个思路
我们的两个栈，分为插入栈和删除栈。
只要插入数据我们就将数据放到插入栈中，
想要删除数据，如果删除栈为空，就将插入栈的全部数据放到删除栈，然后再删除数据，知道删除栈为空，再重复操作。

typedef struct {
    ST PushST;
    ST PopST;

} MyQueue;


int myQueuePeek(MyQueue* obj);
bool myQueueEmpty(MyQueue* obj);
MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->PushST);
    StackInit(&obj->PopST);
    return obj;
}

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

int myQueuePop(MyQueue* obj) {
    assert(obj);
    assert(!myQueueEmpty(obj));

    int peek = myQueuePeek(obj);
    StackPop(&obj->PopST);
    return peek;
}

int myQueuePeek(MyQueue* obj) {
    assert(obj);
    assert(!myQueueEmpty(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) {
    assert(obj);
    return StackEmpty(&obj->PushST)&&StackEmpty(&obj->PopST);
}

void myQueueFree(MyQueue* obj) {
    assert(obj);
    StackDestroy(&obj->PushST);
    StackDestroy(&obj->PopST);
    free(obj);
    obj=NULL;

}

因为我们是c语言，所以我们要把自己的写的栈也链接进去，所以完整代码就是

typedef char STDataType;

typedef struct Stack
{
	STDataType* a;
	int capacity;
	int top;//表示栈顶
}ST;

//栈的初始化
void StackInit(ST* ps);
//栈的销毁
void StackDestroy(ST* ps );
//栈的插入
void StackPush(ST* ps, STDataType x);
//栈的删除
void StackPop(ST* ps);
//判断栈是否为空
bool StackEmpty(ST* ps);
//取栈顶的元素
STDataType StackTop(ST* ps);
//看栈的大小
int StackSize(ST* ps);



//栈的初始化
void StackInit(ST* ps)
{
	assert(ps);
	//ps->a = NULL;
	//ps->sz = 0;
	//ps->top = 0;

	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		perror("malloc error");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;
}


//栈的销毁
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
//栈的插入
void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	//扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity * 2;
		STDataType* ret = (STDataType*)realloc(ps->a,sizeof(STDataType) * newcapacity);
		if (ret == NULL)
		{
			perror("realloc error");
			exit(-1);
		}
		ps->a = ret;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
//栈的删除
void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}
//判断栈是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);
	//if (ps->top == 0)
	//{
	//	return true;
	//}
	//else
	//{
	//	return false;
	//}
	return ps->top == 0;
}
//取栈顶的元素
STDataType StackTop(ST* ps)
{
	assert(ps);
	//返会top下一个元素
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}
//看栈的大小
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

typedef struct {
    ST PushST;
    ST PopST;

} MyQueue;


int myQueuePeek(MyQueue* obj);
bool myQueueEmpty(MyQueue* obj);
MyQueue* myQueueCreate() {
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->PushST);
    StackInit(&obj->PopST);
    return obj;
}

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

int myQueuePop(MyQueue* obj) {
    assert(obj);
    assert(!myQueueEmpty(obj));

    int peek = myQueuePeek(obj);
    StackPop(&obj->PopST);
    return peek;
}

int myQueuePeek(MyQueue* obj) {
    assert(obj);
    assert(!myQueueEmpty(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) {
    assert(obj);
    return StackEmpty(&obj->PushST)&&StackEmpty(&obj->PopST);
}

void myQueueFree(MyQueue* obj) {
    assert(obj);
    StackDestroy(&obj->PushST);
    StackDestroy(&obj->PopST);
    free(obj);
    obj=NULL;

}

(4)设计循环队列

在这里插入图片描述

思路：我们的循环队列，可以有两种方式，一种是数组，一种是链表，我们想要采用哪种，需要我们自己分析，分析我们的思路，以及每一步的操作的对于那种方法好。

我们如果要用链表，我们可以完成这个循环，先进先出，我们就需要两个指针，一个头指针，一个尾指针。
我们先这可以判断，队列为空的条件是head = tail,但是我们如果链表满了，我们的条件就还是这个，判断不了是空，还是满，所以解决办法是可以设置一个sz，我们还可以增加一个结点，然后等满的时候我们的条件就是tail->next=head.
我们队首的元素就是head所指的元素，我们的队尾元素就是我们tail的上一个元素，所以我们这个不好找，解决方法是我们在遍历的时候留下我们的上一个元素地址，我们就可以找到了。
我们在删除链表的时候，还得遍历链表，太复杂了，我们就可以选择顺序表，我们就可以进行下标的随机访问。

我们在进行顺序表的时候，我们在创建空间的时候我们也多创建一个空间
在这里插入图片描述
我们要找front我们就直接找下标对应的元素，找rear的下一个元素，我们插入数据直接在rear上插入，删除数据在front直接向前挪一。我们唯一要注意的就是我们的内容满了就不能在添加了。

typedef struct {
    int* a;
    int front;
    int rear;
    int k;

} MyCircularQueue;




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

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    assert(obj);
    return obj->rear==obj->front;
}

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

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front=(obj->front+1)%(obj->k+1);
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    return obj->a[(obj->rear+obj->k)%(obj->k+1)];
}


void myCircularQueueFree(MyCircularQueue* obj) {
    assert(obj);
    free(obj->a);
    free(obj);
}

总结

我们的栈和队列问题，这些题是关键。大家多多练习，大家一起加油。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【8】AMBA_SOC项目自学IC验证项目-仿真平台脚本使用讲解

【8】AMBA_SOC项目自学IC验证项目-仿真平台脚本使用讲解

仿真平台文件介绍和脚本使用说明 1、项目路径：2、文件夹说明：3、仿真运行命令：第一步：进入项目路径第二步：设置环境第三步：运行仿真第四步：查看波形1、项目路径： 位置：/tool/project/axi 2、文件夹说明： a、env就是放的我们uvm环境相关的env文件； b、out就是我们…
阅读更多...
deque容器,const_iterator

deque容器,const_iterator

目录 1.deque构造函数，容器中数据不修改的方法，const_iterator​编辑 2.deque赋值，，assign 3.deque大小的操作,empty,size,resize 4.deque容器插入和删除，push_back,push_front,pop_back,pop_front,insert,clear,era…
阅读更多...
nginx反向代理+负载均衡上传webshell重难点+apache漏洞

nginx反向代理+负载均衡上传webshell重难点+apache漏洞

nginx反向代理 nginx 负载均衡 负载均衡的策略 1、轮询：nginx默认就是轮询其权重都默认为1，服务器处理请求的顺序：ABABABABAB… upstream mysvr { server 192.168.137.131; server 192.168.137.136; }2、weight：跟据配置…
阅读更多...
从ReentrantLock的实现看AQS的原理及应用

从ReentrantLock的实现看AQS的原理及应用

本文转载自：https://tech.meituan.com/2019/12/05/aqs-theory-and-apply.html 作者：美团技术团队 文章目录前言1 . ReentrantLock1.1 ReentrantLock特性概览1.2 Reentrant Lock与AQS的关联2 . AQS2.1 原理概览2.1.1 AQS 数据结构2.1.2 同步状态State2.2 …
阅读更多...
数据结构——哈夫曼树编程，输入权值实现流程图代码

数据结构——哈夫曼树编程，输入权值实现流程图代码

一、须知 本代码是在数据结构——哈夫曼树编程上建立的，使用时需将代码剪切到C等软件中。需要输入权值方可实现流程图，但是还需要按照编程换算出的结果自己用笔画出流程图。 下面将代码粘贴到文章中，同时举一个例子：二、代…
阅读更多...
ChatGPT留给知乎、小红书的时间不多了

ChatGPT留给知乎、小红书的时间不多了

大家好啊，今天我打算给大家整点好活！挑战一下用ChatGPT打入各平台内部。 知乎挑战！ 首先了解一下“知乎体” 知乎体是以专业知识为基础，以清晰的条理对问题进行阐述，并解决该问题的文体格式。对于不能明确给出答案的…
阅读更多...
【Linux 信号】信号的产生方式、信号的捕捉的全过程

【Linux 信号】信号的产生方式、信号的捕捉的全过程

信号的处理方式是远远比信号的产生当闹钟响了就知道时间到了，说明对应信号处理方法比信号产生更早操作系统的信号处理方法在编写操作系统的时候就已经编写好了signal函数1.1所有的信号1.2 signal函数的概念和简单使用捕捉信号就是自定义对应的信号的处理方法9号信号…
阅读更多...
【ArcGIS Pro二次开发】(1)：开发环境配置

【ArcGIS Pro二次开发】(1)：开发环境配置

要想进行ArcGIS Pro的二次开发，需要安装【Visual Studio】、【ArcGIS Pro】软件和【ArcGIS Pro SDK】组件。在版本选择上，我选了最新的ArcGIS Pro3.0，对应的VS版本为Visual Studio 2022。 一、Visual Studio2022的安装 1、前往官网https://v…
阅读更多...
【STM32】【HAL库】遥控关灯0 概述

【STM32】【HAL库】遥控关灯0 概述

相关连接 【STM32】【HAL库】遥控关灯0 概述 【STM32】【HAL库】遥控关灯1主机 【STM32】【HAL库】遥控关灯2 分机 【STM32】【HAL库】遥控关灯3 遥控器 需求 家里有几个房间,开关距离床都挺远的 睡觉想要关灯的时候需要下床 因此设计了本次项目 需要满足以下要求: 可以控…
阅读更多...
【C1】数据类型，常量变量，输入输出，运算符，if/switch/循环，/数组，指针，/结构体，文件操作，/编译预处理，gdb，makefile，线程

【C1】数据类型，常量变量，输入输出，运算符，if/switch/循环，/数组，指针，/结构体，文件操作，/编译预处理，gdb，makefile，线程

文章目录1.数据类型：单双引号，char（1B），int/float（32位系统，大小一样4B，但存储方式不同），double（8B），long double&#xf…
阅读更多...
补充一些前端面试题

补充一些前端面试题

javascript有哪些库指路>js中的库uniapp和vue有什么区别什么是uniappuni-app（uni，读you ni，是统一的意思）是一个使用Vue.js开发所有前端应用的框架，开发者编写一套代码，可发布到iOS、Android、Web&#…
阅读更多...
天工开物 #5 我的 Linux 开发机

天工开物 #5 我的 Linux 开发机

首先说一下结论：最终我选择了基于 Arch Linux[1] 的 Garuda Linux[2] 发行版作为基础来搭建自己的 Linux 开发机。Neofetch 时刻发行版的选择在上周末的这次折腾里，我一共尝试了 Garuda Linux 发行版，原教旨的 Arch Linux 发行版，…
阅读更多...
R语言读取Excel表格数据并绘制多系列柱状图、条形图

R语言读取Excel表格数据并绘制多系列柱状图、条形图

本文介绍基于R语言中的readxl包与ggplot2包，读取Excel表格文件数据，并绘制具有多个系列的柱状图、条形图的方法。 首先，我们配置一下所需用到的R语言readxl包与ggplot2包；其中，readxl包是用来读取Excel表格文件数据的&…
阅读更多...
android---WebView实例

android---WebView实例

现在很多 App 里都内置了 Web 网页，比如电商平台淘宝、京东等。那么这种该如何实现呢？其实这是 Android 里一个叫 WebView 的组件实现的。下面将介绍 WebView 的实例。下面的实例是以组件化为基础搭建的。 新建项目 WebView，然后对整个项目做…
阅读更多...
网络安全攻防中，Rock-ON自动化的多功能网络侦查工具，Burpsuite被动扫描流量转发

网络安全攻防中，Rock-ON自动化的多功能网络侦查工具，Burpsuite被动扫描流量转发

网络安全攻防中，Rock-ON自动化的多功能网络侦查工具，Burpsuite被动扫描流量转发。 #################### 免责声明：工具本身并无好坏，希望大家以遵守《网络安全法》相关法律为前提来使用该工具，支持研究学习&#xff…
阅读更多...
linux003之远程操作

linux003之远程操作

Xshell简介： Xshell 是一个强大的安全终端模拟软件，它支持SSH1, SSH2, 以及Microsoft Windows 平台的TELNET 协议。Xshell 通过互联网到远程主机，可以操控到linux服务器。　　Xshell可以在Windows界面下用来访问远端不同系统下的服务器&#…
阅读更多...
一些常见错误

一些常见错误

500状态码: 代表服务器业务代码出错, 也就是执行controller里面的某个方法的过程中报错, 此时在IDEA的控制台中会显示具体的错误信息, 所以需要去看IDEA控制台的报错404状态码: 找不到资源找不到静态资源 检查请求地址是否拼写错误 检查静态资源的位置是否正确 如果以上都没有问…
阅读更多...
Docker中安装Oracle-12c

Docker中安装Oracle-12c

前言 MySQL和Oracle是开发中常用到的两个关系型数据库管理系统，接上一期内容，这一期在Docker中完成oracle-12c的安装和配置。 安装oracle-12c 1、拉取oracle-12c镜像 启动Docker Desktop后在cmd窗口中执行docker search oracle命令，搜索O…
阅读更多...
LeetCode-1138. 字母板上的路径【哈希表，字符串】

LeetCode-1138. 字母板上的路径【哈希表，字符串】

LeetCode-1138. 字母板上的路径【哈希表，字符串】题目描述：解题思路一：首先考虑坐标位置，字符是有序的从0开始，当前字符c的行为(c-a)/5,列为(c-a)%5。其次是考虑特殊情况z。若当前从‘z’开始则只能往上走;若是其他字符…
阅读更多...
Spring MVC 之返回数据（静态页面、非静态页面、JSON对象、请求转发与请求重定向）

Spring MVC 之返回数据（静态页面、非静态页面、JSON对象、请求转发与请求重定向）

文章目录1. 默认情况下返回静态页面2. 返回一个非静态页面的数据2.1 ResponseBody 返回页面内容2.2 RestController ResponseBody Controller3. 实现登录功能，返回 JSON 对象3.1 前端使⽤ ajax，后端返回 json 给前端3.2 前端发送 JSON 的标准格式4. 请…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023