数据结构（三）----栈和队列

目录

一.栈

1.栈的基本概念

2.栈的基本操作

3.顺序栈的实现

•顺序栈的定义

•顺序栈的初始化

•进栈操作

  •出栈操作

  •读栈顶元素操作

  •若使用另一种方式:

4.链栈的实现

•链栈的进栈操作

•链栈的出栈操作

•读栈顶元素

二.队列

1.队列的基本概念

2.队列的基本操作

3.用顺序存储实现队列

•初始化

•入队操作

•出队操作

•获得队头元素的值

•判满/空方案

4.用链式存储实现队列

•初始化

•入队操作

•出队操作

•队列满的条件

三.双端队列

一.栈

1.栈的基本概念

栈(stack)是只允许在一端进行插入或删除操作的线性表。

栈顶：允许插入和删除的一端。最上面的元素被称为栈顶元素。

栈底：不允许插入和删除的一端。最下面的元素被称为栈底元素。

如下图所示：

进栈顺序：a1-->a2-->a3-->a4-->a5

出栈顺序：a5-->a4-->a3-->a2-->a1

所以栈的特点是后进先出（Last In First Out ( LIFO )）

补充：

n个不同元素进栈，出栈元素不同排列的个数为\frac{1}{n+1}C_{2n}^{n}。

上述公式称为卡特兰(Catalan)数，可采用数学归纳证明。

2.栈的基本操作

•Initstack(&S)：初始化栈。构造一个空栈S，分配内存空间。
•DestroyStack(&L)：销毁栈。销毁并释放栈s所占用的内存空间。
•Push(&S,x)：进栈，若栈S未满，则将x加入使之成为新栈顶。

•Pop(&S,&x)：出栈，若栈S非空，则弹出栈顶元素，并用x返回。
•GetTop(S,&x)：读栈顶元素。若栈S非空，则用x返回栈顶元素。
其他常用操作:
StackEmpty(S)：判断一个栈S是否为空。若S为空，则返回true，否则返回false。

3.顺序栈的实现
•顺序栈的定义
#define Maxsize 10    //定义栈中元素的最大个数
typedef struct{ElemType data[Maxsize];    //静态数组存放栈中元素int top;    //栈顶指针
} SqStack;void testStack(){SqStack S;     //声明一个顺序栈(分配空间)
}
//这里使用声明的方式分配内存空间，并没有使用malloc函数。
//所以给这个栈分配的内存空间，会在函数结束之后又系统自动回收。

声明顺序栈后，就会给各个数据元素分配连续的存储空间，大小为MaxSize*sizeof(ElemType)的空间。

•顺序栈的初始化
#define Maxsize 10    //定义栈中元素的最大个数
typedef struct{
ElemType data[Maxsize];    //静态数组存放栈中元素
int top;    //栈顶指针
} SqStack;//初始化栈
void Initstack(Sqstack &S){S.top=-1;    //初始化栈顶指针
}//判断栈空
bool StackEmpty(SqStack S){if(S.top==-1)    //栈空return true ;else             //不空return false;
}void testStack(){SqStack S;InitStack(S);
}

•进栈操作
#define MaxSize 10
typedef struct{ElemType data[Maxsize];int top;
} Sqstack;//新元素入栈
bool Push(SqStack &S,ElemType x){if(S.top == MaxSize-1)    //栈满，报错return false;S.top = S.top + 1;    //指针先加1S.data[s.top]=x;      //新元素入栈return true;
}//或者写为
bool Push(SqStack &S,ElemType x){if(S.top == MaxSize-1)    //栈满，报错return false;S.data[++S.top]=x;return true;
}

//不能写为
bool Push(SqStack &S,ElemType x){if(S.top == MaxSize-1)    //栈满，报错return false;S.data[S.top++]=x;return true;
}//这意味着
bool Push(SqStack &S,ElemType x){if(S.top == MaxSize-1)    //栈满，报错return false;    S.data[s.top]=x;    //新进栈的元素会把以前的元素覆盖 S.top = S.top + 1;return true;
}

  •出栈操作
