栈实现队列与队列实现堆

news2024/10/6 8:33:07

        ok呀，上一篇博客写了队列的相关知识，接下来就是我们提及过的，栈与队列的相互实现了。堆与这个问题咧，其实大家完全可以当一个知识扩展因为，这个问题也是没有太多的实践意义的，更多的是教学意义。所以咧。大家了解了解就行了。

栈实现队列

      实现思路

       我们想一想栈与队列有一个最根本的区别就是一个先进先出，一个先进后出。那么如果只用一个栈来实现队列应该是不大可能的。所以我们普遍是使用两个栈来实现队列，用两个队列来实栈。但是这个实现的思路是什么呢？
       我们知道栈是后进先出的。那么我们要实现先进先出的话，那我们创建了两个栈，最好是一个为进栈，一个为出栈。这就好比因为我们一个栈顺序是和队列倒过来的，如果我再将我们的栈直接先倒过来，那么岂不是就要与队列相同吗？

 

        这样大家看一下应该就很清楚了吧？因为这样我们在利用栈的后进先出的关系，这样我们就可以实现队列的输出关系的。

实现代码

        那么接下来我们就直接用c语言来实现一下这个操作了。当然我们知道我们要用栈实现队列的话，我们肯定要先写一个栈。再加之我们之前已经写过了，所以我们直接cv过来。

       写一个栈

#include<stdio.h>
#include<malloc.h>
 
#define STACK_INIT_SIZE 100  //栈的初始容量 
#define STACKINCREMENT 10    //容量增量
#define OK 1 
#define OVERFLOW -2
typedef int SDataType;
typedef int Status;
 
typedef struct{
	SDataType *base; //栈底指针
	SDataType *top;  //栈顶指针
	int StackSize;   //当前已经分配的存储空间，以元素为单位 
}SqStack;
 
//初始化顺序栈，构造一个空栈
Status InitStack(SqStack &S){
	//分配存储空间 
	S.base = (SDataType *)malloc(STACK_INIT_SIZE*sizeof(SDataType));
	if(!S.base){
		//如果分配失败，则返回error 
		return OVERFLOW;
	}
	//S.top 始终指向栈顶元素的下一个位置 
	S.top = S.base;    //初始状态下为空栈 
	S.StackSize = STACK_INIT_SIZE;   //当前已经分配的存储容量为100个 
	return OK;	
} 
 
//入栈
Status Push(SqStack &s,SDataType e){
	SDataType *p;
	//首先判断栈是不是满的（上溢） 
	if(s.top-s.base == s.StackSize){
		//追加空间 
		p = (SDataType *)realloc(s.base,(s.StackSize + STACKINCREMENT)*sizeof(SDataType));
		if(!p){
			//如果没有找到符合条件的存储空间，则返回error 
			return OVERFLOW;
		}
		//成功找到则使s.base指向p 
		s.base = p;  //系统会将原来的内容复制过来
		s.top = s.base + s.StackSize;
		s.StackSize +=  STACKINCREMENT;
	}
	//先插入元素，然后使栈顶指针加 1 
	*(s.top) = e;
	s.top++;
	return OK;
} 
 
//出栈
Status Pop(SqStack &s,SDataType &e){
	//判断是否会发生下溢 
	if(s.top != s.base){
		s.top--;    //先将栈顶指针减 1 
		e = *(s.top);
	}else{
		return 0;
	}
	return e;
}
 
//判断是否为空栈 
void judgeNull(SqStack &s){
	if(s.top == s.base){
		printf("此栈为空栈！\n");
	}else{
		printf("此栈不为空栈！\n");
	}
}
 
//判断是否为满栈
void judgeFull(SqStack &s){
	if(s.top-s.base == s.StackSize){
		printf("栈满！\n");
	}else{
		printf("栈未满！\n");
	} 
} 
 
