【头歌】链栈的基本操作及应用

news2024/12/26 11:27:42

第1关：链栈的基本操作

任务描述

本关任务是实现链栈的基本操作函数，以实现判断栈是否为空、求栈的长度、进栈、出栈以及获取栈顶元素等功能。

相关知识

链式存储的栈

栈的链式存储结构是采用某种链表结构，栈的链式存储结构简称为链栈。 这里采用单链表作为链栈，该单链表是不带头结点的。

可以用不带头结点的单链表存储链栈，设计初始化栈、判断栈是否为空、进栈和出栈等相应算法。

不带头结点的单链表，在进行插入、删除、查值等操作运算时需要对表首进行特殊处理。

不带头结点的单链表基本操作

链栈就是不带头结点的单链表，不带头结点的单链表的基本操作如下：

struct  LNode
{
   ElemType data;
   LNode *next;
};
typedef  LNode * LinkList;    // 另一种定义LinkList的方法
// 不带头结点的单链表的部分基本操作(9个)
void InitList(LinkList &L)
{ // 操作结果：构造一个空的线性表L
   L=NULL; // 指针为空
 }
#define DestroyList ClearList // DestroyList()和ClearList()的操作是一样的
void ClearList(LinkList &L)
{ // 初始条件：线性表L已存在。操作结果：将L重置为空表
   LinkList p;
   while(L) // L不空
   {
     p=L; // p指向首元结点
     L=L->next; // L指向第2个结点(新首元结点)
     free(p); // 释放首元结点
   }
}
int ListEmpty(LinkList L)
{ // 初始条件：单链表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
   if(L)
     return FALSE;
   else
     return TRUE;
}
int ListLength(LinkList L)
{ // 初始条件：线性表L已存在。操作结果：返回L中数据元素个数
   int i=0;
   LinkList p=L;
   while(p) // p指向结点(没到表尾)
   {
     p=p->next; // p指向下一个结点
     i++;
   }
   return i;
}
int GetElem(LinkList L,int i,ElemType &e)
{ // L为不带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
   int j=1;
   LinkList p=L;
   if(i<1) // i值不合法
     return ERROR;
   while(j<i&&p) // 没到第i个元素，也没到表尾
   {
     j++;
     p=p->next;
   }
   if(j==i) // 存在第i个元素
   {
     e=p->data;
     return OK;
   }
   else
     return ERROR;
}
int LocateElem(LinkList L,ElemType e,int(*compare)(ElemType,ElemType))
{ // 初始条件：线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0)
   // 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
   //           若这样的数据元素不存在，则返回值为0
   int i=0;
   LinkList p=L;
   while(p)
   {
     i++;
     if(compare(p->data,e)) // 找到这样的数据元素
       return i;
     p=p->next;
   }
   return 0;
}
int ListInsert(LinkList &L,int i,ElemType e)
{ // 在不带头结点的单链线性表L中第i个位置之前插入元素e
   int j=1;
   LinkList p=L,s;
   if(i<1)                // i值不合法
     return ERROR;
   s=(LinkList)malloc(sizeof(LNode)); // 生成新结点
   s->data=e; // 给s的data域赋值
   if(i==1) // 插在表头
   {
     s->next=L;
     L=s; // 改变L
   }
   else
   { // 插在表的其余处
     while(p&&j<i-1) // 寻找第i-1个结点
     {
       p=p->next;
       j++;
     }
     if(!p) // i大于表长+1
       return ERROR;
     s->next=p->next;
     p->next=s;
   }
   return OK;
}
int ListDelete(LinkList &L,int i,ElemType &e)
 { // 在不带头结点的单链线性表L中，删除第i个元素，并由e返回其值
   int j=1;
   LinkList p=L,q;
   if(i==1)    // 删除第1个结点
   {
     L=p->next; // L由第2个结点开始
     e=p->data;
     free(p);  // 删除并释放第1个结点
   }
   else
   {
     while(p->next&&j<i-1) // 寻找第i个结点，并令p指向其前趋
     {
       p=p->next;
       j++;
     }
     if(!p->next||j>i-1) // 删除位置不合理
       return ERROR;
     q=p->next;         // 删除并释放结点
     p->next=q->next;
     e=q->data;
     free(q);
   }
   return OK;
}
 void ListTraverse(LinkList L,void(*vi)(ElemType))
 { // 初始条件：线性表L已存在。操作结果：依次对L的每个数据元素调用函数vi()
   LinkList p=L;
   while(p)
   {
     vi(p->data);
     p=p->next;
   }
   printf("\n");
 }
