数据结构与算法3---栈与队

news2024/12/22 0:24:23

一、栈

1、顺序栈

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>  
#include <stdlib.h>   //开辟空间

#define MAXSIZE 50

//顺序栈的基本算法
typedef struct {
	int stack[MAXSIZE];
	int top;
}SqStack;

//初始化
void InitStack(SqStack* S) {
	S->top = -1;
}

//判断栈是否为空
int StackEmpty(SqStack S) {
	if (S.top == -1) {
		return 1;
	}
	return 0;
}

//进栈
void StackPush(SqStack* S,int x) {
	if (S->top == MAXSIZE - 1) {
		printf("此时栈满");
	}
	else {
		if (S->top == -1) {
			S->top += 1;
			S->stack[S->top] = x;

		}
		else {
			S->stack[++S->top] = x;
		}
		
		//printf("入栈成功");
	}
}

//出栈
int StackPop(SqStack* S) {
	if (S->top == -1) {
		printf("此时为空栈，无法继续出栈");
		return - 1;
	}
	else {
		int x = S->stack[S->top];
		S->top--;
		return x;
	}
}

//取栈顶元素
int GetStackTop(SqStack* S) {
	if (S->top == -1) {
		return -1;
	}
	int x = S->stack[S->top];
	return x;
}

void StackPrint(SqStack* S) {
	int num = S->top;
	while (num != -1) {
		printf("%d ", S->stack[num]);
		num--;
	}
}

int main() {
	SqStack* S = (SqStack*)malloc(sizeof(SqStack));
	InitStack(S);
	int a;
	scanf("%d", &a);
	while (a != 0) {
		StackPush(S, a);
		scanf("%d", &a);
	}
	StackPrint(S);
	a = StackPop(S);
	printf("%d",a);
	StackPrint(S);
	return 0;
}

2、链栈

        通过单链表实现

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>  
#include <stdlib.h>   //开辟空间

#define MAXSIZE 50

//链栈
typedef struct StackNode {
	int data;
	struct StackNode* next;
}StackNode,*LinkStack;

//初始化
void InitStack(LinkStack S) {
	S->next = NULL;
	S->data = 0;
}

//判断链栈是否为空
int EmptyStack(LinkStack S) {
	if (S->data == 0)
		return 1;
	return 0;
}

//进栈
void StackPush(LinkStack S, int x) {
	LinkStack p = (LinkStack)malloc(sizeof(StackNode));
	p->data = x;
	p->next = S->next;
	S->next = p;
	S->data++;
}

//出栈
int StackPop(LinkStack S) {
	LinkStack p = S->next;
	if (p == NULL)
		return -1;
	S->next = p->next;
	int a = p->data;
	free(p);
	S->data--;
	return a;
}

//打印
void StackPrint(LinkStack S) {
	LinkStack p = S->next;
	while (p) {
		printf("%d ", p->data);
		p = p->next;
	}
}

int main() {
	LinkStack S = (LinkStack)malloc(sizeof(StackNode));
	InitStack(S);
	StackPush(S, 1);
	StackPush(S, 2);
	StackPush(S, 3);
	StackPrint(S);
	int x = StackPop(S);
	printf("%d", x);
	StackPrint(S);
	return 0;
}

3.卡特兰数

C_{_{n}} = C_{2n}^{n} - C_{2n}^{n-1}

1. 出栈次序

一个栈(无穷大)的进栈序列为1，2，3，…，n，有多少个不同的出栈序列?


 C_{2n}^{n}下面这个2n是什么意思？

假如有4个数。那每个数有两个情况一个进栈和出栈两种状态。那就一共有8种状态

如果有n个数就有2n种状态。


C_{2n}^{n}上面那个n是什么意思？

栈进栈再出栈。假如将进栈标记为1。将出栈标记为-1。出栈和进栈是要平衡的和要为0所以代表n个数里面有几种进栈的状态4个数的话就会有4种进栈的状态。

