【数据结构】栈和队列OJ练习

news2025/8/6 4:07:21

文章目录

  • 1. 栈
    • 1.1 栈的概念及其结构
    • 1.2 栈的实现
      • Stack.h
      • Stack.c
      • Test.c
  • 2. 队列
    • 2.1 队列的概念及其结构
    • 2.2 队列的实现
      • Queue.h
      • Queue.c
      • Test.c
  • 3. 栈和队列面试题
    • 3.1 括号匹配问题
    • 3.2 用队列实现栈
    • 3.3 用栈实现队列
    • 3.4 设计循环队列

1. 栈

1.1 栈的概念及其结构

🐶 栈的定义：

一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

🐱 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。

🐭 出栈：栈的删除操作叫做出栈。出数据也在栈顶。

在这里插入图片描述

1.2 栈的实现

💖 栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小

在这里插入图片描述

在这里插入图片描述

Stack.h

#pragma once
#include<stdlib.h>
#include<assert.h>
#include<stdio.h>
#include<stdbool.h>
typedef int STDataType;
typedef struct Stak {
	STDataType* a;
	int top;
	int capacity;
}ST;

//初始化栈
void StackInit(ST* ps);

//销毁栈
void StackDestroy(ST* ps);

//元素入栈
void StackPush(ST* ps, STDataType x);

//元素出栈
void StackPop(ST* ps);

//取栈顶元素
STDataType StackTop(ST* ps);

//栈的判空操作
bool StackEmpty(ST* ps);

//返回栈中的元素个数
int StackSize(ST* ps);

Stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

//初始化栈
void StackInit(ST* ps)
{
	assert(ps);
	ST* tmp = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (!tmp){
		perror("malloc fail::");
		exit(-1);
	}
	else 
	{
		ps->a = tmp;
		ps->capacity = 4;
		ps->top = 0;
	}
}

//销毁栈
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->capacity = 0;
	ps->top = 0;
}

//元素入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//考虑是否需要扩容
	if (ps->capacity == ps->top)
	{
		int newcapacity = ps->capacity * 2;
		ST* tmp = realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (!tmp){
			perror("relloc fail::");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top++] = x;
}

//元素出栈
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

//取栈顶元素
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}

//栈的判空操作
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

//返回栈中的元素个数
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"
void StackTest1()
{
	ST st;
	StackInit(&st);
	printf("入栈：1 2 3 4 5");
	for (int i = 0; i < 5; i++) {
		StackPush(&st, i+1);//压栈
	}
	printf("\n出栈：");
	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));//取栈顶元素
		StackPop(&st);
	}
	StackDestroy(&st);
}
int main()
{
	StackTest1();
	return 0;
}

2. 队列

2.1 队列的概念及其结构

🐶 队列的定义：

只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有 先进先出FIFO(First In First Out) 的性质。

🐱 性质：入队列：进行插入操作的一端称为队尾。出队列：进行删除操作的一端称为队头

在这里插入图片描述

2.2 队列的实现

💖 队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

在这里插入图片描述

Queue.h

#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include<stdbool.h>
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);

Queue.c

#include"Queue.h"

//初始化队列
void QueueInit(Queue* pq)
{
    assert(pq);
    pq->head = 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);
    }
    pq->head = pq->tail = NULL;
}

//入队
void QueuePush(Queue* pq, QDataType x)
{
    assert(pq);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (NULL == newnode)
    {
        exit(-1);
    }
    else
    {
        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);
        del = NULL;
    }
    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;
}

//队列元素个数
int QueueSize(Queue* pq)
{
    return pq->size;
}

Test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"
void TestQueue()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	QueuePush(&q, 6);
	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);
	printf("队列中元素个数：%d\n", QueueSize(&q));
	printf("队头元素：%d\n", QueueFront(&q));
	printf("队尾元素：%d\n", QueueBack(&q));
	//打印队列中的元素
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	printf("\n队列是否为空：");
	int ret = QueueEmpty(&q);
	printf("%d\n", ret);
	QueueDestroy(&q);
}
int main()
{
	TestQueue();
	return 0;
}

