33.栈，队列练习题（王道2023数据结构第3章综合应用）

news2024/11/20 18:28:47

试题1（3.1.4节题3）：

假设以 I 和 O 分别表示入栈和出栈操作。栈的初态和终态均为空，入栈和出栈的操作序列可表示为仅有 I 和 O 组成的序列，可以操作的序列为合法序列，否则称为非法序列。

（1）下面的序列哪些是合法的？

（A）IOIIOIOO  （B）IOOIOIIO  （C）IIIOIOIO   （D）IIIOOIOO

（2）试写出一个算法，判定给定的操作序列是否合法。若合法则返回 True，否则返回 False（假定被判定的操作序列已存入一维数组中）。

解答：（1）AD合法，而BC不合法（注意C中最后栈的终态不为空，所以非法）。

（2）两步检验：检验中间是否有空栈还Pop的情况，检验最后栈是否为空

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    char a[10] = {'I','O','I','I','O','O','I','O','O','O'};  //待检测序列
    int i = 0;
    int j = 0;
    while(a[i]!=NULL){
        if(a[i]=='I')
            j = j + 1;
        else
            j = j - 1;
        if(j < 0){
            printf("输入序列非法！");
            return 0;
        }
        i = i + 1;
    }
    if(j==0){
        printf("输入序列合法！");
            return 1;
    }
    else{
        printf("输入序列非法！");
        return 0;
    }
}

输出：

char a[10] = {'I','O','I','I','O','O','I','I','I','O'};
输入序列非法！

char a[10] = {'I','O','I','I','O','O','I','O','I','O'}; 
输入序列合法！

试题2：（3.1.4节题4）

设单链表的表头指针为L，结点结构由data和next组成，其中data为字符型。设计算法判断该链表全部n个字符是否是中心对称的，如xyx，xyyx都是中心对称的。

这道题也不是很难，但是需要注意C语言中字符的输入输出怎么写。我在写这段代码的时候踩了一个大坑。参考：用scanf()输入单个字符时的注意点_wuyouzeng1121210068的博客-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/wuyouzeng1121210068/article/details/6935395加上空格后，回车符不在赋值给e，否则会报错。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define MAXSIZE 100
#define ElemType char
#define Status int
 
//单链表的数据结构
typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode, *LinkList;
 
//初始化
int InitList(LinkList &L)
{
	L = (LNode *)malloc(sizeof(LNode));
	L->next = NULL;
	return 1;
}
 
//输出
void PrintList(LinkList L)
{
	printf("当前单链表的所有元素：");
	LNode *p;
	p = L->next;
	while (p != NULL)
	{
		printf("%c ", p->data);
		p = p->next;
	}
	printf("\n");
}
 
//尾插法创建单链表
int Create(LinkList &L)
{
    int n;
    char e;
    LNode *temp = L;//声明一个指针指向头结点，用于遍历链表 　　
 
	printf("请输入要输入元素的个数：");
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
	{
		LNode *a = (LNode*)malloc(sizeof(LNode));
		printf("请输入第%d元素的值：", i);
        scanf(" %c", &e);  //%c必须有空格！！！，scanf必须要有取地址运算符&e
		a->data = e;
		temp->next = a;
		a->next = NULL;
		temp = temp->next;
	}
	return 1;
}
 
//插入元素
int InsertList(LNode *L, int i, ElemType e)
{
	LNode *p = L;
	int j = 0;
	while (p && (j < i - 1))  //寻找要插入位置的前驱结点，让p指向它
	{
		p = p->next;
		++j;
	}
	if (!p || j > i - 1) return 0;	//插入位置非法，返回0
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = e;  //创建一个新结点存放要插入的元素e
	s->next = p->next;  //把新结点的指针域指向p->next
	p->next = s;  //把p->next指向要插入的新结点
	return 1;
}
 
//删除元素
int DeleteList(LNode *L, int i)
{
	LNode *p = L;
	int j = 0;
	while (p->next && (j < i - 1))	//寻找要删除结点的前驱结点，让p指向它
	{
		p = p->next;
		++j;
	}
	if (!p->next || j > i - 1) return 0;  //删除位置非法，返回0
	LNode *q;
	q = p->next;  //暂存删除结点，以便随后释放
	p->next = q->next;	//把p->next指向p->next->next，即q->next
	free(q);  //释放结点
	return 1;
}
 