这里我们记：进栈--- +1        出栈--- -1

有以下结论：

  1. 合法序列必定总和为0，即num(-1)=num(+1)
  2. 总和为0的序列不一定合法

有 合法 = C_{2n}^{n} - 非法

        3.“前缀”:包含首个元素往后数

        4.合法序列的特点：对于所有前缀，每一个前缀的和都>=0，且num(-1)=num(+1)

比如： n=3

不合法的：+1，-1，-1，+1，-1，+1

合法的： +1，-1，+1，+1，+1，-1，-1

对于第一个：将第一个“和小于0”的前缀取反，得到一个新序列

-1，+1，+1，+1，-1，+1此时就有4个+1，2个-1

对应n个的话就是将第一个“和小于零”的前缀取反，就得到新序列，且有n+1个+1，n-1个-1

所以A和B是一一对应的

4、表达式求值

【问题描述】栈的应用，给定一个以“#”作为结束符的算式，求出算式的结果

【输入形式】以“#”结尾的表达式，运算数为正整数。每个表达式占一行。

【输出形式】输出表达式运算的结果。

【样例输入1】4+2.53*3-10/5#

【样例输出1】9.59

【样例输入2】3*(7.91-2)#

【样例输出2】17.73

【样例输入3】2.4*3.6/2#

【样例输出3】4.32

【注意】要处理表达式中带小数的数据，不能仅采用getchar去接收数据，请注意查阅资料，看看如何处理。

另外，输出数据请保留2位小数。

#include <stdio.h>
#define TRUE 1
#define FALSE 0
#define Size 50

typedef struct {
	float elem[Size];
	int top;
}SeqStack;


void Init(SeqStack* S) {
	S->top = -1;
}

int Empty(SeqStack* S) {
	return(S->top == -1 ? TRUE : FALSE);
}

int Full(SeqStack* S) {
	return(S->top == Size - 1 ? TRUE : FALSE);
}


int Push(SeqStack* S, float x) {
	if (S->top == Size - 1) {
		return FALSE;
	}
	S->top++;
	S->elem[S->top] = x;
	return TRUE;
}

int Pop(SeqStack* S, float* x) {
	if (S->top == -1) {
		return FALSE;
	}
	else {
		*x = S->elem[S->top];
		S->top--;
		return TRUE;
	}

}

int Get(SeqStack* S, float* x) {
	if (S->top == -1) {
		return FALSE;
	}
	else {
		*x = S->elem[S->top];
		return TRUE;
	}
}

typedef struct {
	char elem[Size];
	int top;
}StrStack;


void StrInit(StrStack* s) {
	s->top = -1;
}


int StrEmpty(StrStack* s) {
	return(s->top == -1 ? TRUE : FALSE);
}

int StrFull(SeqStack* s) {
	return(s->top == Size - 1 ? TRUE : FALSE);
}


int StrPush(StrStack* s, char x) {
	if (s->top == Size - 1) {
		return FALSE;
	}
	s->top++;
	s->elem[s->top] = x;
	return TRUE;
}

int StrPop(StrStack* s, char* x) {
	if (s->top == -1) {
		return FALSE;
	}
	else {
		*x = s->elem[s->top];
		s->top--;
		return TRUE;
	}

}

int StrGet(StrStack* s, char* x) {
	if (s->top == -1) {
		return FALSE;
	}
	else {
		*x = s->elem[s->top];
		return TRUE;
	}
}

int match(char ch, char str) {
	if (ch == '(' && str == ')') {
		return TRUE;
	}
	else if (ch == '[' && str == ']') {
		return TRUE;
	}
	else if (ch == '{' && str == '}') {
		return TRUE;
	}
	else return FALSE;
}