3. 栈和队列面试题

3.1 括号匹配问题

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

💖 思路：

这道题目是一个典型的用栈解决的问题，题目的意思是让我们实现左右括号匹配的问题，我们知道栈的特性是先进后出，大致思路是这样的：

（1）题目给了我们一个字符串，我们需要遍历这个字符串，当遇到的字符是左括号时，我们就将它入栈，当遇到右括号时，我们先看栈是否为空栈，若为空栈，说明没有与之匹配的左括号。直接销毁栈并且返回false。

（2）若栈不为空，在进行匹配，如果匹配成功，先s++，并弹出栈顶的元素，然后在进行下一次入栈或者匹配操作；如果匹配失败，则说明整个字符串的括号是不匹配的，直接返回false即可。

💕 代码实现

这里我们需要注意的是，由于C语言中没有栈相关的库函数，所以我们需要先把上面实现的栈先拷贝一份拿来用。

typedef char STDataType;
typedef struct Stak {
	STDataType* a;
	int top;
	int capacity;
}ST;
//初始化栈
void StackInit(ST* ps);
//销毁栈
void StackDestroy(ST* ps);
//元素入栈
void StackPush(ST* ps, STDataType x);
//元素出栈
void StackPop(ST* ps);
//取栈顶元素
STDataType StackTop(ST* ps);
//栈的判空操作
bool StackEmpty(ST* ps);
//返回栈中的元素个数
int StackSize(ST* ps);
//初始化栈
void StackInit(ST* ps)
{
	assert(ps);
	ST* tmp = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (!tmp){
		perror("malloc fail::");
		exit(-1);
	}
	else {
		ps->a = tmp;
		ps->capacity = 4;
		ps->top = 0;
	}
}
void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->capacity = 0;
	ps->top = 0;
}
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//考虑是否需要扩容
	if (ps->capacity == ps->top)
	{
		int newcapacity = ps->capacity * 2;
		ST* tmp = realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (!tmp){
			perror("relloc fail::");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top++] = x;
}
void StackPop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
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 tmp=StackTop(&st);
            if((*s==')'&&tmp=='(')
            ||(*s==']'&&tmp=='[')
            ||(*s=='}'&&tmp=='{')){
                s++;
                StackPop(&st);
            }
            else
            {
                StackDestroy(&st);
                return false;
            }
        }
    }
    if(StackEmpty(&st))
        return true;
    return false;
}

在这里插入图片描述

3.2 用队列实现栈

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

💖 思路：

我们知道队列的性质是先进先出，而栈的性质却是后进先出，那么如何用两个队列来实现栈后进先出的功能呢？这就需要我们利用两个队列来相互导数据了。具体思路如下：

（1）先定义两个队列并初始化为空队列，始终往一个空队列中入数据，第一次入数据时，由于两个队列都为空，随便选一个入数据即可。

在这里插入图片描述

（2）myStackPop——弹出栈顶元素，定义两个指针empty和nonEmpty分别指向空队列和非空队列，将非空队列中的数据一一导入空队列，直到非空队列中剩下一个数据为止。这时非空队列中的那一个元素就相当于栈顶元素，将其返回则可以实现取栈顶元素，将此队列出队则为出栈操作。

在这里插入图片描述
（3）由于出栈时，其中一个队列已经置为了空队列，所以下次入栈时直接往另一个不为空的队列中入数据即可；取栈顶的元素即为非空队列中队尾的元素，直接将其返回即可。栈的判空操作即判断两个队列是否全部为空即可。

💕 代码实现：

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);
QDataType QueueSize(Queue*pq);


void QueueInit(Queue*pq)
{
    assert(pq);
    pq->head = 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);
    }
    pq->head = pq->tail = NULL;
}
void QueuePush(Queue*pq,QDataType x)
{
    assert(pq);
    QNode*newnode = (QNode*)malloc(sizeof(QNode));
    if(NULL == newnode)
    {
        exit(-1);
    }
    else
    {
        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);
        del = NULL;
    }
    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;
}
QDataType QueueSize(Queue*pq)
{
    return pq->size;
}