//按值查找元素
int LocateElem(LNode *L, ElemType e)
{
	int i = 1;
	LNode *p = L->next;
	while (p&&p->data != e)		//从第一个结点开始，依次向后遍历比较
	{
		p = p->next;
		i++;
	}
	if(p)	return i;
	else	return 0;	
}

bool dc(LinkList L,int n){  //这里假设表长已知，本算法判断链表是否中心对称
    LNode *p;
    int i = 0;
    char s[n / 2];  //建立栈
    p = L->next;
    for (i = 0; i < n / 2;i++){
        s[i] = p->data;
        p = p->next;
    }
    i = i - 1;  //退出循环时还要加1，这里再减回去就是n/2
    if(n % 2== 1){  //注意：表长是奇数时，需要越过中间结点
    //例如表长是5，则n/2=2,退出for循环时i=3，p指针指向第3个元素
    //但是第3个元素和第3个元素必定相等，所以p指针移动到4号，比较2和4即可
        p = p->next;
    }
    while(p!=NULL&&s[i] == p->data){
        i = i - 1;
        p = p->next;
    }
    if(i==-1){
        printf("此链表是中心对称的");
        return 1;
    }
    else{
        printf("此链表不是中心对称的");
        return 0;
    }
}
 
int main(){
    LinkList L;
	InitList(L);
	Create(L);
	PrintList(L);
    dc(L,5);
    /*
    InsertList(L, 4, 'w');
	PrintList(L);
	DeleteList(L, 3);
	PrintList(L);
	printf("%d\n",LocateElem(L, 's'));
    */
	return 0;
}

输出：

当前单链表的所有元素：a b d b a
此链表是中心对称的

当前单链表的所有元素：a b v f d
此链表不是中心对称的

试题3：（3.1.4节题5）

设有两个栈S1，S2都采用顺序栈方式，并共享一个存储区[0...Maxsize-1]，为了尽量利用空间，减少溢出可能，可采用栈顶相向，迎面增长的存储方式，试设计S1，S2的入栈和出栈算法。

此题考的是共享栈，这里复习一下C语言中switch()选择语句的写法：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define MAXSIZE 10
#define ElemType int
#define Status int
 
//共享栈的数据结构
typedef struct
{
	ElemType data[MAXSIZE];
	int top[2];  //两个栈的栈顶指针
}Stack;

//栈的初始化
int InitStack(Stack &a){
    a.top[0] = -1;
    a.top[1] = MAXSIZE;  //初始两个指针都指向栈底
    return 0;
}

//打印栈的元素
void PrintStack(Stack a){
    if(a.top[0]>=0){
        for (int i = 0; i <= a.top[0];i++){
            printf("[%d]", a.data[i]);
        }
    }
    if(a.top[1]-a.top[0]>1){
        for (int i = a.top[0] + 1; i <= a.top[1]-1;i++){
            printf("[NULL]");
        }
    }
    if(a.top[1] <= MAXSIZE-1){
        for (int i = a.top[1]; i <= MAXSIZE - 1;i++){
            printf("[%d]", a.data[i]);
        }
    }
    printf("\n");
} 

//入栈,i为栈号，x表示入栈元素
int Push(Stack &a,int i,ElemType x){
    if (i!=0 && i!=1){
        printf("栈号出错！");
        return 0;
    }
    else{
        switch (i){
        case 0:{
            if(a.top[1]-a.top[0]==1){
                printf("栈已满！");
                return 0;
            }
            else{
                a.top[0] = a.top[0] + 1;
                a.data[a.top[0]] = x;
            }
            break;  //不能缺少break语句，如果缺失，程序会把后面的case都执行。
        }
        case 1:{
            if(a.top[1]-a.top[0]==1){
                printf("栈已满！");
                return 0;
            }
            else{
                a.top[1] = a.top[1] - 1;
                a.data[a.top[1]] = x;
            }
            break;  //不能缺少break语句，如果缺失，程序会把后面的case都执行。
        }    
        }
    }
    return 1;
}