int In(char ch) {
	if (ch == '+') {
		return TRUE;
	}
	else if (ch == '-') {
		return TRUE;
	}
	else if (ch == '*') {
		return TRUE;
	}
	else if (ch == '/') {
		return TRUE;
	}
	else if (ch == '(') {
		return TRUE;
	}
	else if (ch == ')') {
		return TRUE;
	}
	else if (ch == '#') {
		return TRUE;
	}
	else return FALSE;
}


char Comper(char x, char ch) {
	switch (x)
	{
	case'+':
		if (ch == '+' || ch == '-' || ch == ')' || ch == '#')
			return '>';
		else if (ch == '*' || ch == '/' || ch == '(')
			return '<';
		break;
	case'-':
		if (ch == '+' || ch == '-' || ch == ')' || ch == '#')
			return '>';
		else if (ch == '*' || ch == '/' || ch == '(')
			return '<';
		break;

	case'*':
		if (ch == '(') {
			return '<';
		}
		else {
			return '>';
		}
		break;
	case'/':
		if (ch == '(') {
			return '<';
		}
		else {
			return '>';
		}
		break;
	case'(':
		if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(')
			return '<';
		else if (ch == ')')
			return '=';
		else if (ch == '#')
			return '0';
		break;
	case')':
		if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == ')' || ch == '#')
			return '>';
		else if (ch == '(')
			return '0';
		break;
	case'#':
		if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(')
			return '<';
		else if (ch == '#')
			return '=';
		else if (ch == ')')
			return '0';
		break;
	default:
		return '0';
		break;
	}
}
/*
char Operator(char a, char b) {
	int i = 0, j = 0;
	char pre[7][7] = {
		{'>','>','<','<','<','>','>'},
		{'>','>','<','<','<','>','>'},
		{'>','>','>','>','<','>','>'},
		{'>','>','>','>','<','>','>'},
		{'<','<','<','<','<','=','0'},
		{'>','>','>','>','0','>','>'},
		{'<','<','<','<','<','0','='},
	};
	switch (a) {
	case'+':i = 0; break;
	case'-':i = 1; break;
	case'*':i = 2; break;
	case'/':i = 3; break;
	case'(':i = 4; break;
	case')':i = 5; break;
	case'#':i = 6; break;
	}
	switch (b) {
	case'+':j = 0; break;
	case'-':j = 1; break;
	case'*':j = 2; break;
	case'/':j = 3; break;
	case'(':j = 4; break;
	case')':j = 5; break;
	case'#':j = 6; break;
	}
	return pre[i][j];
}
*/

float Execute(float a, char op, float b) {
	switch (op) {
	case'+':
		return (a + b);
		break;
	case'-':
		return (a - b);
		break;
	case'*':
		return (a * b);
		break;
	case'/':
		if (b != 0)
			return (a / b);
		else
			return 0;
		break;
	}
}

char ch;
float Evaluation() {
	char x, y;
	char op;
	float a, b, v;

	SeqStack data;
	StrStack sign;
	Init(&data);
	StrInit(&sign);
	StrPush(&sign, '#');	//提前压一个符号进栈

	//printf("biaodashi:\n");
	ch = getchar();
	StrGet(&sign, &y);

	while (ch != '#' || y != '#') {
		if (!In(ch)) {
			int temp;
			int i = 1;
			float temp2, a[10] = { 0,0.1,0.01,0.001,0.0001,0.00001 };
			temp = ch - '0'; //转换为数字
			ch = getchar();
			while (!In(ch) && ch != '.') {
				temp = temp * 10 + ch - '0';
				ch = getchar();
			}
			temp2 = temp;
			if (ch == '.') {
				ch = getchar();
				for (i = 1; !In(ch); i++) {
					temp2 += (ch - '0') * a[i];
					ch = getchar();
				}
			}
			Push(&data, temp2);
		}
		else {
			switch (Comper(y, ch)) {
			case'<':
				StrPush(&sign, ch);
				ch = getchar();
				break;
			case'=':
				StrPop(&sign, &x);
				ch = getchar();
				break;
			case'>':
				StrPop(&sign, &op);
				Pop(&data, &b);
				Pop(&data, &a);
				v = Execute(a, op, b);
				Push(&data, v);
				break;
			}
		}
		StrGet(&sign, &y);
	}
	Get(&data, &v);
	return(v);
}

int main() {
	float result;
	result = Evaluation();
	printf("\n%.2f", result);
	return 0;
}

二、队列

1、链队列

先进先出

#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
	int data;
	struct Node* next;
}Node;