链栈的基本操作

针对链栈我们定义如下操作：

typedef  SElemType  ElemType;   // 栈结点类型和链表结点类型一致
typedef  LinkList LinkStack;     // LinkStack是指向栈结点的指针类型
#define  InitStack  InitList     // InitStack()与InitList()作用相同，下同
#define DestroyStack  DestroyList
#define ClearStack  ClearList
#define StackEmpty  ListEmpty
#define StackLength ListLength

编程要求

根据提示，在右侧编辑器 Begin-End 区间补充代码，实现4个链栈的基本操作函数，具体要求如下：

  • int GetTop(LinkStack S,SElemType &e); // 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR

  • int Push(LinkStack &S,SElemType e); // 插入元素e为新的栈顶元素

  • int Pop(LinkStack &S,SElemType &e)// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR

  • void StackTraverse(LinkStack S,void(*visit)(SElemType)); // 从栈底到栈顶依次对栈中每个元素调用函数visit()

测试说明

平台会对你编写的代码进行测试：

测试输入： 12 47 5 8 6 92 45 63 75 38 4 29

预期输出： 栈中元素依次为：12 47 5 8 6 92 45 63 75 38 4 29 弹出的栈顶元素 e=29 栈空否：0(1:空 0:否) 栈顶元素 e=4 栈的长度为11 清空栈后，栈空否：1(1:空 0:否)

输入说明 第一行输入顺序栈的数据元素的个数n； 第二行输入顺序栈的n个整数。
输出说明 第一行输出顺序栈的所有数据元素； 第二行输出出栈的数据元素； 第三行判断栈是否为空； 第四行输出当前的栈顶元素及栈的长度； 第五行销毁栈后，判断栈是否为空；

开始你的任务吧，祝你成功！

代码示例

#include <stdio.h>
#include<stdlib.h>
#include <iostream>
using namespace std;

 // 函数结果状态代码
 #define TRUE 1
 #define FALSE 0
 #define OK 1
 #define ERROR 0
typedef  int  SElemType;
void input(SElemType &s);
void output(SElemType s);

typedef  SElemType  ElemType;   // 栈结点类型和链表结点类型一致

struct  LNode
 {
   ElemType data;
   LNode *next;
 };
 typedef  LNode * LinkList; // 另一种定义LinkList的方法

// 不带头结点的单链表的部分基本操作(9个)
 #define DestroyList ClearList // DestroyList()和ClearList()的操作是一样的
 void InitList(LinkList &L); 
 void ClearList(LinkList &L);
 int ListEmpty(LinkList L);
 int ListLength(LinkList L);
 int GetElem(LinkList L,int i,ElemType &e);
 int LocateElem(LinkList L,ElemType e,int(*compare)(ElemType,ElemType));
 int ListInsert(LinkList &L,int i,ElemType e);
 int ListDelete(LinkList &L,int i,ElemType &e);
 void ListTraverse(LinkList L,void(*vi)(ElemType));

 /*****链栈的基本操作*****/
typedef  LinkList LinkStack;     // LinkStack是指向栈结点的指针类型
#define  InitStack  InitList     // InitStack()与InitList()作用相同，下同
#define DestroyStack  DestroyList
#define ClearStack  ClearList
#define StackEmpty  ListEmpty
#define StackLength ListLength