//出栈
int Pop(Stack &a,int i,ElemType x){
    if (i!=0 && i!=1){
        printf("栈号出错！");
        return 0;
    }
    else{
        switch (i){
        case 0:{
            if(a.top[0]==-1){
                printf("栈已空！");
                return 0;
            }
            else{
                x = a.data[a.top[0]];
                a.top[0] = a.top[0] - 1;
                return x;
            }
            break;  //不能缺少break语句，如果缺失，程序会把后面的case都执行。
        }
        case 1:{
            if(a.top[1]==MAXSIZE){
                printf("栈已空！");
                return 0;
            }
            else{
                x = a.data[a.top[1]];
                a.top[1] = a.top[1] + 1;
                return x;
            }
            break;  //不能缺少break语句，如果缺失，程序会把后面的case都执行。
        }    
        }
    }   
}

int main(){
    Stack a;
    int x;
    InitStack(a);
    PrintStack(a);
    Push(a, 0, 1);
    Push(a, 1, 2);
    Push(a, 1, 3);
    PrintStack(a);  //元素入栈之后打印
    Pop(a, 0, x);
    Pop(a, 1, x);
    Pop(a, 0, x);
    PrintStack(a);  //元素出栈后再打印
    return 0;
}

输出：

[NULL][NULL][NULL][NULL][NULL][NULL][NULL][NULL][NULL][NULL]
[1][NULL][NULL][NULL][NULL][NULL][NULL][NULL][3][2]
栈已空！
[NULL][NULL][NULL][NULL][NULL][NULL][NULL][NULL][NULL][2]

试题4：（3.2.5节题1）

若希望队列中的元素都能得到利用，需设置一个标志域tag，并以tag为0或1来区分头指针front和尾指针rear相同时的队列状态是空还是满，试编写此结构的入队和出队算法。

本题中我们重写循环队列（采用数组）的有关算法：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define MAXSIZE 6
#define ElemType int
#define Status int
 
//循环队列的数据结构
typedef struct Queue
{
	ElemType data[MAXSIZE];
    int front, rear;  //头尾指针，队头指针指向第一个元素，队尾指针指向队尾元素的下一个元素
    int tag;
}Queue;
 
//初始化
int InitQueue(Queue &a)
{
    a.front = 0;
    a.rear = 0;
    a.tag = 0;  //初始队列是空
    for (int i = 0; i < MAXSIZE;i++){
        a.data[i] = 0;
    }
    return 1;
}
 
//打印输出
void PrintQueue(Queue a)
{
	printf("当前队列所有元素：");
	for (int i = 0; i < MAXSIZE;i++){
        printf("[%d] ",a.data[i]);
    }
	printf("\n");
}
 
//插入队列
int Insert(Queue &a,ElemType x){
    if(a.front == a.rear && a.tag == 1){
        printf("当前队列已满！");
        return 0;
    }
    else{
        a.data[a.rear] = x;
        a.tag = 1;  //插入队列tag置1
        a.rear = (a.rear + 1) % MAXSIZE;
        return 1;
    }  
}

//删除队列
int Delete(Queue &a,ElemType x){
    if(a.front == a.rear && a.tag == 0){
        printf("当前队列已空！");
        return 0;
    }
    else{
        x = a.data[a.front];
        a.data[a.front] = 0;
        a.tag = 0;  //删除队列tag置0
        a.front = (a.front + 1) % MAXSIZE;
        return x;
    }  
}

int main(){
    Queue a;
    int x;
    InitQueue(a);
    PrintQueue(a);
    Insert(a, 1);
    Insert(a, 2);
    Insert(a, 3);
    Insert(a, 4);
    Delete(a, x);
    PrintQueue(a);
    Insert(a, 5);
    Insert(a, 6);
    Insert(a, 7);
    Insert(a, 8);
    PrintQueue(a);
    return 0;
}

输出：

当前队列所有元素：[0] [0] [0] [0] [0] [0] 
当前队列所有元素：[0] [2] [3] [4] [0] [0]
当前队列已满！
当前队列所有元素：[7] [2] [3] [4] [5] [6]

试题5：（3.2.5节题2）

Q是一个队列，S是一个空栈，实现将队列中的元素逆置。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define MAXSIZE 6
#define ElemType int
#define Status int
 
//循环队列的数据结构
typedef struct Queue{
	ElemType data[MAXSIZE];
    int front, rear;  //头尾指针，队头指针指向第一个元素，队尾指针指向队尾元素的下一个元素
    int tag;
} Queue;
//栈的数据结构
typedef struct Sqstack{
    ElemType data[MAXSIZE];
    int top;  //栈顶指针指向栈顶元素
} Sqstack;