Node* initQueue() {
	Node* Q = (Node*)malloc(sizeof(Node));
	Q->data = 0;
	Q->next = NULL;
	return Q;
}

void inQueue(Node* Q, int data) {
	Node* node = (Node*)malloc(sizeof(Node));
	Node* q = Q;
	node->data = data;
	for (int i = 0; i < Q->data; i++) {
		q = q->next;
	}
	node->next = q->next;
	q->next = node;
	Q->data++;
}
int isEmpty(Node* Q) {
	if (Q->data == 0 || Q->next == NULL)
		return 1;
	return 0;
}

int delQueue(Node* Q) {
	if (isEmpty(Q))
		return -1;
	Node* node = Q->next;
	int data = node->data;
	Q->next = node->next;
	free(node);
	Q->data--;
	return data;
}


void printQueue(Node* Q) {
	Node* node = Q->next;
	while(node) {
		printf("%d ", node->data);
		node = node->next;
	}
	printf("NULL\n");
}

int main() {
	Node* Q = initQueue();
	inQueue(Q,1);
	inQueue(Q, 2);
	inQueue(Q, 3);
	inQueue(Q, 4);
	printQueue(Q);
	int x = delQueue(Q);
	printQueue(Q);
	printf("%d", x);
	return 0;
}

2、循环队列

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 5
//只能放4个数据，牺牲了一个空间去更好判断是否满队

typedef struct Queue {
	int front;
	int rear;
	int data[MAXSIZE];
}Queue;

Queue* initQueue() {
	Queue* Q = (Queue*)malloc(sizeof(Queue));
	Q->front = Q->rear = 0;
	return Q;
}

int isFull(Queue* Q) {
	if ((Q->rear + 1) % MAXSIZE == Q->front) {
		return 1;
	}
	return 0;
}

int isEmpty(Queue* Q) {
	if (Q->front == Q->rear)
		return 1;
	return 0;
}

int inQueue(Queue* Q,int data) {
	if (isFull(Q)) {
		return 0;
	}
	else {
		Q->data[Q->rear] = data;
		Q->rear = (Q->rear + 1) % MAXSIZE;
		return 1;
	}
}

int delQueue(Queue* Q) {
	if (isEmpty(Q))
		return -1;
	int data = Q->data[Q->front];
	Q->front = (Q->front + 1) % MAXSIZE;
	return data;
}

void printQueue(Queue* Q) {
	int length = (Q->rear - Q->front + MAXSIZE) % MAXSIZE;
	int index = Q->front;
	for (int i = 0; i < length; i++) {
		printf("%d->", Q->data[index]);
		index = (index + 1) % MAXSIZE;
	}
	printf("NULL\n");

}

void main() {
	Queue* Q = initQueue();
	inQueue(Q, 1);
	inQueue(Q, 2);
	inQueue(Q, 3);
	inQueue(Q, 4);
	printQueue(Q);
	delQueue(Q);
	printQueue(Q);
	return 0;
}

3、杨辉三角