int main(){
	SqStack s;
	SDataType element;
	
	InitStack(s);  //初始化栈
	//将1-10入栈
	for(int i=1;i<=10;i++){
		Push(s,i);
	}
	
	judgeNull(s);
	judgeFull(s);
	
	printf("出栈：\n");
	//只要栈不为空 
	while(s.top != s.base){
		Pop(s,element);    //出栈的元素用e接收 
		printf("%d ",element);
	}
	
	printf("\n"); 
	judgeNull(s);
	
	return 0;
	 
}

        两个栈 

       我们开始也说过了，我们要两个栈。那么下一步我们就要了还写两个栈。

//两个栈模拟实现队列
typedef struct
{
    ST pushst;
    ST popst;
} MyQueue;

      栈的初始化

      既然我们已经创建好两个栈了，那么接下来我们就要将栈初始化了。

//开辟空间并初始化
MyQueue* myQueueCreate()
{
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&obj->pushst);
    STInit(&obj->popst);
    return obj;
}

     入栈 

        然后我们前面也说过，我们创建了两个站，其中一个为入站，一个为出站，那么呢我们接下来要将数据插入到入栈里面。而且前面我们已经写过了一个栈的入栈。那么我们直接引用就可以了。

//将元素X推到队列的末尾
void myQueuePush(MyQueue* obj, int x)
{
    STPush(&obj->pushst, x);
}

    返回队头

        那么我们首次需要用到先入先出的这个相关定义。其实就很简单，就分为两种情况。一种是我们的出栈里面有数据。一种是我们的出栈里面没有数据。如果有数据的话，我们直接将队列的头元素给返回出来就可以了。但是如果没有数据的话，我们就需要先倒一下数据，然后再返回。虽然大家可能会第一时间想到if和else当然这也是最常见的，我们也可以直接来一个if然后就可以了。我们直接判断我们的出栈是否有数据，如果没有，我们就直接倒然后在最末尾返回数据。如果有数据的话，他就不会进入到这个判断里面，然后我们就可以直接返回了。也就是说我们只需要判断里面是否有数据就可以了，然后再如果没有就进循环导数据，然后出数据。


//返回队列开头的元素
int myQueuePeek(MyQueue* obj)
{
	if (STEmpty(&obj->popst))//如果出栈为空的话就进去循环导数据
	{
		//捯数据
		while (!STEmpty(&obj->pushst))
		{
			STPush(&obj->popst, STTop(&obj->pushst));
			STPop(&obj->pushst);
		}
	}
	return STTop(&obj->popst);//都要传出数据的所以直接整合了
}

   头删 

        我们对于队列的头山的话，其实就只需要将我们出栈的头元素给删除掉，但是呢他又需要将头元素的值给返回。那么我们就需要创建一个临时变量来储存值，然后再头元素删除。

//从队列的开头移除并返回元素
int myQueuePop(MyQueue* obj)
{
	int front = myQueuePeek(obj);//创建一个临时变量存储值
	STPop(&obj->popst);//销毁头元素
	return front;//返回头元素的值
}

  判空 

       对于判空的话其实是比较简单的。因为我们在最开始写栈的时候，我们就已经写过判空了。我们就直接引用就可以了。当然如果我们一个一个判断的话是比较繁琐的，所以我们直接在返回的时候看到他们是否相同，这样就可以了。因为我在我们上面写在判空的时候就已经写过了。

//如果队列为空，返回true；否则，返回false
bool myQueueEmpty(MyQueue* obj)
{
	return STEmpty(&obj->popst) && STEmpty(&obj->pushst);//判断是否都为空
}

销毁

       最后一个销毁队列。其实就很简单啦，我们因为是用栈实现队列的，所以我们就需要把两个栈销毁就可以了。当然还要记得释放里面的空间。 

//销毁队列
void myQueueFree(MyQueue* obj)
{
	STDestroy(&obj->popst);//销毁出栈
	STDestroy(&obj->pushst);//销毁入栈
	free(obj);//释放空间
}

完整代码 

//C语言模拟实现栈
 
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
 
