数据结构:3_栈和队列

news2024/11/18 6:23:36

栈和队列

一.栈

1. 栈的概念及结构

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

在这里插入图片描述

在这里插入图片描述

2. 栈的实现

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

在这里插入图片描述

在这里插入图片描述

// 下面是定长的静态栈的结构，实际中一般不实用，所以我们主要实现下面的支持动态增长的栈
typedef int STDataType;
#define N 10
typedef struct Stack
{
 STDataType _a[N];
 int _top; // 栈顶
}Stack;
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
 STDataType* _a;
 int _top; // 栈顶
 int _capacity; // 容量
}Stack;
// 初始化栈
void StackInit(Stack* ps); 
// 入栈
void StackPush(Stack* ps, STDataType data); 
// 出栈
void StackPop(Stack* ps); 
// 获取栈顶元素
STDataType StackTop(Stack* ps); 
// 获取栈中有效元素个数
int StackSize(Stack* ps); 
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps); 
// 销毁栈
void StackDestroy(Stack* ps);

//栈的实现
typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;		// 标识栈顶位置的
	int capacity;
}ST;

void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->capacity = 0;
	// 表示top指向栈顶元素的下一个位置
	pst->top = 0;
	// 表示top指向栈顶元素
	//pst->top = -1;
}

void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

// 栈顶插入删除
void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}

void STPop(ST* pst)
{
	assert(pst);
	// 不为空
	assert(pst->top > 0);
	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	// 不为空
	assert(pst->top > 0);
	return pst->a[pst->top - 1];
}