//初始化
int InitQueue(Queue &a){
    a.front = 0;
    a.rear = 0;
    a.tag = 0;  //初始队列是空
    for (int i = 0; i < MAXSIZE;i++){
        a.data[i] = 0;
    }
    return 1;
}
int InitStack(Sqstack &a){
    for (int i = 0; i < MAXSIZE;i++){
        a.data[i] = 0;
    }
    a.top = -1;
    return 1;
}

//打印输出
void PrintQueue(Queue a){
	printf("当前队列所有元素：");
	for (int i = 0; i < MAXSIZE;i++){
        printf("[%d] ",a.data[i]);
    }
	printf("\n");
}
void PrintSqstack(Sqstack a){
	printf("当前栈所有元素：");
	for (int i = 0; i < MAXSIZE;i++){
        printf("[%d] ",a.data[i]);
    }
	printf("\n");
}

//插入
int InsertQueue(Queue &a,ElemType x){
    if(a.front == a.rear && a.tag == 1){
        printf("当前队列已满！");
        return 0;
    }
    else{
        a.data[a.rear] = x;
        a.tag = 1;  //插入队列tag置1
        a.rear = (a.rear + 1) % MAXSIZE;
        return 1;
    }  
}
int InsertSqstack(Sqstack &a,ElemType x){
    if(a.top == MAXSIZE-1){
        printf("当前栈已满！");
        return 0;
    }
    else{
        a.top = a.top + 1;
        a.data[a.top] = x;
        return 1;
    } 
}

//删除
int DeleteQueue(Queue &a,ElemType x){
    if(a.front == a.rear && a.tag == 0){
        printf("当前队列已空！");
        return 0;
    }
    else{
        x = a.data[a.front];
        a.data[a.front] = 0;
        a.tag = 0;  //删除队列tag置0
        a.front = (a.front + 1) % MAXSIZE;  //front指针+1
        return x;
    }  
}
int DeleteSqstack(Sqstack &a,ElemType x){
    if(a.top == -1){
        printf("当前栈已空！");
        return 0;
    }
    else{
        x = a.data[a.top];
        a.data[a.top] = 0;
        a.top = a.top - 1;
        return x;
    }  
}

int ReverseQueue(Queue &a){
    Sqstack B;
    InitStack(B);
    int q = a.front;  //记录一下起始地址位置
    int x;
    while(a.front!=a.rear || a.tag!=0){
        InsertSqstack(B, DeleteQueue(a, x));  //出队列，入栈
    }
    a.front = q;
    a.rear = q;
    while(B.top!=-1){
        InsertQueue(a, DeleteSqstack(B, x));  //入队列，出栈
    }
    return 0;
}

int main(){
    Queue a;
    int x;
    InitQueue(a);
    InsertQueue(a, 1);
    InsertQueue(a, 2);
    InsertQueue(a, 3);
    InsertQueue(a, 4);
    InsertQueue(a, 5);
    InsertQueue(a, 6);
    DeleteQueue(a, x);
    InsertQueue(a, 7);
    PrintQueue(a);
    ReverseQueue(a);
    PrintQueue(a);
    return 0;
}

输出：

当前队列所有元素：[7] [2] [3] [4] [5] [6] 
当前队列所有元素：[2] [7] [6] [5] [4] [3]

当前队列所有元素：[0] [2] [3] [4] [0] [0] 
当前队列所有元素：[0] [4] [3] [2] [0] [0]

当前队列所有元素：[7] [0] [3] [4] [5] [6] 
当前队列所有元素：[3] [0] [7] [6] [5] [4]

试题6：（3.3.6节题1）利用栈进行括号匹配

这题原理十分简单，不多解释。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
#define MAXSIZE 10
#define ElemType char
#define Status int
 
//栈的数据结构
typedef struct Sqstack{
    ElemType data[MAXSIZE];
    int top;  //栈顶指针指向栈顶元素
} Sqstack;

//初始化
int InitStack(Sqstack &a){
    for (int i = 0; i < MAXSIZE;i++){
        a.data[i] = '0';
    }
    a.top = -1;
    return 1;
}

//插入
int InsertSqstack(Sqstack &a,ElemType x){
    if(a.top == MAXSIZE-1){
        printf("当前栈已满！");
        return 0;
    }
    else{
        a.top = a.top + 1;
        a.data[a.top] = x;
        return 1;
    } 
}