#include <stdio.h>
#define MAX 100
#define FALSE 0
#define TRUE 1
//循环队列
typedef struct {
    int element[MAX];
    int front; //头指针
    int rear;  //尾指针
} SeqQueue;
//初始化循环队列
void InitQueue(SeqQueue* q) { q->front = q->rear = 0; }
//入队
int EnterQueue(SeqQueue* q, int x) {
    if ((q->rear + 1) % MAX == q->front) {
        printf("---队列已满---");
        return FALSE;
    }
    q->element[q->rear] = x;
    q->rear = (q->rear + 1) % MAX;
    return TRUE;
}
//出队
int DeleteQueue(SeqQueue* q, int* x) {
    if (q->front == q->rear) {
        printf("---队列为空---");
        return FALSE;
    }
    *x = q->element[q->front];
    q->front = (q->front + 1) % MAX;
    return TRUE;
}
//取对头元素
int GetHead(SeqQueue* q, int* x) {
    if (q->front == q->rear)
        return FALSE;
    *x = q->element[q->front];
    return TRUE;
}
//判断队列是否为空
int IsEmpty(SeqQueue* q) {
    if (q->front == q->rear)
        return TRUE;
    else
        return FALSE;
}
//打印杨辉三角
void YangHuiTriangle(int N) {
    SeqQueue q;
    InitQueue(&q);
    int n, i, x, temp;
    EnterQueue(&q, 1); //第一行元素入队
    for (n = 2; n <= N; n++) {
        EnterQueue(&q, 1); //第n行第一个元素入队
        // N为打印的行数，n为每行的元素个数
        for (i = 1; i <= n - 2; i++) { //利用队中第n-1行元素产生第n行的中间n-2个元素并入队
            DeleteQueue(&q, &temp);    //出队元素赋给temp
            printf("%d ", temp);       //打印第n-1行的元素
            GetHead(&q, &x);
            temp = temp + x;      //利用第n-1行元素产生第n行元素
            EnterQueue(&q, temp); //可以利用画图理解
        }
        DeleteQueue(&q, &x);
        printf("%d ", x); //打印n-1行最后一个元素
        EnterQueue(&q, 1);
        printf("\n");
    }
    while (!IsEmpty(&q)) { //打印最后一行
        DeleteQueue(&q, &x);
        printf("%d ", x);
    }
}
//主函数： 
int main() {
    int N;
    scanf("%d", &N);
    YangHuiTriangle(N);
    printf("\n");
    return 0;
}

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

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

相关文章

[BUUCTF从零单排] Web方向 01.Web入门篇之粗心的小李解题思路

[BUUCTF从零单排] Web方向 01.Web入门篇之粗心的小李解题思路

这是作者新开的一个专栏《BUUCTF从零单排》&#xff0c;旨在从零学习CTF知识&#xff0c;方便更多初学者了解各种类型的安全题目&#xff0c;后续分享一定程度会对不同类型的题目进行总结&#xff0c;并结合CTF书籍和真实案例实践&#xff0c;希望对您有所帮助。当然&#xff0…
阅读更多...
JEnv-for-Windows 详细使用

JEnv-for-Windows 详细使用

管理员执行jenv.bat文件 执行正常, 接下来就是按照官网的命令就行了 文件下载地址 https://download.csdn.net/download/qq_43071699/89462664 JEnv 是一个强大的Java版本管理工具&#xff0c;允许开发者在多个Java版本之间轻松切换。以下是一些常用的JEnv命令&#xff0c;这…
阅读更多...
【网络安全产品】---网闸

【网络安全产品】---网闸

了解了不少安全产品&#xff0c;但是对网闸的理解一直比较模糊&#xff0c;今天 what 网闸是安全隔离与信息交换系统的简称&#xff0c;使得在不影响数据正常通信的前提下&#xff0c;让络在不连通的情况下数据的安全交换和资源共享&#xff0c;对不同安全域/网络之间实现真正…
阅读更多...
vue项目——前端CryptoJS加密、解密

vue项目——前端CryptoJS加密、解密

1、vue项目需要安装CryptoJS安装包 npm install crypto-js 2、在项目中引入CryptoJS import CryptoJS from crypto-js 3、使用&#xff0c;代码如下 // 此处key为16进制let key jiajiajiajiajiajiajiajia;console.log(密钥&#xff1a;, key);// key格式化处理key Crypt…
阅读更多...
web中间件漏洞-weblogic漏洞-弱口令war包上传