//定义了两个队列，一个为q1和q2
typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack*obj = (MyStack*)malloc(sizeof(MyStack));
    if(NULL == obj)
    {
        exit(-1);
    }
    QueueInit(&obj->q1);
    QueueInit(&obj->q2);
    return obj;
}

void myStackPush(MyStack* obj, int x) {
    //看哪个是否为空
    if(!QueueEmpty(&obj->q1))
    {
        //队列不为空就插入数据
        QueuePush(&obj->q1,x);
    }
    //q2可能为空或不为空
    else
    {
        QueuePush(&obj->q2,x);
    }
}

int myStackPop(MyStack* obj) {
    //删除栈顶的元素
    Queue*empty = &obj->q1;
    Queue*nonEmpty = &obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonEmpty = &obj->q1;
    }
    while(QueueSize(nonEmpty)>1)
    {
        //取队头数据存放到空的队列,最后剩下一个，这个就是栈顶的元素
        QueuePush(empty,QueueFront(nonEmpty));
        QueuePop(nonEmpty);
    }
    int top = QueueFront(nonEmpty);
    QueuePop(nonEmpty);
    return top;
}

int myStackTop(MyStack* obj) {
    //取栈的头相当于非空的队列的队尾
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        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);
}

在这里插入图片描述

3.3 用栈实现队列

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

💖 思路：

栈的性质是后进先出，队列的性质是先进先出，我们要使用两个栈来实现队列先进先出的性质，如果将一个栈中的元素导入另一个栈中，是不是另一个栈中的元素出栈时是不是就变成了队列的出队顺序呢？好了，具体思路如下：

（1）先定义两个空栈，一个栈用来入数据为push栈，另一个栈用来出数据为pop栈。第一次入数据时，将数据全部往push栈中入。

（2）myQueuePop——返回并移除队头元素，先判断pop栈是否为空，如果不为空，先将pop栈中的栈顶元素保存，然后在移除栈顶元素，最后返回此元素即可；如果pop栈为空，我们需要先将push栈中的元素导入pop栈中，然后在进行刚刚的操作即可。
在这里插入图片描述

（3）myQueuePeek——返回队头元素，要返回队头元素，如果pop栈为空，就必须先将push栈中的元素导入pop栈中，然后直接返回pop栈中的栈顶元素即可。否则只需要直接返回栈顶元素即可。

💖 代码实现：

typedef int STDataType;
typedef struct Stak {
	STDataType* a;
	int top;
	int capacity;
}ST;
//初始化栈
void StackInit(ST* ps);
//销毁栈
void StackDestroy(ST* ps);
//元素入栈
void StackPush(ST* ps, STDataType x);
//元素出栈
void StackPop(ST* ps);
//取栈顶元素
STDataType StackTop(ST* ps);
//栈的判空操作
bool StackEmpty(ST* ps);
//返回栈中的元素个数
int StackSize(ST* ps);
void StackInit(ST* ps)
{
	assert(ps);
	ST* tmp = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (!tmp){
		perror("malloc fail::");
		exit(-1);
	}
	else {
		ps->a = tmp;
		ps->capacity = 4;
		ps->top = 0;
	}
}

void StackDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->capacity = 0;
	ps->top = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	//考虑是否需要扩容
	if (ps->capacity == ps->top)
	{
		int newcapacity = ps->capacity * 2;
		ST* tmp = realloc(ps->a, sizeof(STDataType) * ps->capacity * 2);
		if (!tmp){
			perror("relloc fail::");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top++] = x;
}

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

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

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}

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

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


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) {
    if(StackEmpty(&obj->popST)){
        while(!StackEmpty(&obj->pushST))
        {
            StackPush(&obj->popST,StackTop(&obj->pushST));
            StackPop(&obj->pushST);
        }
    }
    int tmp=StackTop(&obj->popST);
    StackPop(&obj->popST);
    return tmp;
}

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->popST)&&StackEmpty(&obj->pushST);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->popST);
    StackDestroy(&obj->pushST);
    free(obj);
}