//初始化栈
void STInit(ST* ps);
//销毁栈
void STDestroy(ST* ps);
//入栈
void STPush(ST* ps, STDataType x);
//出栈
void STPop(ST* ps);
//获取栈顶元素
STDataType STTop(ST* ps);
//获取栈中有效元素个数
int STSize(ST* ps);
//检测栈是否为空，如果为空返回非零结果，如果不为空返回0
bool STEmpty(ST* ps);
 
void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
 
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
 
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newCapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
 
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}
 
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}
 
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
 
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
 
//=======================================================================
 
//两个栈模拟实现队列
typedef struct
{
    ST pushst;
    ST popst;
} MyQueue;
 
//开辟空间并初始化
MyQueue* myQueueCreate()
{
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    STInit(&obj->pushst);
    STInit(&obj->popst);
    return obj;
}
 
//将元素X推到队列的末尾
void myQueuePush(MyQueue* obj, int x)
{
    STPush(&obj->pushst, x);
}
 
//返回队列开头的元素
int myQueuePeek(MyQueue* obj)
{
    if (STEmpty(&obj->popst))
    {
        //捯数据
        while (!STEmpty(&obj->pushst))
        {
            STPush(&obj->popst, STTop(&obj->pushst));
            STPop(&obj->pushst);
        }
    }
    return STTop(&obj->popst);
}
 
//从队列的开头移除并返回元素
int myQueuePop(MyQueue* obj)
{
    int front = myQueuePeek(obj);
    STPop(&obj->popst);
    return front;
}
 
//如果队列为空，返回true；否则，返回false
bool myQueueEmpty(MyQueue* obj)
{
    return STEmpty(&obj->popst) && STEmpty(&obj->pushst);
}
 
//销毁队列
void myQueueFree(MyQueue* obj)
{
    STDestroy(&obj->popst);
    STDestroy(&obj->pushst);
    free(obj);
}

队列实现栈 

     实现思路

       我们也是先将一个队列里面塞入数据，然后再将它导出来。当然我们还是要确定一下。哪个为进？哪个为出？我们知道队列是先进先出的，但是我们的栈呢是需要先进后出。

      对于队列实现上就不能像栈实现队列那样确定一个为入栈一个为出栈。我们需要时刻改变，我们就这样判断谁为空谁就会入栈，谁为谁就为出栈这样。就是当我们入队列的时候，我们的队列谁有数据就往谁里面插入。

   实现代码

     写一个队列

     当然我们还是老样子，先写一个队列，因为我们以前写过了，接下来还是cv一下就可以了。

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
 
typedef int QDateType;
 
typedef struct QueueNode
{
	QDateType val;
	struct QueueNode* next;
}QueueNode;
 
typedef	struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;
 
void QueueInti(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
 
void QueueDestory(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->tail = pq->head = NULL;
}
 
void QueuePush(Queue* pq, QDateType x)
{
	assert(pq);
 
	QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
	if (NULL == newNode)
	{
		printf("malloc error\n");
		exit(-1);
	}
	newNode->val = x;
	newNode->next = NULL;
 
	if (pq->tail == NULL)
	{
		assert(pq->head == NULL);
		pq->head = pq->tail = newNode;
	}
	else
	{
		pq->tail->next = newNode;
		pq->tail = newNode;
	}
 
}
 
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head && pq->tail);
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QueueNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}
 
bool QueueEmpty(Queue* pq)
{
	assert(pq);
 
	return pq->head == NULL;
}
 
QDateType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);
 
	return pq->head->val;
}
 
int QueueSize(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	int count = 0;
	while (cur)
	{
		cur = cur->next;
		count++;
	}
	return count;
}

    两个队列

     开始我们也说过了，实现队列实现站的话也需要两个队列，所以我们第一步创建两个队列。

//创建两个队列
typedef struct
{
	Queue q1;
	Queue q2;
} MyStack;

     队列初始化 

        好，当我们将队列创建好出来之后，我们就要将队列的初始化了。并且我们开始也是说过我们写过单个队列的程序。那么我们还是直接引用就可以了。