web中间件漏洞-weblogic漏洞-弱口令war包上传

web中间件漏洞-weblogic漏洞-弱口令war包上传 弱口令war包上传 制作war包 jar cvf ma.war.(最后的.代表打包当前目录) 弱口令weblogic/weblogic123 点击部署后、一直点击下一步 访问webshell
阅读更多...
网络基础篇：网络模型

网络基础篇：网络模型

目录 一、初识网络 二、网络的分层 OSI七层模型 TCP/IP四层模型 网络与系统的关系 网络传输基本流程 数据包封装和分用 三、IP地址与MAC地址 认识IP地址 认识MAC地址 IP与MAC的关系 一、初识网络 同一台设备上的进程间通信有很多种方式 &#xff1a; 管道&#xff08…
阅读更多...
Java基础 - 练习（四）打印九九乘法表

Java基础 - 练习（四）打印九九乘法表

Java基础练习 打印九九乘法表&#xff0c;先上代码&#xff1a; public static void multiplicationTable() {for (int i 1; i < 9; i) {for (int j 1; j < i; j) {// \t 跳到下一个TAB位置System.out.print(j "" i "" i * j "\t"…
阅读更多...
【CPP】选择排序：冒泡排序、快速排序

【CPP】选择排序：冒泡排序、快速排序

目录 1.冒泡排序简介代码分析 2.快速排序2.1霍尔版本简介代码分析 2.2挖坑版本2.3前后指针版本2.4非递归的快排思路代码 什么是交换排序&#xff1f; 基本思想&#xff1a;所谓 交换&#xff0c;就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置&#xff0…
阅读更多...
Python基础教程（二十六）：对接MongoDB

Python基础教程（二十六）：对接MongoDB

&#x1f49d;&#x1f49d;&#x1f49d;首先&#xff0c;欢迎各位来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里不仅可以有所收获&#xff0c;同时也能感受到一份轻松欢乐的氛围&#xff0c;祝你生活愉快&#xff01; &#x1f49d;&#x1f49…
阅读更多...
maxKb+ollama+lama2-chinese 基于知识库+本地模型的知识问答系统

maxKb+ollama+lama2-chinese 基于知识库+本地模型的知识问答系统

maxKbollamalama2-chinese 基于知识库本地模型的知识问答系统 搭建步骤 搭建maxKb docker run -d --namemaxkb -p 8080:8080 -v ~/.maxkb:/var/lib/postgresql/data cr2.fit2cloud.com/1panel/maxkb# 用户名: admin # 密码: MaxKB123..github的访问地址&#xff1a;https://…
阅读更多...
压缩字体文件包大小pingfang等通用方法

压缩字体文件包大小pingfang等通用方法

压缩字体包大小 1、确保已经安装python 借助python环境&#xff0c;安装fonttools插件&#xff1a; 如果运行pip失败&#xff0c;注意看一下自己的环境变量是否错误&#xff1a; 在用户环境变量中与python安装目录下scripts相对应 pip install fonttools2、如果显示下载超…
阅读更多...
家用电器信息管理系统

家用电器信息管理系统

摘 要 随着互联网的快速发展&#xff0c;传统家电行业受到冲击&#xff0c;逐渐向智能家居市场转型。因此&#xff0c;智能家居无疑是一个有着巨大市场需求和新兴发展空间的新兴产业&#xff0c;也是人们追求安全、便捷、舒适的生活方式的必然趋势。互联网推动了我国传统家居产…
阅读更多...
TCP编程

TCP编程

自学python如何成为大佬(目录):https://blog.csdn.net/weixin_67859959/article/details/139049996?spm1001.2014.3001.5501 由于TCP连接具有安全可靠的特性&#xff0c;所以TCP应用更为广泛。创建TCP连接时&#xff0c;主动发起连接的叫客户端&#xff0c;被动响应连接的叫服…
阅读更多...
华为设备SSH远程访问配置实验简述

