数据结构:3_栈和队列

栈和队列

一.栈

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);
*/
  • 优化写法
    在这里插入图片描述

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

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

相关文章

软件测试知识库+1，5款顶级自动化测试工具推荐和使用分析

软件测试知识库+1，5款顶级自动化测试工具推荐和使用分析

“工欲善其事必先利其器”，在自动化测试领域，自动化测试工具的核心地位不容置疑的。目前市面上有很多可以支持接口测试的工具，在网上随便一搜就可以出来很多，利用自动化测试工具进行接口测试，可以很好的提高测试效率&a…
阅读更多...
GPT4+Python近红外光谱数据分析及机器学习与深度学习建模

GPT4+Python近红外光谱数据分析及机器学习与深度学习建模

详情点击链接：GPT4Python近红外光谱数据分析及机器学习与深度学习建模 第一：GPT4 1、ChatGPT（GPT-1、GPT-2、GPT-3、GPT-3.5、GPT-4模型的演变） 2、ChatGPT对话初体验 3、GPT-4与GPT-3.5的区别，以及与国内大语言模…
阅读更多...
最新AI系统ChatGPT网站H5系统源码，支持Midjourney绘画，GPT语音对话+ChatFile文档对话总结+DALL-E3文生图

最新AI系统ChatGPT网站H5系统源码，支持Midjourney绘画，GPT语音对话+ChatFile文档对话总结+DALL-E3文生图

一、前言 SparkAi创作系统是基于ChatGPT进行开发的Ai智能问答系统和Midjourney绘画系统，支持OpenAI-GPT全模型国内AI全模型。本期针对源码系统整体测试下来非常完美，那么如何搭建部署AI创作ChatGPT？小编这里写一个详细图文教程吧。已支持GPT…
阅读更多...
Django笔记（六）：DRF框架

Django笔记（六）：DRF框架

首 前后端分离是互联网应用开发的标准使用方式，让前后端通过接口实现解耦，能够更好的进行开发和维护。 RESTful接口常见规范 在接口设计中，大家遵循一定的规范可以减少很多不必要的麻烦，例如url应有一定辨识度，可以…
阅读更多...
（SSO单点登录）多个系统之间如何实现账号互通

（SSO单点登录）多个系统之间如何实现账号互通

SSO具有以下优点： 降低访问第三方网站风险；降低用户名和密码的管理成本；提高用户试用满意度；SSO使用标准的身份认证和授权协议，如OAuth、OpenID Connect等，可以保障用户身份的安全性和隐私性。 单点登录最大…
阅读更多...
Linux 驱动开发基础知识——认识LED驱动程序 （二）

Linux 驱动开发基础知识——认识LED驱动程序 （二）

个人名片： 🦁作者简介：一名喜欢分享和记录学习的在校大学生 🐯个人主页：妄北y 🐧个人QQ：2061314755 🐻个人邮箱：2061314755qq.com 🦉个人WeChat：V…
阅读更多...
el-select选择之后值不显示在文本框的问题解决

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

问题场景如下图： 在el-collapse-item中使用子组件，子组件里是el-form-item代码。el-select在for循环中，可以有多个。 查了一下博客，有的说这种场景需要给el-select添加change事件，加上 this.$forceUpdate() 强制刷新即…
阅读更多...
Vue3.0里为什么要用 Proxy API 替代 defineProperty API ？

Vue3.0里为什么要用 Proxy API 替代 defineProperty API ？

文章目录 一、Object.defineProperty二、Proxy三、总结参考文献 一、Object.defineProperty 定义：Object.defineProperty() 方法会直接在一个对象上定义一个新属性，或者修改一个对象的现有属性，并返回此对象 为什么能实现响应式 通过define…
阅读更多...
Kubeadm安装单master多node节点K8S集群

Kubeadm安装单master多node节点K8S集群

kubeadm安装k8s1.25版本集群步骤 环境说明实验环境规划集群搭建规划 初始化安装k8s集群的实验环境安装虚拟机更新yum源和操作系统配置机器主机名配置主机hosts文件，相互之间通过主机名互相访问配置主机之间无密码登录关闭交换分区swap，提升性能修改机器内…
阅读更多...
[algorithm] 自动驾驶 规划 非线性优化学习系列之1 ：车辆横向运动动力学详细解释