//删除
int DeleteSqstack(Sqstack &a){
    ElemType x;
    if(a.top == -1){
        printf("当前栈已空！");
        return 0;
    }
    else{
        x = a.data[a.top];
        a.data[a.top] = '0';
        a.top = a.top - 1;
        return x;
    }  
}

bool BracketsCheck(char str[]){
    Sqstack a;
    InitStack(a);
    int i = 0;
    char x = '0';
    while (str[i]!='\0'){
        switch (str[i]){
            case '[':
                InsertSqstack(a, str[i]);
                break;
            case '(':
                InsertSqstack(a, str[i]);
                break;
            case '{':
                InsertSqstack(a, str[i]);
                break;
            case '}':
                x = DeleteSqstack(a);
                if(x != '{'){
                    printf("输入括号序列不匹配！");
                    return false;
                }
                break;
            case ']':
                x = DeleteSqstack(a);
                if(x != '['){
                    printf("输入括号序列不匹配！");
                    return false;
                }
                break;
            case ')':
                x = DeleteSqstack(a);
                if(x != '('){
                    printf("输入括号序列不匹配！");
                    return false;
                }
                break;
            default:
                break;
        }//switch
        i = i + 1;
    }//while

    if(a.top != -1){
        printf("输入括号序列不匹配！");
        return false;
    }
    else{
        printf("输入括号序列匹配！");
        return true;
    }
}

int main(){
    printf("输入括号序列：");
    char str[10];
    gets(str);
    BracketsCheck(str);
    return 0;
}

输出：