#define MaxSize 10
typedef struct{ElemType data[Maxsize];int top;
} Sqstack;//出栈操作
bool Pop(Sqstack &S,ElemType &x){if(S.top==-1)    //栈空，报错return false;x=S.data[S.top];    //栈顶元素先出栈S.top=S.top-1;    //指针再减1return true;
}
//删除操作中，top指针往下移,只是逻辑上被删除了，数据还残留在内存中。//出栈操作也可写为
bool Pop(Sqstack &S,ElemType &x){if(S.top==-1)    //栈空，报错return false;x=S.data[S.top--];return true;
}
//不能写为
bool Pop(Sqstack &S,ElemType &x){if(S.top==-1)    //栈空，报错return false;x=S.data[--S.top];return true;
}//这意味着
bool Pop(Sqstack &S,ElemType &x){if(S.top==-1)    //栈空，报错return false;S.top=S.top-1;x=S.data[S.top];return true;
}

 如果先减，再将top的值赋给x，那么x值就会返回"i"，而不是"j"

  •读栈顶元素操作
#define Maxsize 10
typedef struct{ElemType data[Maxsize];int top;
} Sqstack;//出栈澡作
bool Pop(Sqstack &S,ElemType &x){if(S.top==-1)    //栈空，报错return false;x=S.data[s.top--];    //先出栈，指针再减1return true;
}//读栈顶元素
bool GetTop(Sqstack S,ElemType &x){if(S.top==-1)    //栈空，报错return false;x=S.data[s.top];    //x记录栈顶元素return true;
}
//可以看到，出栈操作和读栈顶元素非常类似。

  •若使用另一种方式:

将top指针刚开始指向0，判断栈是否为空，即判断S.top==0，这样设计是将top指针指向下一个能插入元素的位置。

若进行入栈操作时，需要先把x放到top指针指向的位置，再让top+1，和之前的方式相反。

出栈操作也是，需要先让top-1，再把top指向的数据元素传回去。

代码如下：

#define Maxsize 10
typedef struct{ElemType data[Maxsize];int top;
} SqStack;//初始化栈
void Initstack(Sqstack &s){S.top=0;    //初始化指向0
}bool StackEmpty(Sqstack S){if(S.top==0)    //栈空return true;elsereturn false;
}//入栈操作
bool Push(SqStack &S,ElemType x){if(S.top == MaxSize)    //栈满，报错return false;S.data[S.top++]=x;return true;
}//出栈操作
bool Pop(Sqstack &S,ElemType &x){if(S.top==0)    //栈空，报错return false;x=S.data[--S.top];return true;
}void testStack(){    判断栈空SqStacks;//声明一个顺序栈InitStack(S);
}

顺序栈的缺点是栈的大小不可变，可以在刚开始就给栈分配大片的内存空间，但这样会导致内存空间的浪费，可以使用共享栈提高内存空间的利用率。共享栈即两个栈共享同一片内存空间。

代码如下：

#define MaxSize 10
typedef struct{ElemType data[Maxsize];    //静态数组存放栈中元素int top0;    //0号栈栈顶指针int top1;    //1号栈浅顶指针
} Shstack;//初始化栈
void InitStack(Shstack &S){S.top0=-1;    //初始化栈顶指针S.top1=Maxsize;
}

可以看到，共享栈判断栈满的条件：top0+1=top1

总结：

4.链栈的实现

对于链栈而言，其进栈操作其实对应于链表中对头结点的"后插"操作，出栈操作对应于链表中对头结点的"后删"操作,就是将链头的一端看作栈顶的一端。

建议先看：http://t.csdnimg.cn/IknBJ

代码如下：