华为设备SSH远程访问配置实验简述

一、实验需求: 1、AR1模拟电脑SSH 访问AR2路由器。 二、实验步骤&#xff1a; 1、AR1和AR2接口配置IP&#xff0c;实现链路通信。 2、AR2配置AAA模式 配置用户及密码 配置用户访问级别 配置用户SSH 访问服务 AR2配置远程服务数量 配置用户远程访问模式为AAA 配置允许登录接入用…
阅读更多...
东芝-Soft Limit 报警及其解决办法

东芝-Soft Limit 报警及其解决办法

灵感来源与生活，在生活中总能有意想不到的惊喜，下面来看看小编今天的惊喜！！！ 今天不知道怎么了，有人来找就说是机器人坏了，一直报警，重启关机回原点也没有用。 意外到来，只能使用手柄将控制器打手动，来看看报警显示什么。 下面就看到了这，我靠第一次看见，只能看看手…
阅读更多...
【决战欧洲之巅】苏格兰VS瑞士-AI预测走地数据

【决战欧洲之巅】苏格兰VS瑞士-AI预测走地数据

初步分析 苏格兰队是欧洲杯的老牌球队&#xff0c;虽然首场比赛表现不佳&#xff0c;但他们的实力不容小觑。苏格兰在预选赛中表现出色&#xff0c;以小组第二的身份晋级&#xff0c;并拥有包括多名英超球员在内的强大阵容&#xff0c;如曼联中场麦克托米奈和利物浦右后卫罗伯…
阅读更多...
【Android面试八股文】你刚刚提到了V2签名使用美团的Walle实现多渠道打包，那么你能讲一讲Android 签名的 v1、v2、v3、v4版本的区别吗？

【Android面试八股文】你刚刚提到了V2签名使用美团的Walle实现多渠道打包，那么你能讲一讲Android 签名的 v1、v2、v3、v4版本的区别吗？

文章目录 前言一、简介二、APK 签名方案 v1 (JAR签名)2.1. 签名过程2.2 验证过程2.3 详细例子2.4 优缺点2.5 美团基于V1版本的多渠道打包方案三、APK 签名方案 v23.1 为什么要设计APK 签名方案 v2 ？3.2 APK 签名方案 v2 ： 签名前和签名后的 APK3.2.1 签名前和签名后的 APK3.2…
阅读更多...
后端不提供文件流接口，前台js使用a标签实现当前表格数据(数组非blob数据)下载成Excel

后端不提供文件流接口，前台js使用a标签实现当前表格数据(数组非blob数据)下载成Excel

前言&#xff1a;开发过程中遇到的一些业务场景&#xff0c;如果第三方不让使用&#xff0c;后端不提供接口&#xff0c;就只能拿到table数据(Array)&#xff0c;实现excel文件下载。 废话不多说&#xff0c;直接上代码&#xff0c;方法后续自行封装即可&#xff1a; functio…
阅读更多...
7亿中国男人，今年夏天都在穿什么？

7亿中国男人，今年夏天都在穿什么？

文丨郭梦仪 北京气温已经逼近38度&#xff0c;注重防晒的人群中这次多了男人的身影。 程序员宇宙中心&#xff0c;清河万象汇西区&#xff0c;小米su7吸引众多男士前来观摩&#xff0c;和对面蕉下门店里的“防晒衣大军”恰好呼应上了。 北京清河万象汇的防晒衣专卖店 夏日将…
阅读更多...
C++ 计算凸包点的最小旋转矩形

C++ 计算凸包点的最小旋转矩形

RotateRect.h #include <vector>/** * brief 计算点集最小旋转外接矩形 */ class RotateRect { public:enum { CALIPERS_MAXHEIGHT 0, CALIPERS_MINAREARECT 1, CALIPERS_MAXDIST 2 };struct Point {float x, y;};using Points std::vector<Point>;struct Size…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023