在这里插入图片描述

3.4 设计循环队列

这里我们先来介绍一下循环队列：循环队列是把顺序队列首尾相连，把存储队列元素的表从逻辑上看成一个环，成为循环队列。

在这里插入图片描述

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

💖 思路：

循环队列相对普通队列新增了一个队首的指针front，队尾的指针为tail，即初始化时队列的队首和队尾指向同一个位置。在入队时，队尾的指针不再是向后加一位，而是在向后加一位的基础上还要对队列的长度取余运算。因为当队尾的指针在最后一位时，如果此时队列未满，即表明队列前方还有空余的空间，所以此时队尾需要对队列长度取余回到队列头部空余的位置。

💕 代码实现：

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=obj->rear=0;
    obj->k=k;
    return obj;
}
//判断队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    assert(obj);
    return obj->front==obj->rear;
}
//判断队列是否已满
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)%(obj->k+1);
    return true;
}
//循环队列出数据
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    assert(obj);
    if(myCircularQueueIsEmpty(obj))
        return false;
    obj->front++;
    obj->front=obj->front%(obj->k+1);
    return true;
}
//返回队头数据
int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->a[obj->front];
}
//返回队尾数据
int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
        return -1;
    return obj->rear==0?obj->a[obj->k]:obj->a[obj->rear-1];
}
//释放队列
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

在这里插入图片描述

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

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

相关文章

《深度学习进阶 自然语言处理》第六章：LSTM介绍

《深度学习进阶 自然语言处理》第六章：LSTM介绍

文章目录6.1 RNN的问题6.1.1 RNN的复习6.1.2 梯度消失和梯度爆炸6.1.4 梯度爆炸的对策6.2 梯度消失和LSTM6.2.1 LSTM的接口6.2.2 LSTM层的结构6.2.3 输出门6.2.4 遗忘门6.2.5 新的记忆单元6.2.6 输入门6.2.7 LSTM的梯度的流动6.3 使用LSTM的语言模型6.3.1 LSTM层的多层化6.3.2 …
阅读更多...
乐华娱乐欲重返上市：毛利率走低，上半年利润下滑，韩庚为股东

乐华娱乐欲重返上市：毛利率走低，上半年利润下滑，韩庚为股东

撰稿|汤汤 来源|贝多财经 宣布暂缓香港IPO计划不到3个月&#xff0c;乐华娱乐&#xff08;HK:02306&#xff09;欲再度回归。 11月17日&#xff0c;港交所披露的信息显示&#xff0c;乐华娱乐集团&#xff08;YH Entertainment Group&#xff0c;简称“乐华娱乐”&#xff0…
阅读更多...
谈谈主数据管理的概念、原则、标准和指南

谈谈主数据管理的概念、原则、标准和指南

1主数据的定义和关键概念 1.1什么是主数据 主数据是不同业务领域的公共信息，并在多个业务流程中使用。主数据通常描述参与事务或事件的事物。示例包括有关课程、学生或雇员的信息。 参考数据通常用于对其他数据(如状态代码)进行分类，或与组织边界以外的信息(如国家列表)相…
阅读更多...
ctfhub -afr -1 2 3

ctfhub -afr -1 2 3

afr-1 打开题目链接 默认的传参数据为 ?phello 更改一下试试看 ?p111 无回显 ?pflag 回显了 no no no 想到了 php任意文件读取 ?pphp://filter/readconvert.base64-encode/resourceflag 回显出数据 应该是base64 拿去解码 得到flag afr-2 打开题目链接 查看源代码…
阅读更多...
【第一阶段：java基础】第8章：面向对象编程高级-1（P333-P393）static、main、代码块、单例设计模式

【第一阶段：java基础】第8章：面向对象编程高级-1（P333-P393）static、main、代码块、单例设计模式