//两个队列的初始化
MyStack* myStackCreate()
{
	MyStack* st = (MyStack*)malloc(sizeof(MyStack));//创建一个临时结构体
	if (st == NULL)
		return false;

	QueueInit(&st->q1);//分别初始化
	QueueInit(&st->q2);

	return st;
}

      入队列 

       我们前面说过我们看中了两个队列里面谁有数据就往谁里面插入。因为我们在前面已经写过了单个队列的相关代码了。那么我们接下来只需要判断谁不为空，就往谁里面插入就可以了。

//队列的入队列
void myStackPush(MyStack* obj, int x)
{
	if (QueueSize(&obj->q1) != 0)//如果q1不为空的话，q1插入，反之q2插入
	{
		QueuePush(&obj->q1, x);
	}
	else
	{
		QueuePush(&obj->q2, x);
	}
}

      队列的头元素 

       当然还是少不了我们的头元素。在我们不知情的情况下，我们肯定不知道谁的队列里面有数据，所以我们这里我们也需要判断一下。判断好之后，但是我们也需要再思考一下。我们队列和栈的输入输出顺序是不一样的，那么是不是我们队列需要先再倒一下，然后再输出这样得到的答案才是我们想要的。

       并且我们还需要知道我们从一个队列倒到另一个队列。是不是源队列导出一个元素，那么就要删除这个元素，不然的话只是导出来的话，两个队列都有元素了，这样就不满足我们一个队列有元素，一个队列无元素的基本原则了。

//返回栈的头元素
int myStackPop(MyStack* obj)
{
	Queue* tmp = &obj->q1;//假设法，确定谁有数据
	Queue* notmp = &obj->q2;

	if (QueueSize(notmp) == 0)
	{
		tmp = &obj->q2;
		notmp = &obj->q1;
	}

	while (QueueSize(notmp)>1)//倒数据，并且清楚数据
	{
		QueuePush(tmp, QueueFront(notmp));
		QueuePop(notmp);

	}

	QDataType res = QueueFront(notmp);//一个临时变量，并且释放
	QueuePop(notmp);
	return res;
}

队列的尾元素

       还会队列的尾元素也是一样的道理吧？我们只需要判断谁的元素有就可以了，然后再访问他的尾节点的元素，那么就很简单。

//返回队列尾元素
int myStackTop(MyStack* obj)
{//判断谁不为空，直接返回
	if (QueueSize(&obj->q1) != 0)
		return QueueBack(&obj->q1);
	else
		return QueueBack(&obj->q2);
}

    队列判空 

        当大家看了上面的栈实现线队列的判空的话，那么队列判空其实也是很简单的。也是直接判断一个然后相与就可以了。

//队列的判空
bool myStackEmpty(MyStack* obj) 
{
    return QueueEmpty(&obj->q1)  &&  QueueEmpty(&obj->q2);
}

队列的销毁

       当然实现了这些，我们就要实现最后的一个做指令对你的销毁了。但是我们也知道栈实现队列的销毁就很简单。这个只需要分开销毁并置空就可以了。那么队列的这个肯定也是一样的。只需要分开销毁，然后置空。

//队列的销毁
void myStackFree(MyStack* obj) 
{
    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);
 
    free(obj);
}

完整代码

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>
 
typedef int QDateType;
 
typedef struct QueueNode
{
	QDateType val;
	struct QueueNode* next;
}QueueNode;
 
typedef	struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;
 
void QueueInti(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}
 
void QueueDestory(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->tail = pq->head = NULL;
}
 
void QueuePush(Queue* pq, QDateType x)
{
	assert(pq);
 
	QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
	if (NULL == newNode)
	{
		printf("malloc error\n");
		exit(-1);
	}
	newNode->val = x;
	newNode->next = NULL;
 
	if (pq->tail == NULL)
	{
		assert(pq->head == NULL);
		pq->head = pq->tail = newNode;
	}
	else
	{
		pq->tail->next = newNode;
		pq->tail = newNode;
	}
 
}
 
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head && pq->tail);
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QueueNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}
 
bool QueueEmpty(Queue* pq)
{
	assert(pq);
 
	return pq->head == NULL;
}
 