int GetTop(LinkStack S,SElemType &e); // 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
int Push(LinkStack &S,SElemType e);  // 插入元素e为新的栈顶元素
int Pop(LinkStack &S,SElemType &e); // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
void StackTraverse(LinkStack S,void(*visit)(SElemType)); // 从栈底到栈顶依次对栈中每个元素调用函数visit()


int main()
 {
   int j,n;
   LinkStack s;
   SElemType e;
   InitStack(s);
   cin>>n;
   for(j=1;j<=n;j++)
   {
	   input(e);
	   Push(s,e);
   }
   printf("栈中元素依次为：");
   StackTraverse(s,output);
   Pop(s,e);
   printf("弹出的栈顶元素 e=%d\n",e);
   printf("栈空否：%d(1:空 0:否)\n",StackEmpty(s));
   GetTop(s,e);
   printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));
   ClearStack(s);
   printf("清空栈后，栈空否：%d(1:空 0:否)\n",StackEmpty(s));
   DestroyStack(s);  
 }
 
/*****SElemType类型元素的基本操作*****/
void input(SElemType &s)
{
	cin>>s;
}
void output(SElemType s)
{
	cout<<s<<" ";
}

// 不带头结点的单链表的部分基本操作(9个)
#define DestroyList ClearList    // DestroyList()和ClearList()的操作是一样的
void InitList(LinkList &L)
{ // 操作结果：构造一个空的线性表L
   L=NULL; // 指针为空
}

void ClearList(LinkList &L)
{ // 初始条件：线性表L已存在。操作结果：将L重置为空表
   LinkList p;
   while(L) // L不空
   {
     p=L; // p指向首元结点
     L=L->next; // L指向第2个结点(新首元结点)
     free(p); // 释放首元结点
   }
}

int ListEmpty(LinkList L)
{ // 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
   if(L)
     return FALSE;
   else
     return TRUE;
}

int ListLength(LinkList L)
{ // 初始条件：线性表L已存在。操作结果：返回L中数据元素个数
   int i=0;
   LinkList p=L;
   while(p) // p指向结点(没到表尾)
   {
     p=p->next; // p指向下一个结点
     i++;
   }
   return i;
}

int GetElem(LinkList L,int i,ElemType &e)
{ // L为不带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
   int j=1;
   LinkList p=L;
   if(i<1) // i值不合法
     return ERROR;
   while(j<i&&p) // 没到第i个元素，也没到表尾
   {
     j++;
     p=p->next;
   }
   if(j==i) // 存在第i个元素
   {
     e=p->data;
     return OK;
   }
   else
     return ERROR;
}

int LocateElem(LinkList L,ElemType e,int(*compare)(ElemType,ElemType))
{ // 初始条件：线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0)
   // 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
   //           若这样的数据元素不存在，则返回值为0
   int i=0;
   LinkList p=L;
   while(p)
   {
     i++;
     if(compare(p->data,e)) // 找到这样的数据元素
       return i;
     p=p->next;
   }
   return 0;
}

int ListInsert(LinkList &L,int i,ElemType e)
{ // 在不带头结点的单链线性表L中第i个位置之前插入元素e
   int j=1;
   LinkList p=L,s;
   if(i<1) // i值不合法
     return ERROR;
   s=(LinkList)malloc(sizeof(LNode)); // 生成新结点
   s->data=e; // 给s的data域赋值
   if(i==1) // 插在表头
   {
     s->next=L;
     L=s; // 改变L
   }
   else
   { // 插在表的其余处
     while(p&&j<i-1) // 寻找第i-1个结点
     {
       p=p->next;
       j++;
     }
     if(!p) // i大于表长+1
       return ERROR;
     s->next=p->next;
     p->next=s;
   }
   return OK;
}