[algorithm] 自动驾驶 规划 非线性优化学习系列之1 ：车辆横向运动动力学详细解释

写在前面 最近时空联合规划很火，想学习。由于在学校主打学习新能源电力电子方向，转行后也想好好零散的知识体系。计划从车辆运动动力学习，模型预测控制（经典控制目前看主打应用，不会再去深入），…
阅读更多...
使用js判断list中是否含有某个字符串，存在则删除，

使用js判断list中是否含有某个字符串，存在则删除，

显示上图中使用了两种方式， 左边的是filter将不等于userCode的元素筛选出来组成一个新的list， userCodeList.filter(item> item!userCode)；但是上面这个方法在IE浏览器中不支持， 所以改成了右边的方法，使用splice…
阅读更多...
C#，入门教程(22)——函数的基础知识

C#，入门教程(22)——函数的基础知识

上一篇： C#，入门教程(21)——命名空间（namespace）与程序结构的基础知识https://blog.csdn.net/beijinghorn/article/details/124140653 一、函数的基本概念 一个软件的结构大体如下： 大厦application: a plaza { --…
阅读更多...
01-灵魂一问：智能网联汽车域控SOA如何做？

01-灵魂一问：智能网联汽车域控SOA如何做？

1. 前言 //TODO 2. SOA？微服务？ //TODO 3. 如何设计框架？ 3.1 全面SOA SOA平台化，全面解耦操作系统，将操作系统重新分层 3.2 部分SOA 仅仅将部分涉及车辆相关的SOA服务化，比如automotive service …
阅读更多...
Java带你快速了解单元测试

Java带你快速了解单元测试

一、单元测试 1.1 单元测试快速入门 所谓单元测试，就是针对最小的功能单元，编写测试代码对其进行正确性测试。 我们想想，咱们之前是怎么进行测试的呢？ 比如说我们写了一个学生管理系统，有添加学生、修改学生、删除…
阅读更多...
MySQL基础（一）

MySQL基础（一）

学习数据库的目的： 实现数据持久化到本地。使用完整的管理系统统一管理，可以实现结构化查询，方便管理。 一、数据库概述 数据库（DataBase） 为了方便数据的存储和管理，它将数据按照特定的 规则存储在磁盘…
阅读更多...
成都直播基地应该怎么做？直击西南直播电商行业发展现状

成都直播基地应该怎么做？直击西南直播电商行业发展现状

新蓝图已然绘就，新征程击鼓催征。近年，四川电子商务行业的发展势头日益强劲，为助力成都直播产业的多元化发展，由德商产投与无锋科技联袂打造的中国西部大型全域直播产业基地——天府锋巢直播产业基地落户成都市天府新区。该成都直…
阅读更多...
HTTP与HTTPS的工作流程

HTTP与HTTPS的工作流程

HTTP与HTTPS的工作流程 http知识点回顾1、HTTP访问的过程2、HTTP常见状态码3、HTTP 协议一共五大特点 https的工作流程1、对称加密2、非对称加密3、https工作流程 http知识点回顾 1、HTTP访问的过程 （1）解析url，获取 url 中包含的域名&…
阅读更多...
使用ffmpeg转换索尼老DV拍摄的VOB文件为mp4

使用ffmpeg转换索尼老DV拍摄的VOB文件为mp4

一些背景故事 最近对象想用 CCD 拍照录像，家里刚好有一台快 20 年前的索尼 DV DCR-DVD653E，就是电池老化充不进去电了。 翻出来之后还感慨了一下：当年没有网购，价格不透明；有些地方也没有官方店，只有一两家…
阅读更多...
vivado:关联notepad++

vivado:关联notepad++

网上好多都要下插件，看了野火视频，直接在vivado里面加路径弄好的 2 3（那个fonts and colors也经常用 改字体） 4 5 以下是我的路径 D:/gongjuruanjian/notepad/Notepad/notepad.exe [file name] -n[line number] 把[file name] -…
阅读更多...
【刷题】 leetcode 面试题 01.06 字符串压缩

【刷题】 leetcode 面试题 01.06 字符串压缩

字符串压缩 字符串压缩思路一（双指针顺畅版）思路二（sprintf函数巧解版） Thanks♪(･ω･)ﾉ谢谢阅读下一篇文章见！！！ 字符串压缩 来看题目： 根据题目…
阅读更多...
最新文章

Copyright @ 2022~2023