QDateType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);
 
	return pq->head->val;
}
 
int QueueSize(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	int count = 0;
	while (cur)
	{
		cur = cur->next;
		count++;
	}
	return count;
}

//创建两个队列
typedef struct
{
	Queue q1;
	Queue q2;
} MyStack;


//两个队列的初始化
MyStack* myStackCreate()
{
	MyStack* st = (MyStack*)malloc(sizeof(MyStack));//创建一个临时结构体
	if (st == NULL)
		return false;

	QueueInit(&st->q1);//分别初始化
	QueueInit(&st->q2);

	return st;
}
 
//队列的入队列
void myStackPush(MyStack* obj, int x)
{
	if (QueueSize(&obj->q1) != 0)//如果q1不为空的话，q1插入，反之q2插入
	{
		QueuePush(&obj->q1, x);
	}
	else
	{
		QueuePush(&obj->q2, x);
	}
}

//返回栈的头元素
int myStackPop(MyStack* obj)
{
	Queue* tmp = &obj->q1;//假设法，确定谁有数据
	Queue* notmp = &obj->q2;

	if (QueueSize(notmp) == 0)
	{
		tmp = &obj->q2;
		notmp = &obj->q1;
	}

	while (QueueSize(notmp)>1)//倒数据，并且清楚数据
	{
		QueuePush(tmp, QueueFront(notmp));
		QueuePop(notmp);

	}

	QDataType res = QueueFront(notmp);//一个临时变量，并且释放
	QueuePop(notmp);
	return res;
}

//返回队列尾元素
int myStackTop(MyStack* obj)
{//判断谁不为空，直接返回
	if (QueueSize(&obj->q1) != 0)
		return QueueBack(&obj->q1);
	else
		return QueueBack(&obj->q2);
}

//队列的判空
bool myStackEmpty(MyStack* obj) 
{
    return QueueEmpty(&obj->q1)  &&  QueueEmpty(&obj->q2);
}

//队列的销毁
void myStackFree(MyStack* obj) 
{
    QueueDestory(&obj->q1);
    QueueDestory(&obj->q2);
 
    free(obj);
}

总结

       好了，以上就是关于栈与队列相互实现的相关知识吧。当然这些有其中有很多可以优化的地方，大家可以细心的观察一下，然后呢其中关于这个博客大家其实可以相当于课后拓展，因为确实这样没必要把他作为一个非常重要知识点，大家只需要知道如何使用就可以了。

      最主要的还是需要大家熟练使用对业余战的单个的相关知识来，希望这篇不太对大家会有帮助，然后今天的讲解就到这里了。

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

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

相关文章

Linux--信号（万字详解！超完整！）

Linux--信号（万字详解！超完整！）

目录 0.预备知识 0.1.基本概念 0.2.信号的捕捉 0.3.理解信号的发送与保存 1.信号的产生&#xff08;阶段一&#xff09; 1.通过kill命令&#xff0c;向指定进程发送指定的信号 2.通过终端按键产生信号&#xff1a;ctrlc&#xff08;信号2&#xff09;&#xff0c;ctrl\(…
阅读更多...
2024暑假集训第二次考试

2024暑假集训第二次考试

10062. Majority Opinion 思路分析 这道题就是一道思维题&#xff0c;这种题需要刻意练习&#xff0c;形成一定的思维模式用之前学过算法的原理去思考问题&#xff0c;而不是一味考验某一种算法的应用。 这道题就需要思考的是什么情况可以让这个奶牛爱吃同一种干草&#xff0c;…
阅读更多...
ES6模块化学习

ES6模块化学习

1. 回顾&#xff1a;node.js 中如何实现模块化 node.js 遵循了 CommonJS 的模块化规范。其中&#xff1a; 导入其它模块使用 require() 方法 模块对外共享成员使用 module.exports 对象 模块化的好处&#xff1a; 大家都遵守同样的模块化规范写代码&#xff…
阅读更多...
免费的二级域名分发，您确定不要试试吗？

免费的二级域名分发，您确定不要试试吗？