int ListDelete(LinkList &L,int i,ElemType &e)
{ // 在不带头结点的单链线性表L中，删除第i个元素，并由e返回其值
   int j=1;
   LinkList p=L,q;
   if(i==1) // 删除第1个结点
   {
     L=p->next; // L由第2个结点开始
     e=p->data;
     free(p); // 删除并释放第1个结点
   }
   else
   {
     while(p->next&&j<i-1) // 寻找第i个结点，并令p指向其前趋
     {
       p=p->next;
       j++;
     }
     if(!p->next||j>i-1) // 删除位置不合理
       return ERROR;
     q=p->next; // 删除并释放结点
     p->next=q->next;
     e=q->data;
     free(q);
   }
   return OK;
}
 
void ListTraverse(LinkList L,void(*vi)(ElemType))
{ // 初始条件：线性表L已存在。操作结果：依次对L的每个数据元素调用函数vi()
   LinkList p=L;
   while(p)
   {
     vi(p->data);
     p=p->next;
   }
   printf("\n");
}


int GetTop(LinkStack S,SElemType &e)
 { // 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
    /********** Begin **********/ 
    if (S)
    {
      e = S->data;
      return OK;
    }
    return ERROR;
    /********** End **********/	
}

int Push(LinkStack &S,SElemType e)
{ // 插入元素e为新的栈顶元素
    /********** Begin **********/ 
  LinkStack p;
	p = new LNode; //生成新的结点p 
	p->data = e;
	p->next = S; //新结点插入栈顶 
	S = p;  // 修改栈顶指针 
	return OK;
    /********** End **********/	
 }

int Pop(LinkStack &S,SElemType &e)
{ // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
    /********** Begin **********/ 
    LinkStack del;
    if (S == NULL) return ERROR;
    e = S->data;
    del = S;   //del接收一下要删除的栈顶指针 
    S = S->next;
    delete del;
    return OK;
    /********** End **********/	
 }

void StackTraverse(LinkStack S,void(*visit)(SElemType))
{ // 从栈底到栈顶依次对栈中每个元素调用函数visit()
    /********** Begin **********/ 
   	LinkStack P;
   	InitStack(P); 
   	LinkStack p = S;
   	while (p)
   	{
   		Push(P, p->data);
   		p = p->next;
	}
	ListTraverse(P, visit); 
	/********** End **********/	
}

第2关：链栈的应用——括号匹配

任务描述

本关任务：设计一个算法，判断一个可能含有花括号、中括号、和圆括号的表达式中各类括号是否匹配，若匹配，则返回1；否则返回0。其中表达式只包含三种括号，花括号{}、中括号[]、圆括号()，即它仅由 (、)、[、]、{、}六个字符组成。

相关知识

从左至右扫描一个表达式(或字符串)，则每个右括号将与最近遇到的那个左括号相匹配。

在从左至右扫描表达式过程中把所遇到的左括号存放到栈中。

每当遇到一个右括号时，就将它与栈顶的左括号(如果存在)相匹配，同时从栈顶删除该左括号。

算法思想：

设置一个栈，当读到左括号时，左括号进栈。当读到右括号时，则从栈中弹出一个元素，与读到的左括号进行匹配，若匹配成功，继续读入；否则匹配失败。另外，在算法的开始和结束时，栈都应该是空的，所以匹配到最后还要判断栈是否为空，若空，则说明匹配成功，返回1。若非空，则说明匹配失败，返回0。

步骤如下：

  • 设置一个链栈st，定义一个整型flag变量（初始为1）。

  • 用i扫描表达式exp，当i<n并且flag=1时循环：

  • 当遇到左括号“(”、“[”、“{”时，将其进栈；

  • 遇到“}”、“]”、“)”时，出栈字符ch，若出栈失败（下溢出）或者ch不匹配，则置flag=0退出循环;

  • 否则直到exp扫描完毕为止。

  • 若栈空并且flag为1则返回1，否则返回0。

编程要求