本系列博客是韩顺平老师java基础课的课程笔记&#xff0c;B站&#xff1a;课程链接&#xff0c;吐血推荐的一套全网最细java教程&#xff0c;获益匪浅&#xff01; 韩顺平P333-P393类变量和类方法类变量/静态变量类方法/静态方法理解main方法语法代码块注意事项好处细节单例设计…
阅读更多...
Java接口

Java接口

什么是接口&#xff1f; 在Java中&#xff0c;接口可以看成是多个类的公共规范&#xff0c;是一种引用数据类型。 使用关键字interface来定义接口 interface IRunning {void run(); }在创建接口时&#xff0c;接口的命名一般以大写字母I开头&#xff0c;接口的命名一般使用形…
阅读更多...
【数据结构】栈和队列

【数据结构】栈和队列

文章目录栈和队列栈栈的概念及结构栈的实现初始化栈入栈出栈获取栈顶元素获取栈中有效元素个数判断栈是否为空销毁栈括号匹配问题队列队列的概念及结构队列的实现初始化队列队尾入队列对头出队列获取队头元素获取队尾元素销毁队列判断队列是否为空栈和队列 栈 栈的概念及结构…
阅读更多...
带你初识微服务

带你初识微服务

博客主页&#xff1a;踏风彡的博客 博主介绍&#xff1a;一枚在学习的大学生&#xff0c;希望在这里和各位一起学习。 所属专栏&#xff1a;SpringCloud 文章创作不易&#xff0c;期待各位朋友的互动&#xff0c;有什么学习问题都可在评论区留言或者私信我&#xff0c;我会尽我…
阅读更多...
同花顺_代码解析_技术指标_L

同花顺_代码解析_技术指标_L

本文通过对同花顺中现成代码进行解析&#xff0c;用以了解同花顺相关策略设计的思想 目录 LH_LYDG LH_猎鹰歼狐 LHBLX LHSJ LHTZ LHXJ LH猎狐雷达 LOF净值 LWR LH_LYDG 猎鹰渡关&#xff08;检测大盘顶部&#xff09; 指标用法&#xff1a; &#xff08;1&#xff…
阅读更多...
进程间的信号

进程间的信号

目录 一.信号入门 1.1概念 1.2信号发送与记录 1.3信号的处理方式 二.产生信号的方式 2.1通过终端按键产生 2.2通过系统函数向进程发信号 2.3由软件条件产生信号 2.4由硬件异常产生信号 三.阻塞信号 3.1信号相关概念 3.2信号在内核的表示 3.3sigset_t&#xff1a; 3.4…
阅读更多...
工具及方法 - 使用Total Commander来查找重名文件

工具及方法 - 使用Total Commander来查找重名文件

我只是一个Total Commander的轻度使用者&#xff0c;主要使用的是打开多个窗口&#xff0c;可以方便的以标签形式切换。 还有&#xff0c;这个软件是免费的&#xff0c;只是免费版打开时多一步&#xff0c;要输入个数字验证。 今天在使用一个SDK时&#xff0c;要包含进很多头文…
阅读更多...
论文阅读笔记《Locality Preserving Matching》

论文阅读笔记《Locality Preserving Matching》

核心思想 该文提出一种基于局部保持的特征匹配方法&#xff08;LPM&#xff09;。其核心思想是对于一个正确匹配点&#xff0c;其邻域范围内的其他匹配点与对应目标点之间的变换关系&#xff0c;应该和正确的匹配点保持一致&#xff0c;而错误匹配点&#xff0c;则应该有较大的…
阅读更多...
第一章《初学者问题大集合》第6节：IntelliJ IDEA的下载与安装

第一章《初学者问题大集合》第6节：IntelliJ IDEA的下载与安装

当完成了Java开发环境之后&#xff0c;各位读者就可以开始编写第一个Java程序了。可是应该在哪里写程序呢&#xff1f;早期的开发者们都是用纯文本编辑工具编写Java程序&#xff0c;并且在命令行窗口中编译和运行Java程序。时至今日&#xff0c;我们早已远离了那个程序开发的“…
阅读更多...
CentOs程序环境准备