//链栈的定义和链表的定义是相同的，只是命名不同
typedef struct Linknode{ElemType data;struct Linknode *next;
}LiStack;    //栈类型定义//带头结点
bool InitStack(LiStack &L){L=(Linknode *)malloc(sizeof(Linknode));if(L==NULL)return false;    //内存不足，分配失败L->next=NULL;return true;    
}bool Empty(LinkList L){return(L->next == NULL);
}//不带头结点
bool InitStack(LiStack &L){L=NULL;return true;
}bool Empty(LinkList L){return(L=NULL);
}
•链栈的进栈操作
//带头结点
LiStack LiSPush(LiStack &L){Linknode *s;int x;L=(LiStack)malloc(size(Linknode));L->next=NULL;scanf("%d",&x);while(x!=9999){s=(Linknode *)malloc(sizeof(Linknode));s->data=x;s->next=L->next;L->next=s;scanf("%d",&x);}return L;
}//不带头结点
LiStack LisPush(LiStack &L){Linknode *s;int x;L=NULL;scanf("%d",&x);while(x!=9999){s=(Linknode *)malloc(sizeof(Linknode));s->data=x;s->next=L;L=s;scanf("%d",&x);}return L;
}
•链栈的出栈操作
//带头结点
LiStack LisPop(LiStack &L, int &e) {if (L->next == NULL) {// 栈空，无法出栈return NULL;}Linknode *q = L->next;e = q->data;L->next = q->next;free(q);return L;
}//不带头结点
LiStack LisPop(LiStack &L, int &e) {if (L == NULL) {// 栈空，无法出栈return NULL;}Linknode *q = L;e = q->data;L = L->next;free(q);return L;
}
•读栈顶元素
//带头结点
int GetTop(LiStack &L) {if (L->next == NULL) {// 栈为空return -1; // 或者抛出异常}return L->next->data;
}//不带头结点
int GetTop(LiStack &L) {if (L == NULL) {// 栈为空return -1; // 或者抛出异常}return L->data;
}

二.队列

1.队列的基本概念

栈(stack)是只允许在一端进行插入或删除操作的线性表。队列(aueue)是只允许在一端进行插入，在另一端删除的线性表。

队头，队尾，空队列:

空队列：没有数据元素

队头：允许删除的一端

队尾：允许插入的一端

队列的特点：先进入队列的元素先出队，即先进先出（First In First Out,FIFO）。

2.队列的基本操作

Initaueue(&Q)：初始化队列，构造一个空队列。

DestroyQueue(&Q)：销毁队列。销毁并释放队列Q所占用的内存空间。

EnQueue(&Q,x)：入队，若队列Q未满，将x加入，使之成为新的队尾。

DeQueue(&a,&x)：出队，若队列Q非空，删除队头元素，并用x返回。
GetHead(a,&x)：读队头元素，若队列Q非空，则将队头元素赋值给x。

其他常用操作：

QueueEmpty(Q)：判队列空，若队列Q为空返回true，否则返回false。

3.用顺序存储实现队列
•初始化
#define Maxsize 10    //定义队列中元素的最大个数
typedef struct{ElemType data[Maxsize];    //用静态数组存放队列元素int front,rear;    //队头指针和队尾指针
}SqQueue;void testQueue(){SqQueue Q;//声明一个队列
}

声明一个队列后，系统会分配一片连续的存储空间，大小为MaxSize*sizeof(ElemType)，如下图所示：

队头指针：指向队头元素。

队尾指针：指向队尾元素的后一个位置。

所以还没有插入元素时，队头指针与队尾指针同时指向data[0]：

#define Maxsize 10    //定义队列中元素的最大个数
typedef struct{ElemType data[Maxsize];    //用静态数组存放队列元素int front,rear;    //队头指针和队尾指针
}SqQueue;void InitQueue(SqQueue &Q){//初始时，队头和队尾指针指向0Q.rear=Q.front=0;
}//判空
bool QueueEmpty(SqQueue Q){if(Q.rear==Q.front)    //队空条件return true;elsereturn false;void testQueue(){SqQueue Q;//声明一个队列InitQueue(Q);}

•入队操作

只能从队尾入队

#define MaxSize 10
typedef struct{ElemType data[Maxsize];int front,rear;
} SqQueue;//入队
bool EnQueue(SqQueue &Q,ElemType x){if(Q.rear==MaxSize)    return false;    //队满则报错Q.data[Q.rear]=x;    //新元素插入队尾Q.rear=(Q.rear+1);return true;
}

注：rear=MaxSize不能作为队列已满的判断条件，上面的写法是错误的。如下图所示，若前面的元素出队了，要再插入元素，可以从前面无数据元素的区域插入。

正确写法：

#define MaxSize 10
typedef struct{ElemType data[Maxsize];int front,rear;
} SqQueue;//入队
bool EnQueue(SqQueue &Q,ElemType x){if((Q.rear+1)%MaxSize=Q.front)    //判满return false;    //队满则报错Q.data[Q.rear]=x;    //新元素插入队尾Q.rear=(Q.rear+1)%MaxSize;    //队尾指针加1取模return true;
}

这里的Q.rear=(Q.rear)%MaxSize实现的效果是：当（Q.rear+1）%MaxSize==0时，即“队满”时，会将rear指针重新指向data[0]。

这样用模运算，将存储空间在逻辑上变成了“环状。

如下图所示，队满条件是：队尾指针的再下一个位置是队头，即(Q.rear+1)%MaxSize==Q.front

为什么需要不能再插入一个元素，并且使rear和front指向同一个元素呢？

因为初始化队列的时候，rear指针与front指针就是指向同一个位置，同时我们也是通过判断rear和front指针是否指向同一个位置，判断队列是否为空的。

如果再插入一个元素，rear和front指针指向同一个位置，这样，判满与判空条件就会混淆起来。

所以必须牺牲一个存储单元，以区分队列满还是空。

•出队操作

只能让队头元素出队：

//出队(删除一个队头元素，并用x返回)
bool DeQueue(sqQueue &Q,ElemType &x){if(Q.rear==Q.front)    //当队头指针与队尾指针再次指向同一个位置时，说明队空return false;    //队空则报错x=Q.data[Q.front];Q.front=(Q.front+1)%Maxsize;    //队头指针后移return true;
}

•获得队头元素的值
//获得队头元素的值，用x返回
bool GetHead(SqQueue Q,ElemType &x){if(Q.rear==Q.front)    //队空则报错return false;x=Q.data[Q.front];return true;
}//相比于出队操作,获取队头的值不需要将队头指针后移
bool DeQueue(sqQueue &Q,ElemType &x){if(Q.rear==Q.front)    //当队头指针与队尾指针再次指向同一个位置时，说明队空return false;  x=Q.data[Q.front];Q.front=(Q.front+1)%Maxsize;    return true;
}
•判满/空方案

方案一：

以上方案中，判断队列已满的条件：队尾指针的再下一个位置是队头，即：

(Q.rear+1)%MaxSize==Q.front

队空条件：队头指针与队尾指针指向同一个地方，即：

Q.rear=Q.front

队列元素个数：

(rear+MaxSize-front)%MaxSize

例如下图，rear=2，front=3，那么队列元素个数就是：（2+10-3）%10 =9%10=9

其实也可以不用牺牲一个存储空间，下面两种方案可供参考。

方案二：

#define MaxSize 10
typedef struct{ElemType data[MaxSize];int front,rear;int size;    //用size表示当前队列的长度，当入队成功size++，出队成功size--
}SqQueue;

具体代码如下： 

#define MaxSize 10
typedef struct {ElemType data[MaxSize];int front, rear;int size; // 用size表示当前队列的长度，当入队成功size++，出队成功size--
} SqQueue;// 初始化队列
void InitQueue(SqQueue &Q) {Q.front = Q.rear = 0;Q.size = 0;
}// 判断队列是否为空
bool QueueIsEmpty(SqQueue Q) {return (Q.rear == Q.front) && (Q.size == 0);
}// 判断队列是否已满
bool QueueIsFull(SqQueue Q) {return (Q.rear == Q.front) && (Q.size == MaxSize);
}// 入队操作
bool EnQueue(SqQueue &Q, ElemType x) {if (QueueIsFull(Q))return false;Q.data[Q.rear] = x;Q.rear = (Q.rear + 1) % MaxSize;Q.size++;return true;
}// 出队操作
bool DeQueue(SqQueue &Q, ElemType &x) {if (QueueIsEmpty(Q))    // 队列为空return false;x = Q.data[Q.front];Q.front = (Q.front + 1) % MaxSize;Q.size--;return true;
}

方案三：

#define Maxsize 10
typedef struct{ElemType data[Maxsize];int front,rear;int tag;    //记录最近进行的是删除/插入
//每次删除操作成功时，都令tag=0，每次插入成功时，都令tag=1;
} SqQueue;

只有删除操作，才能导致队空，只有插入操作，才能导致队满。所以：

具体代码如下： 

#define Maxsize 10
typedef struct{ElemType data[Maxsize];int front,rear;int tag;    //记录最近进行的是删除/插入
//每次删除操作成功时，都令tag=0，每次插入成功时，都令tag=1;
} SqQueue;// 初始化队列
void InitQueue(SqQueue &Q) {Q.front = Q.rear = 0;Q.tag = 0; // 初始时没有进行过操作，设置tag为0
}// 判断队列是否为空
bool QueueIsEmpty(SqQueue Q) {return Q.front == Q.rear && Q.tag == 0;
}// 判断队列是否已满
bool QueueIsFull(SqQueue Q) {return Q.front == Q.rear && Q.tag == 1;
}// 入队操作
bool EnQueue(SqQueue &Q, ElemType x) {if (QueueIsFull(Q)) {return false;}Q.data[Q.rear] = x;Q.rear = (Q.rear + 1) % Maxsize;Q.tag = 1; // 插入成功，设置tag为1return true;
}// 出队操作
bool DeQueue(SqQueue &Q, ElemType &x) {if (QueueIsEmpty(Q)) {return false;}x = Q.data[Q.front];Q.front = (Q.front + 1) % Maxsize;Q.tag = 0; // 删除成功，设置tag为0return true;
}

在考试时，也可能出现rear指向队尾元素的情况，如下图所示：

//rear指向队尾元素的后一个位置时入队操作：
Q.data[Q.rear]=x;
Q.rear=(Q.rear+1)%MaxSize;//rear指向队尾元素时入队操作：
Q.rear=(Q.rear+1)%MaxSize;
Q.data[Q.rear]=x;

初始化操作：

void InitQueue(SqQueue &Q){//初始时，队头和队尾指针指向0Q.front=0;Q.rear=MaxSize-1;
}

判空操作： 

//判空
bool QueueEmpty(SqQueue Q){if((Q.rear+1)%MaxSize==Q.front)    //队空条件return true;elsereturn false;

判满操作：

判满也不能用与判空相同的条件了：

可以牺牲一个存储空间，即队空时，队尾指针在队头指针后面一个位置，队满时，队尾指针在队头指针后面两个位置。

或者向上面说的一样，增加辅助变量，如size，tag

这里只演示牺牲一个存储空间的情况：

#define Maxsize 10
typedef struct{ElemType data[Maxsize];int front,rear;
} SqQueue;// 初始化队列
void InitQueue(SqQueue &Q) {Q.front = 0;Q.rear =MaxSze-1;}//判空
bool QueueEmpty(SqQueue Q){if((Q.rear+1)%MaxSize==Q.front)    //队空条件return true;elsereturn false;//判满
bool QueueEmpty(SqQueue Q){if((Q.rear+2)%MaxSize==Q.front)    //队空条件return true;elsereturn false;// 入队操作
bool EnQueue(SqQueue &Q, ElemType x) {if (QueueIsFull(Q)) {return false;}Q.rear=(Q.rear+1)%MaxSize;    //先往后移一个存储空间，再赋值Q.data[Q.rear]=x;return true;
}// 出队操作
bool DeQueue(SqQueue &Q, ElemType &x) {if (QueueIsEmpty(Q)) {return false;}x = Q.data[Q.front];    Q.front = (Q.front + 1) % Maxsize;return true;
}

总结：

4.用链式存储实现队列
•初始化
typedef struct LinkNode{        //链式队列结点ElemType data;struct LinkNode *next;
}LinkNode;typedef struct{    //链式队列LinkNode *front,*rear;    //队列的队头和队尾指针
}LinkQueue;


typedef struct LinkNode{        //链式队列结点ElemType data;struct LinkNode *next;
}LinkNode;typedef struct{    //链式队列LinkNode *front,*rear;    //队列的队头和队尾指针
}LinkQueue;//初始化队列(带头结点)
void InitQueue(LinkQueue &Q){//初始时 front、rear 都指向头结点Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkNode));Q.front->next=NULL;
}//判断队列是否为空
bool IsEmpty(LinkQueue Q){if(Q.front==Q.rear)return true;elsereturn false;
}void testLinkQueue(){LinkQueue Q;    //声明一个队列InitQueue(Q);   //初始化队列
}//初始化队列(不带头结点)
void InitQueue(LinkQueue &Q){//初始时 front、rear 都指向NULLQ.front=NULL;Q.rear=NULL;
}//判断队列是否为空(不带头结点)
bool IsEmpty(LinkQueue Q){if(Q.front==NULL)return true;elsereturn false;
}

•入队操作
//新元素入队(带头结点)
void EnQueue(LinkQueue &Q,ElemType x){LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));s->data=x;s->next=NULL;    //新结点插入到rear之后    Q.rear->next=s;  //修改表尾指针Q.rear=s;

首先申请一个新结点，并把数据元素放到这一新结点当中：s->data=x;

新插入的结点一定是队列的最后一个结点，所以该结点的next指针指向NULL:s->next=NULL

将rear指向的结点的next指针指向新申请的s结点：Q.rear->next=s;

最后表尾指针会指向新的表尾结点：Q.rear=s;

若不带头结点，在第一个元素入队时，就需要进行特殊的处理：

//新元素入队(不带头结点)
void EnQueue(LinkQueue &Q,ElemType x){LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));s->data=x;s->next=NULL;if(Q.front == NULL){    //在空队列中插入第一个元素Q.front = s;    //修改队头队尾指针Q.rear=s;    } else {    Q.rear->next=s;    //新结点插入到 rear 结点之后Q.rear=s;    //修改 rear 指针}
}

•出队操作
//队头元素出队(带头结点)
bool DeQueue(LinkQueue &Q,ElemType &x){if(Q.front==Q.rear)return false;    //空队LinkNode *p=Q.front->next;x=p->data;    //用变量x返回队头元素Q.front->next=p->next;    //修改头结点的 next 指针if(Q.rear==p)    //此次是最后一个结点出队Q.rear=Q.front;    //修改rear指针free(p);    //释放结点空间return true;
}

首先用p指向要出队的结点，即头结点之后的结点：LinkNode *p=Q.front->next;

接着修改头结点的后项指针：Q.front->next=p->next;

最后释放结点p：free(p)

若此次出队的结点p是当前队列的最后一个元素，在修改完头结点的后项指针后：

还需要修改表尾指针，让其指向头结点：Q.rear=Q.front;

最后释放p：free(p)

对于不带头结点的队列：

//队头元素出队(不带头结点)
bool DeQueue(LinkQueue &Q,ElemType &x){if(Q.front==NULL)    //空队return false;LinkNode *p=Q.front;    //p指向此次出队的结点x=p->data;    //用变量x返回队头元素Q.front=p->next;    //修改 front 指针if(Q.rear==p){Q.front = NULL;Q.rear = NULL;}free(p);return true;
}

每次出队的是front指针指向的结点：LinkNode *p=Q.front;

由于没有头结点，所以每一次队头出队时，就需要修改队头指针指向的结点：

Q.front=p->next;

最后一个结点出队后，将front和rear都指向NULL：Q.front=NULL;Q.rear=NULL;

•队列满的条件

对于顺序存储的队列，存储空间都是预分配的，预分配的存储空间耗尽，则队满。而对链式存储而言，一般不会对满，除非内存不足。

三.双端队列

之前学习的栈，只允许从一端插入和删除的线性表：

队列则只允许从一端插入，另一端删除的线性表：

双端队列则是允许从两端插入，也允许从两端删除的线性表：

若只使用其中一端的插入、删除操作，则效果等同于栈。所以，只要是栈能实现的功能，双端队列一定能够实现。

双端队列还可以分为：

输入受限的双端队列：只允许从一端插入、两端删除的线性表。

输出受限的双端队列：只允许从两端插入、一端删除的线性表。

对于栈而言，合法的出栈序列有14种，可用卡特兰数计算：

对于输入受限的双端队列：

在栈中合法的序列，在双端队列中一定合法，所以只需要看“在栈中不合法”的输出队列即可。

可以得到以下结果，划线的是在栈中不合法，而在输入受限的双端队列中合法的序列：

对于输出受限的双端队列，同理：

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

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

相关文章

关于ABP 新增表，dbfirst模式

关于ABP 新增表，dbfirst模式

下面的代码是基于abp生成的项目，项目名：Store 1.在Domain结尾的项目中通过EF工具生成数据实体： Scaffold-DbContext Data Source服务器IP;Initial Catalog数据库;User Idsa;Password密码;EncryptFalse; Microsoft.EntityFrameworkCore.SqlS…
阅读更多...
Java基础_15集合及其方法

Java基础_15集合及其方法

今天的内容 1.集合 1.集合【重点】 1.1为什么使用集合 集合和数组是一样的都是用来存储数据的！！！ 真实的开发的时候，使用的是集合不是数组，为啥？ 数组存数据: ​ 1.数组的容量是固定的 ​ 2.数组封装的方法…
阅读更多...
慢品人间烟火色，闲观万事岁月长

慢品人间烟火色，闲观万事岁月长

小女孩的衣柜里，怎能缺少一套别致的新中式穿搭？让我们的小公主在时尚与传统中寻找平衡 演绎属于自己的中国风魅力精致的小立领，淡淡的文艺复古气息 上衣系带设计，外加一层高透轻纱穿上身如亭亭玉立的大小姐整个人仿佛笼罩了一层…
阅读更多...
【docker】之linux写shell脚本备份线上数据库（备份为dump文件）

【docker】之linux写shell脚本备份线上数据库（备份为dump文件）

目录 1. SH文件1.1 SH文件示例1.2 文件解释1.3 .sh文件执行 2. 备份线上数据库的.sh文件2.1 文件命令解析 3. 命令执行4. 线下dump文件的恢复与备份 环境：linux容器：docker 1. SH文件 SH文件通常指的是 Shell 脚本文件，文件后缀名为.sh&…
阅读更多...
IP查询在追踪网络攻击源头中的应用

IP查询在追踪网络攻击源头中的应用

随着网络攻击事件的不断增加，追踪攻击源头成为网络安全领域的重要任务之一。IP查询技术通过分析网络流量中的IP地址，可以帮助确定攻击的来源。本文将探讨IP查询在追踪网络攻击源头中的应用，包括其原理、方法以及实际案例分析。 IP地址查询&a…
阅读更多...
比特币减半后 牛市爆发

比特币减半后 牛市爆发

作者：Arthur Hayes of Co-Founder of 100x 编译：Qin jin of ccvalue (以下内容仅代表作者个人观点，不应作为投资决策依据，也不应被视为参与投资交易的建议或意见）。 Ping PingPing，我的手机发出的声音&…
阅读更多...
Linux CentOS 安装 MySQL 服务教程

Linux CentOS 安装 MySQL 服务教程

Linux CentOS 安装 MySQL 服务教程 1. 查看系统和GNU C库(glibc)版本信息 1.1 查询机器 glibc 版本信息 glibc，全名GNU C Library，是大多数Linux发行版中使用的C库，为系统和应用程序提供核心的API接口。在Linux系统中，特别是在…
阅读更多...
js 数组 按列循环二维数组

js 数组 按列循环二维数组

期待效果&#xff1a; 核心代码&#xff1a; //js function handle(array) {var result [];for (let i 0; i < array[0].length; i) {var item []; for (let j 0; j < array.length; j) {item.push(array[j][i])} result.push(item);} return result; } 运行代码&a…
阅读更多...
酷开科技 | 酷开系统打破客厅局限让大家享受更智能便捷的服务

酷开科技 | 酷开系统打破客厅局限让大家享受更智能便捷的服务

曾经电视是家庭场景中的重要屏幕&#xff0c;是家庭发现世界和获取资讯的中心。但经历了近一百年的发展&#xff0c;传统电视行业进入瓶颈期&#xff0c;电视在家庭中的地位被逐渐替代。特别是智能手机的诞生&#xff0c;让手机成为个人生活的中心和全社会关注焦点&#xff0c;…
阅读更多...
STM32F7 MPU Cache的原理和一致性问题

STM32F7 MPU Cache的原理和一致性问题

目录 概述 1 Cache 及其原理 2 结构及策略 2.1 Cache类型 2.2 Cache实例 3 Cache 及 MPU 属性 4 Cache 一致性问题 4.1 未Clean写Cache情况 4.2 DMA 更新物理内存情况 4.3 一个实例 4.3.1 功能描述 4.3.2 代码实现 4.3.3 结论 概述 本文主要从结构原理以及应用方…
阅读更多...
接口自动化测试（python+pytest+requests）

接口自动化测试（python+pytest+requests）

一、选取自动化测试用例 优先级高：先实现业务流程用例、后实现单接口用例功能较稳定的接口优先开展测试用例脚本的实现二、搭建自动化测试环境 核心技术：编程语言:python；测试框架:pytest；接口请求:requests安装/验证requests:命令行终端分别输入 pip install requests / p…
阅读更多...
助力低碳出行 | 基于ACM32 MCU的电动滑板车方案

助力低碳出行 | 基于ACM32 MCU的电动滑板车方案

随着智能科技的快速发展&#xff0c;电动滑板车的驱动系统也得到了长足的发展。国内外的电动滑板车用电机驱动系统分为传统刷式电机和无刷电机两种类型。其中&#xff0c;传统的刷式电机已经逐渐被无刷电机所取代&#xff0c;无刷电机的性能和寿命都更出色&#xff0c;已成为电…
阅读更多...
蓝桥杯-单片机基础16——利用定时计数中断进行动态数码管的多窗口显示

蓝桥杯-单片机基础16——利用定时计数中断进行动态数码管的多窗口显示

综合查阅了网络上目前能找到的所有关于此技能的代码&#xff0c;最终找到了下述方式比较可靠&#xff0c;且可以自定义任意显示的数值。 传统采用延时函数的方式实现动态数码管扫描&#xff0c;在题目变复杂时效果总是会不佳&#xff0c;因此在省赛中有必要尝试采用定时计数器中…
阅读更多...
HCIP课后习题之一

HCIP课后习题之一

1、路由协议用工作机制上分为那几种&#xff1f;分别是&#xff1f; A&#xff1a;两种。分别是静态路由和动态路由&#xff08;可分为IGP和EGP&#xff09; 2、IGP和EGP协议有哪些&#xff1f; A&#xff1a;IGP: RIP、OSPF、ISIS、EIGRP EGP: BGP 3、路由优先级的用途&…
阅读更多...
嵌入式学习52-ARM1

嵌入式学习52-ARM1

知识零散&#xff1a; 1.flash&#xff1a; nor flash 可被寻地址 …
阅读更多...
如何设置端口映射？

如何设置端口映射？

端口映射是一种网络技术&#xff0c;通过在网络路由器或防火墙上设置规则&#xff0c;将外部网络请求转发到内部特定设备或服务的端口上。这样可以实现不同地区电脑与电脑、设备与设备、电脑与设备之间的信息远程通信&#xff0c;提供更加便捷的网络连接。 2. 天联组网 天联是…
阅读更多...
Day:005 | Python爬虫：高效数据抓取的编程技术（爬虫效率）

Day:005 | Python爬虫：高效数据抓取的编程技术（爬虫效率）

爬虫之多线程-了解 单线程爬虫的问题 因为爬虫多为IO密集型的程序&#xff0c;而IO处理速度并不是很快&#xff0c;因此速度不会太快如果IO卡顿&#xff0c;直接影响速度 解决方案 考虑使用多线程、多进程 原理&#xff1a; 爬虫使用多线程来处理网络请求&#xff0c;使用线程…
阅读更多...
废品回收 小程序+APP

废品回收 小程序+APP

用户实名认证、回收员实名认证、后台审核、会员管理、回收员管理、订单管理、提现管理、地图、档案管理。 支持&#xff0c;安卓APP、苹果APP、小程序 流程&#xff1a; 一、用户端下单&#xff0c;地图选择上门位置、填写具体位置、废品名称、预估重量、选择是企业废旧、家…
阅读更多...
MySQL - 掌握MySQL锁的必备知识

MySQL - 掌握MySQL锁的必备知识

1. 多个事务更新同一行数据时是如何加锁避免脏写? 当有多个事务同时并发更新一行数据的时候，不就是会有脏写的问题吗？那么脏写是靠什么防止的呢？ 其实就是靠锁机制，依靠锁机制让多个事务更新一行数据的时候串行化，避免同时更新一行数据。 在MySQL里，假设有一行数据摆…
阅读更多...
基于JAVA的校园失物招领平台

基于JAVA的校园失物招领平台

采用技术 基于JAVA的校园失物招领平台的设计与实现~ 开发语言&#xff1a;Java 数据库&#xff1a;MySQL 技术&#xff1a;SpringMVCMyBatis 工具&#xff1a;IDEA/Ecilpse、Navicat、Maven 页面展示效果 管理员功能 论坛管理 失物认领管理 寻物启事管理 用户管理 失物…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023