根据提示，在右侧编辑器 Begin - End 之间补充代码，判断表达式（或字符串）中括号是否成对出现。

测试说明

平台会对你编写的代码进行测试，只有所有数据全部计算正确才能通过测试：

测试输入：{ [ ] ( ) } 预期输出：{ [ ] ( ) }是匹配的表达式

测试输入：[ ( { } ] [ ) ] 预期输出：[ ( { } ] [ ) ]不是匹配的表达式

开始你的任务吧，祝你成功！

代码示例

#include<stdio.h>
#include<string.h>
#include "slink.h"	//包含前面的链栈基本运算函数


int Match(char exp[],int n)	//exp存放表达式，n是表达式长度
{ 
   LinkStack st;			//定义一个链栈st
   InitStack(st);		//栈初始化
   int flag=1,i=0,a=0,b=0;
   char ch;
   /********** Begin **********/ 
   
    for(int i =0 ;i<n;i++)
    {
		if(exp[i]=='('||exp[i]=='{'||exp[i]=='[')
        {
			Push(st,exp[i]);
			a++;
		}
        else
        {
			b++;
			GetTop(st,ch);
			if((ch =='('&&exp[i]==')')||(ch == '{'&&exp[i]=='}')||(ch=='['&&exp[i]==']'))
			Pop(st,ch);
		}
	}
	if(ListEmpty(st)&&a==b)
    {
		return 1;
	}
    else
		return 0;
	

 

   /********** End **********/
}

void display(char exp[])
{
	int n=strlen(exp);
	if (Match(exp,n))
		printf("%s是匹配的表达式\n",exp);
	else
		printf("%s不是匹配的表达式\n",exp);
}

int main()
{
	char str[80];
	scanf("%s",str);
	display(str);
	return 0;
}

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

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

相关文章

oracle11g SAP测试机归档日志暴增排查（一）

oracle11g SAP测试机归档日志暴增排查（一）

现象是oracle11g空间一天很快就被归档日志增加的文件爆满了&#xff0c;空间没有&#xff0c;oracle也不正常&#xff0c;当然sap也出现异常了。 看空间是就是/oracle没有空间了&#xff0c;用du * -sh 很快找到oraarch下面日志文件几分钟内产生大量的归档日志文件。 1、因为是…
阅读更多...
面试京东软件测试岗，收到offer后我却毫不犹豫拒绝了....

面试京东软件测试岗，收到offer后我却毫不犹豫拒绝了....

我大学学的是计算机专业&#xff0c;毕业的时候&#xff0c;对于找工作比较迷茫&#xff0c;也不知道当时怎么想的&#xff0c;一头就扎进了一家外包公司&#xff0c;一干就是2年。我想说的是&#xff0c;但凡有点机会&#xff0c;千万别去外包&#xff01; 在深思熟虑过后&am…
阅读更多...
隐式Makefile详解

隐式Makefile详解

工程： Makefile： 第1行：指定Makefile所在的当前路径赋值给宏定义ROOTDIR; 第2行：指定Makefile所在的当前路径下的lib文件夹路径赋值给LIB_DIR; 第3行：指定Makefile所在的当前路径下的include文件夹路径赋值给INCLUDE_DIR; 第4行：指定Makefile所在的当前路径下的bin文件…
阅读更多...
花40天啃完这份微服务架构笔记，终于挺进腾讯T3,它太重要了

花40天啃完这份微服务架构笔记，终于挺进腾讯T3,它太重要了

都2023年了 还没用过微服务吗&#xff1f; 面试的时候高并发回答的总是不能让面试官满意&#xff1f; 一个互联网项目究竟有多少细节&#xff1f; 网上搜了一堆秒杀系统方案&#xff0c;究竟真实的线上电商该怎么做&#xff1f; 你缺乏这两个字 实战 消除痛点 解决面试 …
阅读更多...
debian开启root登录

debian开启root登录