bool STEmpty(ST* pst)
{
	assert(pst);
	/*if (pst->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/
	return pst->top == 0;
}

int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}
  • 注意:
    在这里插入图片描述

二.队列

1. 队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头
在这里插入图片描述

2. 队列的实现

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

// 链式结构：表示队列
typedef struct QListNode
{ 
 struct QListNode* _pNext; 
 QDataType _data; 
}QNode; 
// 队列的结构
typedef struct Queue
{ 
 QNode* _front; 
 QNode* _rear; 
}Queue; 
// 初始化队列
void QueueInit(Queue* q); 
// 队尾入队列
void QueuePush(Queue* q, QDataType data); 
// 队头出队列
void QueuePop(Queue* q); 
// 获取队列头部元素
QDataType QueueFront(Queue* q); 
// 获取队列队尾元素
QDataType QueueBack(Queue* q); 
// 获取队列中有效元素个数
int QueueSize(Queue* q); 
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q); 
// 销毁队列
void QueueDestroy(Queue* q);

//队列的实现
typedef int QDataType;
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

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

	if (pq->ptail == NULL)
	{
		pq->ptail = pq->phead = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}

	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	QNode* del = pq->phead;
	pq->phead = pq->phead->next;
	free(del);
	del = NULL;

	if (pq->phead == NULL)
		pq->ptail = NULL;

	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->val;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);
	return pq->ptail->val;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead == NULL;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

三.栈和队列面试题

1. 有效的括号

https://leetcode.cn/problems/valid-parentheses/description/

typedef char STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;       //标识栈顶位置的
	int capacity;
}ST;

void STInit(ST* pst);
void STDetory(ST* pst);
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
STDataType STTop(ST* pst);
bool STEmpty(ST* pst);
int STSize(ST* pst);

void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->capacity = 0;
	// 表示top指向栈顶元素的下一个位置
	pst->top = 0;
	// 表示top指向栈顶元素
	//pst->top = -1;
}

void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}

void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->a[pst->top - 1];
}

bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}

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

bool isValid(char* s) {

    ST st;
    STInit(&st);
    while(*s)
    {
        //顺序不匹配
        if(*s=='('||*s=='['||*s=='{')
        {
            STPush(&st,*s);
        }
        else
        {
            if(st.top==0)
            {
                STDestroy(&st);
                return false;
            }
            char top=STTop(&st);
            STPop(&st);
            if(*s==')'&&top!='('||
               *s==']'&&top!='['||
               *s=='}'&&top!='{')
               {
                   STDestroy(&st);
                   return false;
               }
        }
        s++;
    }
    if(st.top!=0)
    {
        STDestroy(&st);
        return false;
    }
    STDestroy(&st);
    return true;
}

2. 用队列实现栈

https://leetcode.cn/problems/implement-stack-using-queues/description/

    1. 一个队列存数据
    1. 另一个队列用来出数据时，导数据
typedef int QDataType;
typedef struct QueueNode
{
	QDataType val;
	struct QueueNode* next;
}QNode;

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	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->phead = pq->ptail = NULL;
	pq->size = 0;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

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

	if (pq->ptail == NULL)
	{
		pq->ptail = pq->phead = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}

	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	QNode* del = pq->phead;
	pq->phead = pq->phead->next;
	free(del);
	del = NULL;

	if (pq->phead == NULL)
		pq->ptail = NULL;

	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->val;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);
	return pq->ptail->val;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead == NULL;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}


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


MyStack* myStackCreate() {
    MyStack* pst=(MyStack*)malloc(sizeof(MyStack));
    QueueInit(&pst->q1);
    QueueInit(&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* emptyq=&obj->q1;
    Queue* nonemptyq=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        emptyq=&obj->q2;
        nonemptyq=&obj->q1;
    }
    while(QueueSize(nonemptyq)>1)
    {
        QueuePush(emptyq,QueueFront(nonemptyq));
        QueuePop(nonemptyq);
    }
    int top=QueueFront(nonemptyq);
    QueuePop(nonemptyq);
    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);
    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. 用栈实现队列

https://leetcode.cn/problems/implement-queue-using-stacks/

//法一:
typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;		// 标识栈顶位置的
	int capacity;
}ST;

void STInit(ST* pst);
void STDestroy(ST* pst);

// 栈顶插入删除
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
STDataType STTop(ST* pst);

bool STEmpty(ST* pst);
int STSize(ST* pst);

void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->capacity = 0;
	// 表示top指向栈顶元素的下一个位置
	pst->top = 0;
	// 表示top指向栈顶元素
	//pst->top = -1;
}

void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

// 栈顶插入删除
void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}

void STPop(ST* pst)
{
	assert(pst);
	// 不为空
	assert(pst->top > 0);
	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	// 不为空
	assert(pst->top > 0);
	return pst->a[pst->top - 1];
}

bool STEmpty(ST* pst)
{
	assert(pst);
	/*if (pst->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/
	return pst->top == 0;
}

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



typedef struct {
    ST q1;
    ST q2;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* pst=(MyQueue*)malloc(sizeof(MyQueue));
    STInit(&pst->q1);
    STInit(&pst->q2);
    return pst;
}

void myQueuePush(MyQueue* obj, int x) {
    if(!STEmpty(&obj->q1))
    {
        STPush(&obj->q1,x);
    }
    else
    {
        STPush(&obj->q2,x);
    }
}

int myQueuePop(MyQueue* obj) {
    ST* emptyq=&obj->q1;
    ST* nonemptyq=&obj->q2;
    if(!STEmpty(&obj->q1))
    {
        emptyq=&obj->q2;
        nonemptyq=&obj->q1;
    }
    while(STSize(nonemptyq)>0)
    {
        STPush(emptyq,STTop(nonemptyq));
        STPop(nonemptyq);
    }
    int top =STTop(emptyq);
    STPop(emptyq);
    while(STSize(emptyq)>0)
    {
        STPush(nonemptyq,STTop(emptyq));
        STPop(emptyq);
    }
    return top;
}

int myQueuePeek(MyQueue* obj) {
    ST* emptyq=&obj->q1;
    ST* nonemptyq=&obj->q2;
    if(!STEmpty(&obj->q1))
    {
        emptyq=&obj->q2;
        nonemptyq=&obj->q1;
    }
    while(STSize(nonemptyq)>0)
    {
        STPush(emptyq,STTop(nonemptyq));
        STPop(nonemptyq);
    }
    int top =STTop(emptyq);
    while(STSize(emptyq)>0)
    {
        STPush(nonemptyq,STTop(emptyq));
        STPop(emptyq);
    }
    return top;
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->q1)&&STEmpty(&obj->q2);
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->q1);
    STDestroy(&obj->q2);
    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);
*/

//法二:
typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;		// 标识栈顶位置的
	int capacity;
}ST;

void STInit(ST* pst);
void STDestroy(ST* pst);

// 栈顶插入删除
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
STDataType STTop(ST* pst);

bool STEmpty(ST* pst);
int STSize(ST* pst);

void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->capacity = 0;
	// 表示top指向栈顶元素的下一个位置
	pst->top = 0;
	// 表示top指向栈顶元素
	//pst->top = -1;
}

void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}

// 栈顶插入删除
void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}

void STPop(ST* pst)
{
	assert(pst);
	// 不为空
	assert(pst->top > 0);
	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	// 不为空
	assert(pst->top > 0);
	return pst->a[pst->top - 1];
}

bool STEmpty(ST* pst)
{
	assert(pst);
	/*if (pst->top == 0)
	{
		return true;
	}
	else
	{
		return false;
	}*/
	return pst->top == 0;
}

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



typedef struct {
    ST pushst;
    ST popst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* pst=(MyQueue*)malloc(sizeof(MyQueue));
    STInit(&pst->pushst);
    STInit(&pst->popst);
    return pst;
}

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