这是可爱的小盆友做的一个免费的二级域名&#xff0c;目前上线就送114514个积分&#xff0c;名额有限~ 首先进入>路明二级域名分发 - 免费稳定的二级域名分发服务 (kmyl.top)< 进来是这个样子&#xff08;如下图所示&#xff09; 话不多说&#xff0c;进入教程~ 第一章…
阅读更多...
vue对axios进行请求响应封装

vue对axios进行请求响应封装

一、原因 像是在一些业务逻辑上&#xff0c;比如需要在请求之前展示loading效果&#xff0c;或者在登录的时候判断身份信息&#xff08;token&#xff09;等信息有没有过期&#xff0c;再者根据服务器响应回来的code码进行相应的提示信息。等等在请求之前&#xff0c;之后做的一…
阅读更多...
跟着峰哥学java 微信小程序 第二天 封装ES7 ＋ 后端工作

跟着峰哥学java 微信小程序 第二天 封装ES7 ＋ 后端工作

1.前端 1.1使用promise封装 使用promise封装以至于在图片路径 统一路径中修改 //封装统一请求域名 const baseUrl "http://localhost:8080"; //封装后需导出 export const getBaseUrl()>{return baseUrl; } 导入外来资源 初始化数据 设置数据 将处理后的数据…
阅读更多...
高薪程序员必修课-JVM的内存区域以及对象创建过程

高薪程序员必修课-JVM的内存区域以及对象创建过程

JVM内存区域 在Java虚拟机&#xff08;JVM&#xff09;中&#xff0c;内存区域&#xff08;Memory Areas&#xff09;是对内存空间的逻辑划分&#xff0c;用于存储不同类型的数据和执行不同的操作。理解JVM的内存区域有助于优化程序性能、调优内存使用和排查内存相关的问题。下…
阅读更多...
Java后端每日面试题(day1)

Java后端每日面试题(day1)

目录 JavaWeb三大组件依赖注入的方式Autowire和Resurce有什么区别&#xff1f;Spring Boot的优点Spring IoC是什么&#xff1f;说说Spring Aop的优点Component和Bean的区别自定义注解时使用的RetentionPolicy枚举类有哪些值&#xff1f;如何理解Spring的SPI机制&#xff1f;Spr…
阅读更多...
溶酶体靶向嵌合体制备方法和技术

溶酶体靶向嵌合体制备方法和技术

网盘 https://pan.baidu.com/s/1dhCCryatp71j7yXTDdrrTw?pwdynr4 具有聚集诱导发光性质的比率型溶酶体pH探针及应用.pdf 内体-溶酶体转运靶向嵌合体降解剂及其制备方法与应用.pdf 可降解PDGFR-β的蛋白降解靶向嵌合体及其制备方法和应用.pdf 溶酶体膜包覆纳米颗粒的制备方法.…
阅读更多...
19C 单机文件系统安装文档

19C 单机文件系统安装文档

准备工作 1)查看系统版本、内核参数 more /etc/redhat-release more /etc/redflag-releaseuname -a2)查看当前系统是否配置了HugePages。在下面的查询中&#xff0c;HugePages的几个相关值都为0&#xff0c;表明当前未配值HugePages&#xff0c;其次可以看到该版本的大页大小为…
阅读更多...
科普文：微服务之服务网格Service Mesh

科普文：微服务之服务网格Service Mesh

一、ServiceMesh概念 背景 随着业务的发展&#xff0c;传统单体应用的问题越来越严重&#xff1a; 单体应用代码库庞大&#xff0c;不易于理解和修改持续部署困难&#xff0c;由于单体应用各组件间依赖性强&#xff0c;只要其中任何一个组件发生更改&#xff0c;将重新部署整…
阅读更多...
2024年7月5日 (周五) 叶子游戏新闻

2024年7月5日 (周五) 叶子游戏新闻