输入括号序列：([]
输入括号序列不匹配！

输入括号序列：(())
输入括号序列匹配！

试题7：（3.3.6节题2）铁路调度问题

所用栈的数据结构与上一题相同。

void TrainDispatch(char str[]){
    Sqstack a;
    InitStack(a);
    char x;
    int i = 0;
    while(str[i]!='\0'){
        if(str[i] == 'H'){
            InsertSqstack(a, str[i]);
        }
        else{
            printf("S");
        }
        i = i + 1;
    }
    while(a.top!=-1){
        x = DeleteSqstack(a);
        printf("%c", x);
    }
}

int main(){
    printf("输入火车序列：");
    char str[10];
    gets(str);
    TrainDispatch(str);
    return 0;
}

输出：

输入火车序列：SHSHSH
SSSHHH

试题8：（3.3.6节题3）利用栈实现递归函数的非递归计算：P_n(x)=\left\{\begin{matrix} 1,n=0\\ 2x,n=1 \\ 2xP_{n-1}(x)-2(n-1)P_{n-2}(x),n>1 \end{matrix}\right.

所用栈的数据结构同上。

double p(int n,double x){
    Sqstack a;
    InitStack(a);
    double fv0 = 1;
    double fv1 = 2 * x;
    if(n==0)
        return fv0;
    else if(n==1)
        return fv1;
    else{
        for (int i = 2; i <= n;i++){
            a.top = a.top + 1;
        }
        for (int i = 2; i <= n; i++){
            a.data[a.top] = 2 * x * fv1 - 2 * (i - 1) * fv0;
            fv0 = fv1;
            fv1 = a.data[a.top];
            a.top = a.top - 1;
        }
        return fv1;
    }
}

int main(){
    printf("%f\n",p(2,3));
    printf("%f\n",p(3,3));
    return 0;
}

输出：

34.000000
180.000000

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

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

相关文章

C++——namespace std

C++——namespace std

命名空间&#xff08;namespace&#xff09; 0.使用方法 namespace 命名空间名 {... } 1. 每个命名空间都是一个作用域 同其他作用域类似&#xff0c;命名空间中的每个名字都必须表示该空间内的唯一实体。因为不同命名空间的作用域不同&#xff0c;所以在不同命名空间内可以…
阅读更多...
Neural Insights for Digital Marketing Content Design 阅读笔记

Neural Insights for Digital Marketing Content Design 阅读笔记

KDD-2023 很值得读的文章&#xff01; 1 摘要 电商里&#xff0c;营销内容的实验&#xff0c;很重要。 然而&#xff0c;创作营销内容是一个手动和耗时的过程&#xff0c;缺乏明确的指导原则。 本文通过 基于历史数据的AI驱动的可行性洞察&#xff0c;来弥补 营销内容创作 和…
阅读更多...
96 # cookie

96 # cookie

cookie 和 session 和 sessionStorage 和 localStorage localStorage 和 sessionStorage 本地储存&#xff08;发送请求不会携带&#xff09;&#xff0c;不能跨域localStorage 浏览器关闭后不会清空&#xff0c;必须手动清空sessionStorage 浏览器关闭后就会销毁http 无状态的…
阅读更多...
【Vue】条件渲染列表渲染来啦

【Vue】条件渲染列表渲染来啦

hello&#xff0c;我是小索奇哈&#xff0c;精心制作的Vue系列持续发放&#xff0c;涵盖大量的经验和示例&#xff0c;由浅入深进行讲解。 本章给大家讲解的是条件&列表渲染&#xff0c;前面的章节已经更新完毕&#xff0c;后面的章节持续输出&#xff0c;有任何问题都可以…
阅读更多...
Anaconda启动错误

Anaconda启动错误

错误 An unexpected error occurred on Navigator start-up | Could not find a suitable TLS CA certificate bundle, invalid path 导致Anaconda启动失败&#xff01; [解决办法]1 找到anaconda的安装目录&#xff0c;该目录下的__init__.py 这两处分别改为verifyself.sessio…
阅读更多...
程序员不得不知道的排序算法-上

程序员不得不知道的排序算法-上

目录 前言 1.冒泡排序 2.选择排序 3.插入排序 4.希尔排序 5.快速排序 6.归并排序 总结 前言 今天给大家讲一下常用的排序算法 1.冒泡排序 冒泡排序&#xff08;Bubble Sort&#xff09;是一种简单的排序算法&#xff0c;它重复地从待排序的元素中比较相邻的两个元素&a…
阅读更多...
如何制作gif动图gif （多图合成gif、GIF录制软件、视频制作成GIF动图）

如何制作gif动图gif （多图合成gif、GIF录制软件、视频制作成GIF动图）

文章目录 1 在线制作多图合成gif动画2 GIF录制软件3 将现有的视频 制作成GIF动图 1 在线制作多图合成gif动画 在线制作gif动画链接:https://www.matools.com/gif ①选择需要制作gif动画的图片将其添加 ②调整时间间隔&#xff0c;图片宽高等设置 ③一键生成gif ④下载到本…
阅读更多...
十年耕耘，致力于让垂直领域合作企业提升竞争力

十年耕耘，致力于让垂直领域合作企业提升竞争力

2013年6月叶帆科技公司成立&#xff0c;时光如驹&#xff0c;距今已经十年了&#xff08;叶帆科技的前身叶帆工作室&#xff0c;官方博客上的第一篇博文发表于2004年6月&#xff0c;已近二十年了&#xff09;。 十年时间&#xff0c;初心不变&#xff0c;一直和各垂直领域的企…
阅读更多...
最新AI写作系统ChatGPT源码/支持GPT4.0+GPT联网提问/支持ai绘画Midjourney+Prompt应用+MJ以图生图+思维导图生成

最新AI写作系统ChatGPT源码/支持GPT4.0+GPT联网提问/支持ai绘画Midjourney+Prompt应用+MJ以图生图+思维导图生成

一、智能创作系统 SparkAi创作系统是基于国外很火的ChatGPT进行开发的Ai智能问答系统。本期针对源码系统整体测试下来非常完美&#xff0c;可以说SparkAi是目前国内一款的ChatGPT对接OpenAI软件系统。那么如何搭建部署AI创作ChatGPT&#xff1f;小编这里写一个详细图文教程吧&…
阅读更多...
使用ElementUI完成登入注册的跨域请求提高开发效率

使用ElementUI完成登入注册的跨域请求提高开发效率

&#x1f3ac; 艳艳耶✌️&#xff1a;个人主页 &#x1f525; 个人专栏 &#xff1a;《Spring与Mybatis集成整合》​​​​​​​ ⛺️ 生活的理想&#xff0c;为了不断更新自己 ! 目录 ​编辑 1、前言 1.1.什么是ELementUI 2、完成登陆注册前端页面 2.1环境搭建 运行…
阅读更多...
通过pfx格式证书生成Nginx的SSL证书

通过pfx格式证书生成Nginx的SSL证书

1、安装openssl 工具地址&#xff1a;Win32/Win64 OpenSSL Installer for Windows - Shining Light Productions 安装完成后&#xff0c;自行配置环境变量。 2、生成证书 &#xff08;1&#xff09;以管理员身份运行cmd&#xff0c;进入到pfx文件的目录&#xff1a; &#x…
阅读更多...
CSS详细基础（二）文本样式

CSS详细基础（二）文本样式

插播一条CSS的工作原理&#xff1a; CSS是一种定义样式结构如字体、颜色、位置等的语言&#xff0c;被用于描述网页上的信息格式化和显示的方式。CSS样式可以直接存储于HTML网页或者单独的样式单文件。无论哪一种方式&#xff0c;样式单包含将样式应用到指定类型的元素的规则。…
阅读更多...
postman记录backup

postman记录backup

之前一直未登录postman&#xff0c;在临时空间处理请求&#xff0c;可能是因为postman更新了&#xff0c;导致其记录没了 别着急&#xff01; 首先我们先登录postman&#xff0c;有谷歌登录方式等 第一步、登录后点击import 第二步、点击files 第三步、找到c:/users/AppData…
阅读更多...
三、VXLAN静态方式实验举例

三、VXLAN静态方式实验举例

VXLAN静态方式实验举例 1.1、静态方式部署集中式网关1.1.1、VXLAN隧道建立1.1.2、MAC地址动态学习1.1.3、同子网已知单播报文转发1.1.4、同子网BUM报文转发1.1.5、跨子网报文转发1.1.6、配置VXLAN接入业务部署方式 1.2、配置举例&#xff0c;相同网段互通&#xff08;静态方式&…
阅读更多...
JVS低代码开发工具：触发逻辑引擎后对象变量节点回显配置说明

JVS低代码开发工具：触发逻辑引擎后对象变量节点回显配置说明

使用说明 通常业务中会涉及到表单上部分字段填写后通过触发逻辑处理已填写的数据进行回显到表单上&#xff0c;这时我们可以采用业务逻辑来配置对象变量节点进行表单数据回显。 对象变量&#xff1a;将自定义字段重新组装新的数据结构&#xff0c;数据结构类型为对象。 设计…
阅读更多...
【网络安全】2023年堡垒机品牌大全

【网络安全】2023年堡垒机品牌大全

随着大家网络安全意识的增加&#xff0c;随着国家等保政策的严格执行&#xff0c;越来越多的企业开始采购堡垒机。这里就给大家总结了部分堡垒机品牌&#xff0c;让大家参考参考。 2023年堡垒机品牌大全 1、行云堡垒 2、JumpServer 3、安恒 4、骞云 5、齐治 6、阿里云 …
阅读更多...
ahk系列——ahk_v2实现win10任意界面搜狗翻译

ahk系列——ahk_v2实现win10任意界面搜狗翻译

1、准备环境 win10或者以上系统安装ahkv2_64环境&#xff0c;安装包安装好后会有32和64位的unicode版本准备一个编译器&#xff0c;我用idea&#xff0c;不会ahk编程的我会把编译好的exe连接放到最后需要 联网 才能翻译 2、 使用方法 选中需要翻译的文字&#xff0c;然后ctr…
阅读更多...
【算法】递归（高阶题目） -随时补充

【算法】递归（高阶题目） -随时补充

文章目录 岛问题汉诺塔问题牛群繁衍数量问题求字符串的全部子序列字符串的全排列数字的全排列I数字的全排列IIN皇后IIN皇后I 岛问题 递归的方法: 遍历岛这个二维数组&#xff0c;如果当前数为1&#xff0c;则进入感染函数并将岛个数1感染函数&#xff1a;其实就是一个递归标注…
阅读更多...
win11+wsl+git+cmake+x86gcc+armgcc+clangformat+vscode环境安装

win11+wsl+git+cmake+x86gcc+armgcc+clangformat+vscode环境安装

一、安装wsl &#xff08;1&#xff09;打开power shell 并运行&#xff1a; Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Windows-Subsystem-Linux Enable-WindowsOptionalFeature -Online -FeatureName VirtualMachinePlatform &#xff08;2&#xff0…
阅读更多...
通过containerd部署k8s集群环境及初始化时部分报错解决

通过containerd部署k8s集群环境及初始化时部分报错解决

目录 一.基础环境配置&#xff08;每个节点都做&#xff09; 1.hosts解析 2.防火墙和selinux 3.安装基本软件并配置时间同步 4.禁用swap分区 5.更改内核参数 6.配置ipvs 7.k8s下载 &#xff08;1&#xff09;配置镜像下载相关软件 &#xff08;2&#xff09;配置kube…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023