Debian桌面系统，默认不允许root用户登录，需要通过修改相应的配置文件“/etc/pam.d/gdm3”和“/etc/gdm3/deamon.conf”，才能使root用户登录 1.debian开启root登录 1.1修改配置文件 1.使用我们安装debian系统时创建的普通用户登录到系统的桌面 2.点击activities搜索termi…
阅读更多...
关于TCP的四次挥手介绍

关于TCP的四次挥手介绍

一、什么是TCP的四次挥手在网络数据传输中&#xff0c;传输层协议断开连接的过程我们称为四次挥手二、四次挥手的具体细节1. 第一次挥手&#xff1a;Client将FIN置为1&#xff0c;发送一个序列号seq给Server&#xff1b;进入FIN_WAIT_1状态&#xff1b;2. 第二次挥手&#xff1…
阅读更多...
Ceres安装与卸载以及新旧版本中的问题

Ceres安装与卸载以及新旧版本中的问题

Ceres在SLAM优化中常常会用到&#xff0c;简单记录一下关于Ceres的一些问题 1、Ceres安装 1.1、安装依赖项 sudo apt-get install liblapack-dev libsuitesparse-dev libcxsparse3 libgflags-dev libgoogle-glog-dev libgtest-dev1.2、下载Ceres Ceres的下载地址为&#x…
阅读更多...
苏嵌实训——day17

苏嵌实训——day17

文章目录1.1 信号灯集函数接口1.semget2.semctl3.封装初始化函数4. semop二 网络编程2.1 为什么要学习网络编程2.2 发展2.2.1 ARPnet2.2.2 TCP/IP协议2.3 网络体系结构以及OSI开放系统互联模型2.4 TCP/IP协议族2.5 五层模型2.6 TCP和UDP的异同点2.7 函数讲解2.7.1 socket2.7.2 …
阅读更多...
k8s快速入门、集群部署-62

k8s快速入门、集群部署-62

一&#xff1a;k8s简介 Kubernetes 简称 k8s。是用于自动部署&#xff0c;扩展和管理容器化应用程序的开源系统。 1.1 官方文档 中文官网&#xff1a;https://kubernetes.io/zh/ 中文社区&#xff1a;https://www.kubernetes.org.cn/ 官方文档&#xff1a;https://kubernete…
阅读更多...
利用钉钉机器人Webhook向钉钉群推送告警通知

利用钉钉机器人Webhook向钉钉群推送告警通知

一、配置钉钉群 1、新建一个接收通知的钉钉群 如下图&#xff0c;创建一个接收通知的钉钉群 选择项目群&#xff0c;点创建 输入群名称&#xff0c;右侧选择群成员&#xff0c;最后点击右下角的创建 2、对群进行设置 点群右上角的设置按钮 点击 “智能群助手” 点 “添加机器人…
阅读更多...
常见测试案例汇总

常见测试案例汇总

作者&#xff1a;~小明学编程 文章专栏&#xff1a;测试开发 格言&#xff1a;热爱编程的&#xff0c;终将被编程所厚爱。 目录 水杯的测试用例 功能性测试 界面测试 性能测试 兼容性测试 易用性测试 安全测试 电梯的测试用例 界面测试 功能测试 性能测试 兼容性…
阅读更多...
明明加了唯一索引，为什么还是产生重复数据？

明明加了唯一索引，为什么还是产生重复数据？

距离上次发稿 已经过去好久了&#xff0c; 开搞&#xff0c;2023第一稿&#xff1b; .还原问题现场 前段时间&#xff0c;为了防止商品组产生重复的数据&#xff0c;我专门加了一张防重表。 问题就出在商品组的防重表上。 具体表结构如下&#xff1a; 为了保证数据的唯一性&a…
阅读更多...
《吴军数学通识讲义》读后感

《吴军数学通识讲义》读后感