老板键工具来唤去: 它可以为常用程序自定义快捷键&#xff0c;实现一键唤起、一键隐藏的 Windows 工具&#xff0c;并且支持窗口动态绑定快捷键&#xff08;无需设置自动实现&#xff09;。 卸载工具 HiBitUninstaller: Windows上的软件卸载工具 《乐高地平线大冒险》为何不登陆…
阅读更多...
能否免费使用Adobe XD？

能否免费使用Adobe XD？

Adobe XD不是免费的。Adobe 目前XD采用订阅模式&#xff0c;提供订阅模式 7 每天试用期结束后需要付费购买&#xff0c;具体价格根据不同的订阅计划确定&#xff0c;包括每月购买&#xff0c;包括 9.99 美元或每月 99.99 美元&#xff0c;或者选择购买Adobe CreativeCloud整体订…
阅读更多...
文件打开的系统错误分析流程

文件打开的系统错误分析流程

当用户出现“Open file failed”错误时&#xff0c;手动产生dump文件。 &#xff08;1&#xff09;打开资源管理器&#xff0c;选择AppNameXXX.exe进程&#xff0c;右击鼠标选择“创建转储文件” (2) 生成转储文件 3.获取用户转储文件 4.用Visual studio2015打开dump文件分析…
阅读更多...
Qt使用sqlite数据库及项目实战

Qt使用sqlite数据库及项目实战

一.sqlite使用介绍 在Qt中使用SQLite数据库非常简单&#xff0c;SQLite是一个轻量级的嵌入式数据库&#xff0c;不需要单独的数据库服务器&#xff0c;完全使用本地文件来存储数据。 当在Qt中使用SQLite数据库时&#xff0c;需要涉及到一些SQL语句以及Qt中的相关函数&#xf…
阅读更多...
linux主机(A)通过私钥登录linux主机(B)

linux主机(A)通过私钥登录linux主机(B)

1.登录B主机&#xff0c;先在B主机执行 ssh-keygen 2.设置id_rsa的权限 chmod 600 id_rsa 3.将生成的id_rsa.pub导入到authorized_keys ssh-copy-id -i ./id_rsa.pub root127.0.0.1 4.将id_rsa复制到A主机 scp id_rsa_123 root1.1.1.A:/home/ 5.登录到A主机使用私钥登录 因…
阅读更多...
华为云生态和快速入门

华为云生态和快速入门

华为云生态 新技术催生新物种&#xff0c;新物种推动新生态 数字技术催生各类运营商去重塑并颠覆各行业的商业模式 从业务层面看&#xff0c;企业始终如一的目标是业务增长和持续盈利&#xff0c;围绕这些目标衍生出提质、增效、降本、安全、创新和合规的业务诉求&#xff0c…
阅读更多...
【C语言题目】34.猜凶手

【C语言题目】34.猜凶手

文章目录 作业标题作业内容2.解题思路3.具体代码 作业标题 猜凶手 作业内容 日本某地发生了一件谋杀案&#xff0c;警察通过排查确定杀人凶手必为4个嫌疑犯的一个。 以下为4个嫌疑犯的供词: A说&#xff1a;不是我。 B说&#xff1a;是C。 C说&#xff1a;是D。 D说&#xff…
阅读更多...
科研绘图系列：R语言STAMP图（STAMP Plot）

科研绘图系列：R语言STAMP图（STAMP Plot）

介绍 STAMP图（STAMP plot）并非一个广泛认知的、具有特定名称的图表类型，而是可能指在STAMP（Statistical Analysis of Metagenomic Profiles：“STAMP: statistical analysis of taxonomic and functional profiles”）软件使用过程中生成的各种统计和可视化图表的总称。ST…
阅读更多...
window.ai 开启你的内置AI之旅

window.ai 开启你的内置AI之旅

❝ 成功是得你所想&#xff0c;幸福是享你所得 大家好&#xff0c;我是柒八九。一个专注于前端开发技术/Rust及AI应用知识分享的Coder ❝ 此篇文章所涉及到的技术有 AI( Gemini Nano) Chrome Ollama 因为&#xff0c;行文字数所限&#xff0c;有些概念可能会一带而过亦或者提供…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023