CentOs程序环境准备

1. MySQL的安装启动 选择指定操作系统指定版本的mysql进行下载 MySQL :: Download MySQL Community Serverhttps://dev.mysql.com/downloads/mysql/5.7.html#downloads 选择复制下载链接 回到终端&#xff0c;执行此命令下载 wget https://dev.mysql.com/get/Downloads/MyS…
阅读更多...
举个栗子~Tableau 技巧（244）：用和弦图（Chord diagram）呈现数据关系

举个栗子~Tableau 技巧（244）：用和弦图（Chord diagram）呈现数据关系

关于和弦图 和弦图&#xff08;Chord diagram&#xff09;常用来表示数据之间的相互关系。数据点沿着圆圈分布&#xff0c;通过点和点之间相互连接的弧线来呈现相互之间的关系。和弦图从视觉上来说比较美观&#xff0c;数据呈现又很直观&#xff0c;所以深受数据粉喜爱。 之前…
阅读更多...
【Linux初阶】Linux调试器-gdb使用 | gdb的 l/b/info/d/r/n/s/bt/finish/p/(un)display/q

【Linux初阶】Linux调试器-gdb使用 | gdb的 l/b/info/d/r/n/s/bt/finish/p/(un)display/q

&#x1f31f;hello&#xff0c;各位读者大大们你们好呀&#x1f31f; &#x1f36d;&#x1f36d;系列专栏&#xff1a;【Linux初阶】 ✒️✒️本篇内容&#xff1a;gdb使用相关背景知识&#xff0c;gdb的使用&#xff08;打断点、查断点、消断点、调试运行、查看对应变量&…
阅读更多...
【python拼图游戏】图片自选，来挑战一下自己的极限吧~

【python拼图游戏】图片自选，来挑战一下自己的极限吧~

嗨害大家好鸭&#xff01;我是小熊猫❤ 拼图的画面多以自然风光、建筑物以及一些为人所熟识的图案的为题材。 城堡和山峦是两类传统的主题&#xff0c; 不过任何图画和影像都可以用做拼图的素材。 有一些公司还提供将私人摄影作品制成拼图的服务。 今天我小熊猫就给带来py…
阅读更多...
FFmpeg5.1 解码rtsp 并用OpenCV 播放

FFmpeg5.1 解码rtsp 并用OpenCV 播放

RTSP 连接过程如下图 看下实际过程中FFmpeg 的日志情况&#xff1a; [tcp 0000014CC3256D40] No default whitelist set [tcp 0000014CC3256D40] Original list of addresses: [tcp 0000014CC3256D40] Address ::1 port 8554 [tcp 0000014CC3256D40] Address 127.0.0.1 po…
阅读更多...
使用BP神经网络、RBF神经网络以及PSO优化的RBF神经网络对数据进行预测（Matlab代码实现）

使用BP神经网络、RBF神经网络以及PSO优化的RBF神经网络对数据进行预测（Matlab代码实现）

&#x1f352;&#x1f352;&#x1f352;欢迎关注&#x1f308;&#x1f308;&#x1f308; &#x1f4dd;个人主页&#xff1a;我爱Matlab &#x1f44d;点赞➕评论➕收藏 养成习惯&#xff08;一键三连&#xff09;&#x1f33b;&#x1f33b;&#x1f33b; &#x1f34c;希…
阅读更多...
Keysight是德科技E5061B网络分析仪-安泰测试

Keysight是德科技E5061B网络分析仪-安泰测试

E5061B ENA系列网络分析仪从5Hz 至3GHz提供了广泛的频率范围。它不仅支持一般的射频应用(例如滤波器或放大器测量等)&#xff0c;还支持低频应用(例如直流至直流转换器环路增益测量)。因此&#xff0c;它是所有实验台上进行网络分析的最重要工具。 拥有E5061B&#xff0c;您就…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023