int myQueuePop(MyQueue* obj) {
    int top;
    if(!STEmpty(&obj->popst))
    {
        top =STTop(&obj->popst);
        STPop(&obj->popst);
    }
    else
    {
        while(STSize(&obj->pushst)>0)
        {
            STPush(&obj->popst,STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
        top =STTop(&obj->popst);
        STPop(&obj->popst);
    }
    return top;
}

int myQueuePeek(MyQueue* obj) {
    int top;
    if(!STEmpty(&obj->popst))
    {
        top =STTop(&obj->popst);
    }
    else
    {
        while(STSize(&obj->pushst)>0)
        {
            STPush(&obj->popst,STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
        top =STTop(&obj->popst);
    }
    return top;
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->pushst)&&STEmpty(&obj->popst);
}

void myQueueFree(MyQueue* obj) {
    STDestroy(&obj->pushst);
    STDestroy(&obj->popst);
    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);
*/

4. 设计循环队列

https://leetcode.cn/problems/design-circular-queue/description/

typedef struct {
    int* a;
    int front;
    int back;
    int k;
} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

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

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

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    obj->front=(obj->front+1)%(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;
    }
    if(obj->back==0)
    {
        return obj->a[obj->k];
    }
    else
    {
        return obj->a[obj->back-1];
    }
}

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

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->back+1)%(obj->k+1)==obj->front;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    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.coloradmin.cn/o/1407240.html

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

相关文章

【QML-Qt Design Studio】

【QML-Qt Design Studio】

QML编程指南 ■ Qt Design Studio （Qt Quick UI设计工具）■ 安装Qt Design Studio■ ■ Qt Design Studio （Qt Quick UI设计工具） Qt Design Studio是一个用于创建酷炫、优美UI的工具。 简单概括其功能就是让UI设计转换为qml&…
阅读更多...
uniapp+vue3+ts--编写微信小程序对接e签宝签署时跳转刷脸效果（人脸识别）中间页代码

uniapp+vue3+ts--编写微信小程序对接e签宝签署时跳转刷脸效果（人脸识别）中间页代码

uniappvue3ts–编写微信小程序对接e签宝签署时跳转刷脸效果（人脸识别）中间页代码 e签宝内嵌H5方式集成签署页的文档说明：https://open.esign.cn/doc/opendoc/case3/ahb0sg 签署时跳转刷脸效果示意图： 1. 在文件夹新建一个文件&a…
阅读更多...
java基础：有序数组中插入数字使其依然有序案例分析

java基础：有序数组中插入数字使其依然有序案例分析

问题目标是将用户输入的整数插入到一个已排序的数组中，以保持数组的有序性。 如何实现？ 思路分析： 初始化已排序的数组：通过使用int[] arr {1, 2, 3, 4, 5, 6};语句创建一个已经排好序的数组。定义变量：index用于记…
阅读更多...
2024年制造业展望

2024年制造业展望

制造业是国民经济的主体，其重要性不言而喻。就2023年而言，制造业在技术创新、数字化转型和可持续发展方面都取得了重要的进展。以下是对于2024年制造业的发展进行的分析与预测。 1 保持业务平衡仍将是一项挑战 在过去的四年里，制造业高管人…
阅读更多...
【IEEE会议征稿】2024年第九届智能计算与信号处理国际学术会议（ICSP 2024）

【IEEE会议征稿】2024年第九届智能计算与信号处理国际学术会议（ICSP 2024）

2024年第九届智能计算与信号处理国际学术会议（ICSP 2024） 2024年第八届智能计算与信号处理国际学术会议（ICSP 2024）将在西安举行， 会期是2024年4月19-21日， 为期三天, 会议由西安科技大学主办。 欢迎参会&…
阅读更多...
Django开发_17_表单类

Django开发_17_表单类

一、介绍 为了简化前端form表单代码 二、步骤 （一）创建form.py 创建一个表单类 from django import formsclass RegisterForm(forms.Form):reg_name forms.CharField(max_length10, label用户名)reg_pwd forms.CharField(max_length20, label密码…
阅读更多...
【Pandora Next Notebook】

【Pandora Next Notebook】

系列文章目录 一是为了说一说这个项目，第二点是为了介绍一下如何使用大善人Cloudflare的功能来配合v0.5.0的新功能。它就是全代理ChatXXX账号注册流程。 文章目录 系列文章目录前言一、[GPT_BOT](https://chat.oaifree.com/)这次借着v0.5.0发布了一个好玩的功能&…
阅读更多...
配网故障定位装置：实现高效故障排查的利器

配网故障定位装置：实现高效故障排查的利器

在现代社会，电力系统的稳定运行对于国家经济和民生至关重要。然而，随着电力系统的不断发展，配网故障问题日益严重，给电力系统带来了巨大的安全隐患。为了解决这一问题，恒峰智慧科技研发了一种基于成熟的行波测距技术的…
阅读更多...
Vue+OpenLayers7：html原生网页如何使用OpenLayers7地图

Vue+OpenLayers7：html原生网页如何使用OpenLayers7地图

返回《Vue+OpenLayers7》专栏目录：Vue+OpenLayers7 前言 尽管现在大部分网页都是使用Vue或者React开发了，但是还是有不少开发者使用的是网页原生html进行开发，或者是老项目维护的需要，所以为了照顾使用html原生网页的同学们，本章简单讲解一下如何使用原始html网页情况下…
阅读更多...
1. Matplotlib的Figure基础概念

1. Matplotlib的Figure基础概念

1. Matplotlib的Figure基础概念 一 **角色和作用**二 **类比：**三 **基本使用示例** Matplotlib是一个用于绘制二维图形的Python库，广泛应用于数据可视化领域。其灵活性和强大的功能使得用户能够轻松创建各种类型的图表，包括折线图、散点图、…
阅读更多...
el-select选择之后值不显示在文本框的问题解决

el-select选择之后值不显示在文本框的问题解决

问题场景如下图： 在el-collapse-item中使用子组件，子组件里是el-form-item代码。el-select在for循环中，可以有多个。 查了一下博客，有的说这种场景需要给el-select添加change事件，加上 this.$forceUpdate() 强制刷新即…
阅读更多...
Spring Boot 中的外部化配置

Spring Boot 中的外部化配置

Spring Boot 中的外部化配置 一、配置文件基础1.配置文件格式（1）YAML 基本语法规则（2）YAML 支持三种数据结构 2.application 文件3.application.properties 配置文件4.application.yml 配置文件5.Environment6.组织多文件7.多环境…
阅读更多...
创新医疗服务：宠物在线问诊系统的搭建与应用

创新医疗服务：宠物在线问诊系统的搭建与应用

随着科技的不断进步，创新的医疗服务方式也日渐成为宠物主人关心爱宠健康的首选。本文将深入介绍如何搭建一套创新的宠物在线问诊系统，并展示其应用的技术代码。 1. 系统架构与技术选择 在开始搭建之前，我们需要设计系统的架构并选择合适的…
阅读更多...
码农维权——案例分析之违法解除劳动合同(六)

码农维权——案例分析之违法解除劳动合同(六)

目录 一、背景 二、案例分析：违法解除劳动合同 A、公司的主张 B、公司的主要证据（公司单方面提交的，法院不一定认可采纳） C、员工的质证/证据 D、判决结果 E、判决依据 三、写在最后 一、背景 当前互联网行业普遍以”变相…
阅读更多...
Vue开始封装全局防抖和节流函数

Vue开始封装全局防抖和节流函数

封装文件 封装文件的实现思路如下： 首先，我们需要定义两个函数：防抖函数和节流函数。这两个函数的目的是为了减少频繁触发某个事件导致的性能问题；防抖函数的实现思路是创建一个计时器变量，用于延迟执行函数。当触发…
阅读更多...
c# ADODB.Recordset实例调用Fields报错

c# ADODB.Recordset实例调用Fields报错

代码： using System; using System.CodeDom; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using ADODB;namespace ConsoleApp1 {internal class Programre{static ADODB.Recordset recordsetInstance…
阅读更多...
trino-435: trino接入TIDB数据源

trino-435: trino接入TIDB数据源

文章目录 一、TIDB介绍二、TIDB源接入流程三、遇到的错误1、数据源注册：2、查询表数据一、TIDB介绍 二、TIDB源接入流程 三、遇到的错误 1、数据源注册： http://localhost:8080/v1/catalog/register?name=tidb_test {"connector.name":"tidb",&quo…
阅读更多...
NodeJs中要注意onClick的函数调用写法

NodeJs中要注意onClick的函数调用写法

在一个测试页面写简单的测试函数时候，遇到一个页面刷新问题。同一个函数被调用了几次。 const [msg, setMsg] React.useState("");async function updateGoodsQty2() {...setMsg(rsp.message)}async function updateGoodsQty3() {...setMsg(rsp.message)…
阅读更多...
Elasticsearch分布式一致性原理剖析(一)-节点篇

Elasticsearch分布式一致性原理剖析(一)-节点篇

前言 “Elasticsearch分布式一致性原理剖析”系列将会对Elasticsearch的分布式一致性原理进行详细的剖析，介绍其实现方式、原理以及其存在的问题等(基于6.2版本)。 ES目前是最流行的分布式搜索引擎系统，其使用Lucene作为单机存储引擎并提供强大的搜索查…
阅读更多...
从零开始学Python第02课：第一个Python程序

从零开始学Python第02课：第一个Python程序

在上一课中，我们对 Python 语言的过去现在有了一些了解，我们准备好了运行 Python 程序所需要的解释器环境。相信大家已经迫不及待的想开始自己的 Python 编程之旅了，但是新问题来了，我们应该在什么地方书写 Python 程序&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023