先抛一个问题&#xff0c;一副扑克牌随机发牌&#xff0c;均匀发给三人&#xff0c;已知你手上有两张K&#xff0c;另外两张K&#xff0c;每人一张的概率大&#xff0c;还是分给一个人的概率大&#xff0c;或者这两种场景概率一样&#xff1f; 从小开始学数学&#xff0c;但毕业…
阅读更多...
PostgreSQL实战之物理复制和逻辑复制（六）

PostgreSQL实战之物理复制和逻辑复制（六）

目录 PostgreSQL实战之物理复制和逻辑复制&#xff08;六&#xff09; 6 延迟备库 6.1 延迟备库的意义 6.2 延迟备库部署 6.3 recovery_min_apply_delay参数对同步复制的影响 PostgreSQL实战之物理复制和逻辑复制&#xff08;六&#xff09; 6 延迟备库 延迟备库是指可以配…
阅读更多...
Flink官方例子解析：Flink源码子项目flink-examples

Flink官方例子解析：Flink源码子项目flink-examples

1. 简介 很多朋友在学习Flink的时候都希望能有个demo代码来参考实践&#xff0c;于是在百度或者Google一顿搜索&#xff0c;虽然能找到很多demo代码&#xff0c;但是这些demo要么版本比较旧&#xff0c;要么代码不全&#xff0c;根本跑不通。 其实&#xff0c;Flink官网就提供…
阅读更多...
10、矩阵分析

10、矩阵分析

目录 一、向量和矩阵的范数运算 二、矩阵的秩 三、矩阵的行列式 四、矩阵的迹 五、矩阵的化零矩阵 六、矩阵的正交空间 七、矩阵的约化行阶梯形式 八、矩阵空间之间的夹角 MATLAB 提供的矩阵分析函数&#xff1a; 一、向量和矩阵的范数运算 (1)在MATLAB中&#xff0c;…
阅读更多...
不平衡数据集的建模的技巧和策略

不平衡数据集的建模的技巧和策略

不平衡数据集是指一个类中的示例数量与另一类中的示例数量显著不同的情况。 例如在一个二元分类问题中&#xff0c;一个类只占总样本的一小部分&#xff0c;这被称为不平衡数据集。类不平衡会在构建机器学习模型时导致很多问题。 不平衡数据集的主要问题之一是模型可能会偏向多…
阅读更多...
笔记本怎么录制屏幕？笔记本录屏有这一款就够了

笔记本怎么录制屏幕？笔记本录屏有这一款就够了

为了携带方便&#xff0c;很多小伙伴都选择笔记本电脑作为自己学习和办公的工具。在使用笔记本时&#xff0c;我们有时需要对它进行屏幕录制&#xff0c;那你知道笔记本怎么录制屏幕吗&#xff1f;怎样才能又快又好地录制屏幕&#xff1f;今天小编就给大家带来一款能高效录制笔…
阅读更多...
DBCO-SS-NH2,二苯并环辛炔-二硫键-氨基，DBCO-SS-amine

DBCO-SS-NH2,二苯并环辛炔-二硫键-氨基，DBCO-SS-amine

DBCO-SS-NH2,二苯并环辛炔-二硫键-氨基&#xff0c;DBCO-SS-amine 英文名称&#xff1a;DBCO-SS-NH2、DBCO-SS-amine 中文名称&#xff1a;二苯并环辛炔-二硫键-氨基 外 观: 浅黄色或白色固体 分子式: C23H25N3O2S2 分子量: 439.59 存储环境:尽可能储存在-20℃环境下&…
阅读更多...
网络原理(TCP/IP)(5)

网络原理(TCP/IP)(5)

2.IP协议的核心功能:能够在两点之间规划出来一条合适的路径 1)地址管理&#xff1a;通过一系列的规则&#xff0c;可以把网络上设备的地址给描述出来 2)路由地址&#xff1a;根据当下的源IP和目的地址&#xff0c;规划成一条合适的路径&#xff0c;啥叫合适&#xff1f;关键是看…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023