C语言之用链表的方式解析和运算嵌套的波兰表达式

news2025/11/1 2:42:20

C语言之用链表的方式解析和运算嵌套的波兰表达式

嵌套的波兰表达式，形如：(+ 1 （+ 2 （+ 3 （+ 4 5 ）））) ，用数组模拟栈，来实现这个功能。

将上一篇文章的代码拿过来，进一步改进！

  • C语言之用链表的方式解析与运算简单的波兰表达式

定义一个新的数据类型，嵌套的子表达式subexpr

#define DT_SUBEXPR  0X03

在表达式结构中的共用体中加入一个新的类型ExprNode *bval

  • 让 DT_SUBEXPR 对应 ExprNode *bval
  ...
  union {
        char  oval; //operator
        long  ival; //integer
    ExprNode *bval; //subexpr
  } V;
  ...

定义创建新的子表达式节点的函数，代码如下：

/* create a new sub express node */
ExprNode *
expr_node_new_sub (ExprNode *val)
{
  ExprNode *node = (ExprNode*) malloc (sizeof(ExprNode));
  node->expr.dt = DT_SUBEXPR;
  node->expr.V.bval = val;
  node->next = NULL;
  return node;
}

释放链表时同时也要释放这种类型的节点，expr_node_free代码改造如下：

/* free the express node list */
void
expr_node_free (ExprNode *node)
{
  while (node != NULL)
    {
      ExprNode *tmp = node->next;
      if (node->expr.dt == DT_SUBEXPR)
	    expr_node_free (node->expr.V.bval);
      free (node);
      node = tmp;
    }
}

out函数前定义一个用于缩进显示的表达式级别变量exprlv，out函数代码如下：

/* define output express info level */
static int exprlv = 0;

/* output express info */
void
out_expr_info (Expr expr)
{
  for (int i = 0; i < exprlv; i++) printf ("   ");
  switch (expr.dt)
    {
    case DT_OPERATOR: printf (" OP: %c\n",  expr.V.oval); break;
    case DT_INTEGER : printf ("INT: %ld\n", expr.V.ival); break;
    case DT_SUBEXPR : printf ("SUB:\n");
      exprlv++; out_expinfo (expr.V.bval); exprlv--; break;
    }
}

out函数代码如下：

/* output express value */
void
out_expr_value (Expr expr)
{
  switch (expr.dt)
    {
    case DT_OPERATOR: printf (" %c",  expr.V.oval); break;
    case DT_INTEGER : printf (" %ld", expr.V.ival); break;
    case DT_SUBEXPR : out_express (expr.V.bval); break;
    }
}

在原来的parse_expr_string函数基础上，重新写一个parse_expr_string函数

  • STSIZE，指定栈的深度，也就是表达式嵌套的深度！！！
/* define number length */
#define NBSIZE 32

/* define stack height */
#define STSIZE 32

/* parse express string to express node */
ExprNode *
parse_expr_string (char *estr)
{
  ExprNode *root = NULL;
  ExprNode *st[STSIZE] = {0};
  char nbuf[NBSIZE] = {0};
  int idx = 0, ndx = 1, lv = 0;
  char c;

  nbuf[0] = '+'; //default +
  c = estr[idx];
  while (c != 0)
    {
      switch (c)
	{
	case '0'...'9': //number
	  {
	    char n = estr[idx+1];
	    nbuf[ndx] = c; ndx++;
	    if (n == ' ' || n == ')')
	      {
		long lt = strtol (nbuf, NULL, 10);
		ExprNode *tmp = expr_node_new_int (lt);
		st[lv-1] = expr_node_append (st[lv-1], tmp);
		memset (nbuf, 0, NBSIZE); nbuf[0] = '+'; ndx = 1;
	      }
	  }
	  break;

	case '+': case '-': case '*': case '/': //operator
	  {
	    if (c == '+' || c == '-')
	      {
		char n = estr[idx+1];
		if (n >= '0' && n <= '9')
		  {
		    nbuf[0] = c; break;
		  }
	      }
	    ExprNode *tmp = expr_node_new_op (c);
	    st[lv-1] = expr_node_append (st[lv-1], tmp);
	  }
	  break;

	case '(':
	  {
	    lv++; //todo
	    if (lv > STSIZE) printf ("Error: Syntax error, Stack overflow!\n");
	  }
	  break;

	case ')':
	  {
	    lv--;
	    if (lv == 0)
	      {
		root = st[lv];
		return root; //todo
	      }
	    else if (lv > 0)
	      {
		ExprNode *sub = expr_node_new_sub (st[lv]);
		st[lv-1] = expr_node_append (st[lv-1], sub);
		st[lv] = NULL;
	      }
	    else
	      { printf ("Error: Syntax error! Stack overflow!\n"); } //todo
	  }
	  break;

	case ' ': //space
	  break;

	defualt:
	  printf ("Syntax error!\n");
	}

      idx++; c = estr[idx];
    }

  return root;
}

交互输入表达式、运算、输出结果函数eval_express，代码如下：

/* interactive evalute express */
void
eval_express (void)
{
  ExprNode *elist = NULL;
  char buf[1024] = {0};
  int idx = 0;
  char c;

  printf ("REPL:> ");
  c = fgetc (stdin);
  while (c != EOF)
    {
      if (c == '\n')
	{
	  elist = parse_expr_string (buf);
	  printf ("-------------------------\n");
	  out_expinfo (elist);
	  printf ("-------------------------\n");
	  printf ("full expr:");
	  out_express (elist);
	  printf ("\n-------------------------\n");
	  printf ("Result : %ld\n", expr_node_compute (elist));
	  memset (buf, 0, 1024);
	  expr_node_free (elist); elist = NULL;
	  printf ("REPL:> ");
	  idx = 0; c = fgetc (stdin);
	}
      else
	{
	  buf[idx] = c;
	  idx++; c = fgetc (stdin);
	}
    }
}

/**/
int
main (int argc, char *argv[])
{
  eval_express ();
  return 0;
}
//-----(+ 1 (+ 2 3))-----//

编译运行，结果如预期，输出如下：

songvm@ubuntu:~/works/notes/lisp$ gcc xb.c -o xb
songvm@ubuntu:~/works/notes/lisp$ ./xb
REPL:> (+ 9 (+ 8 (+ 7 (+ 6 (+ 5 (+ 4 (+ 3 (+ 2 (+ 1 0)))))))))
-------------------------
 OP: +
INT: 9
SUB:
    OP: +
   INT: 8
   SUB:
       OP: +
      INT: 7
      SUB:
          OP: +
         INT: 6
         SUB:
             OP: +
            INT: 5
            SUB:
                OP: +
               INT: 4
               SUB:
                   OP: +
                  INT: 3
                  SUB:
                      OP: +
                     INT: 2
                     SUB:
                         OP: +
                        INT: 1
                        INT: 0
-------------------------
full expr: ( + 9 ( + 8 ( + 7 ( + 6 ( + 5 ( + 4 ( + 3 ( + 2 ( + 1 0 ) ) ) ) ) ) ) ) )
-------------------------
Result : 45
REPL:> (+ (* 8 9) (/ 200 4))
-------------------------
 OP: +
SUB:
    OP: *
   INT: 8
   INT: 9
SUB:
    OP: /
   INT: 200
   INT: 4
-------------------------
full expr: ( + ( * 8 9 ) ( / 200 4 ) )
-------------------------
Result : 122
REPL:>

完整代码如下：

/* filename: xb.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* compile : gcc xb.c -o xb */
/*     run : ./xb           */

/* define express datatype */
#define DT_OPERATOR 0X01
#define DT_INTEGER  0X02
#define DT_SUBEXPR  0X03

/* define express node struct */
typedef struct _ExpressNode ExprNode;

/* define express struct */
typedef struct _Express Expr;
struct _Express {
  char name[7]; //todo save variable name
  char dt; //express datatype
  union {
        char  oval; //operator
        long  ival; //integer
    ExprNode *bval; //subexpr
  } V;
};

/* define express node struct */
//typedef struct _ExpressNode ExprNode;
struct _ExpressNode {
  Expr expr;
  ExprNode *next;
};

/* define function pointer for express node */
typedef void (*EPFunc) (Expr expr);

/* create a new operator express node */
ExprNode *
expr_node_new_op (char val)
{
  ExprNode *node = (ExprNode*) malloc (sizeof(ExprNode));
  node->expr.dt = DT_OPERATOR;
  node->expr.V.oval = val;
  node->next = NULL;
  return node;
}

/* create a new integer express node */
ExprNode *
expr_node_new_int (long val)
{
  ExprNode *node = (ExprNode*) malloc (sizeof(ExprNode));
  node->expr.dt = DT_INTEGER;
  node->expr.V.ival = val;
  node->next = NULL;
  return node;
}

/* create a new sub express node */
ExprNode *
expr_node_new_sub (ExprNode *val)
{
  ExprNode *node = (ExprNode*) malloc (sizeof(ExprNode));
  node->expr.dt = DT_SUBEXPR;
  node->expr.V.bval = val;
  node->next = NULL;
  return node;
}

/* free the express node list */
void
expr_node_free (ExprNode *node)
{
  while (node != NULL)
    {
      ExprNode *tmp = node->next;
      if (node->expr.dt == DT_SUBEXPR)
	expr_node_free (node->expr.V.bval);
      free (node);
      node = tmp;
    }
}

/* append node to head */
ExprNode *
expr_node_append (ExprNode *head, ExprNode *node)
{
  ExprNode *tmp = head;
  if (tmp == NULL) return node;
  while (tmp->next != NULL)
    tmp = tmp->next;
  tmp->next = node;
  return head;
}

/* foreach node call epfunc from head to end */
void
expr_node_foreach (ExprNode *head, EPFunc epfunc)
{
  ExprNode *tmp = head;
  while (tmp != NULL)
    {
      epfunc (tmp->expr);
      tmp = tmp->next;
    }
}

/* compute express list */
/* declare here */
long
expr_node_compute (ExprNode *head);

/* run operator + return long int */
static long
expr_node_opadd (ExprNode *node)
{
  long rs = 0;
  ExprNode *tmp = node;
  if (tmp == NULL) return rs; //(+) return 0
  if (tmp->expr.dt == DT_SUBEXPR)
    { rs = expr_node_compute (tmp->expr.V.bval); }
  else if (tmp->expr.dt == DT_INTEGER)
    { rs = tmp->expr.V.ival; }
  tmp = tmp->next;
  while (tmp != NULL)
    {
      if (tmp->expr.dt == DT_SUBEXPR)
	{
	  rs = rs + expr_node_compute (tmp->expr.V.bval);
	}
      else if (tmp->expr.dt == DT_INTEGER)
	{
	  rs = rs + tmp->expr.V.ival;
	}
      tmp = tmp->next;
    }
  //printf ("OP add, RS : %ld\n", rs);
  return rs;
}

/* run operator - return long int */
static long
expr_node_opsub (ExprNode *node)
{
  long rs = 0;
  ExprNode *tmp = node;
  if (tmp == NULL) return rs; //(-) out err info, need arg
  if (tmp->expr.dt == DT_SUBEXPR)
    { rs = expr_node_compute (tmp->expr.V.bval); }
  else if (tmp->expr.dt == DT_INTEGER)
    { rs = tmp->expr.V.ival; }
  tmp = tmp->next;
  if (tmp == NULL) return -rs; //(- 9) ==> -9
  while (tmp != NULL)
    {
      if (tmp->expr.dt == DT_SUBEXPR)
	{
	  rs = rs - expr_node_compute (tmp->expr.V.bval);
	}
      else if (tmp->expr.dt == DT_INTEGER)
	{
	  rs = rs - tmp->expr.V.ival;
	}
      tmp = tmp->next;
    }
  //printf ("OP sub, RS : %ld\n", rs);
  return rs;
}

/* run operator * return long int */
static long
expr_node_opmul (ExprNode *node)
{
  long rs = 0;
  ExprNode *tmp = node;
  if (tmp == NULL) return 1; //(*) return 1
  if (tmp->expr.dt == DT_SUBEXPR)
    { rs = expr_node_compute (tmp->expr.V.bval); }
  else if (tmp->expr.dt == DT_INTEGER)
    { rs = tmp->expr.V.ival; }
  tmp = tmp->next;
  while (tmp != NULL)
    {
      if (tmp->expr.dt == DT_SUBEXPR)
	{
	  rs = rs * expr_node_compute (tmp->expr.V.bval);
	}
      else if (tmp->expr.dt == DT_INTEGER)
	{
	  rs = rs * tmp->expr.V.ival;
	}
      tmp = tmp->next;
    }
  //printf ("OP mul, RS : %ld\n", rs);
  return rs;
}

/* run operator / return long int */
static long
expr_node_opdiv (ExprNode *node)
{
  long rs = 1;
  ExprNode *tmp = node;
  if (tmp == NULL) return 1; //(/) out err info, need arg
  if (tmp->expr.dt == DT_SUBEXPR)
    { rs = expr_node_compute (tmp->expr.V.bval); }
  else if (tmp->expr.dt == DT_INTEGER)
    { rs = tmp->expr.V.ival; }
  tmp = tmp->next;
  while (tmp != NULL)
    {
      if (tmp->expr.dt == DT_SUBEXPR)
	{
	  rs = rs / expr_node_compute (tmp->expr.V.bval);
	}
      else if (tmp->expr.dt == DT_INTEGER)
	{
	  rs = rs / tmp->expr.V.ival;
	}
      tmp = tmp->next;
    }
  //printf ("OP div, RS : %ld\n", rs);
  return rs;
}

/* compute express list */
long
expr_node_compute (ExprNode *node)
{
  long rs = 0;
  ExprNode *tmp = node;
  switch (tmp->expr.V.oval)
    {
    case '+': rs = expr_node_opadd (tmp->next); break;
    case '-': rs = expr_node_opsub (tmp->next); break;
    case '*': rs = expr_node_opmul (tmp->next); break;
    case '/': rs = expr_node_opdiv (tmp->next); break;
    }
  return rs;
}

/* declare out_expinfo */
void
out_expinfo (ExprNode *head);

/* declare out_express */
void
out_express (ExprNode *head);

/* define output express info level */
static int exprlv = 0;

/* output express info */
void
out_expr_info (Expr expr)
{
  for (int i = 0; i < exprlv; i++) printf ("   ");
  switch (expr.dt)
    {
    case DT_OPERATOR: printf (" OP: %c\n",  expr.V.oval); break;
    case DT_INTEGER : printf ("INT: %ld\n", expr.V.ival); break;
    case DT_SUBEXPR : printf ("SUB:\n");
      exprlv++; out_expinfo (expr.V.bval); exprlv--; break;
    }
}

/* output express value */
void
out_expr_value (Expr expr)
{
  switch (expr.dt)
    {
    case DT_OPERATOR: printf (" %c",  expr.V.oval); break;
    case DT_INTEGER : printf (" %ld", expr.V.ival); break;
    case DT_SUBEXPR : out_express (expr.V.bval); break;
    }
}

/* output full express info */
void
out_expinfo (ExprNode *head)
{
  expr_node_foreach (head, out_expr_info);
}

/* output full express value */
void
out_express (ExprNode *head)
{
  printf (" (");
  expr_node_foreach (head, out_expr_value);
  printf (" )");
}

/* define number length */
#define NBSIZE 32

/* define stack height */
#define STSIZE 32

/* parse express string to express node */
ExprNode *
parse_expr_string (char *estr)
{
  ExprNode *root = NULL;
  ExprNode *st[STSIZE] = {0};
  char nbuf[NBSIZE] = {0};
  int idx = 0, ndx = 1, lv = 0;
  char c;

  nbuf[0] = '+'; //default +
  c = estr[idx];
  while (c != 0)
    {
      switch (c)
	{
	case '0'...'9': //number
	  {
	    char n = estr[idx+1];
	    nbuf[ndx] = c; ndx++;
	    if (n == ' ' || n == ')')
	      {
		long lt = strtol (nbuf, NULL, 10);
		ExprNode *tmp = expr_node_new_int (lt);
		st[lv-1] = expr_node_append (st[lv-1], tmp);
		memset (nbuf, 0, NBSIZE); nbuf[0] = '+'; ndx = 1;
	      }
	  }
	  break;

	case '+': case '-': case '*': case '/': //operator
	  {
	    if (c == '+' || c == '-')
	      {
		char n = estr[idx+1];
		if (n >= '0' && n <= '9')
		  {
		    nbuf[0] = c; break;
		  }
	      }
	    ExprNode *tmp = expr_node_new_op (c);
	    st[lv-1] = expr_node_append (st[lv-1], tmp);
	  }
	  break;

	case '(':
	  {
	    lv++; //todo
	    if (lv > STSIZE) printf ("Error: Syntax error, Stack overflow!\n");
	  }
	  break;

	case ')':
	  {
	    lv--;
	    if (lv == 0)
	      {
		root = st[lv];
		return root; //todo
	      }
	    else if (lv > 0)
	      {
		ExprNode *sub = expr_node_new_sub (st[lv]);
		st[lv-1] = expr_node_append (st[lv-1], sub);
		st[lv] = NULL;
	      }
	    else
	      { printf ("Error: Syntax error! Stack overflow!\n"); } //todo
	  }
	  break;

	case ' ': //space
	  break;

	defualt:
	  printf ("Syntax error!\n");
	}

      idx++; c = estr[idx];
    }

  return root;
}

/* test function */
void
test_parse (void)
{
  //char *str = "(+ 10 20) (+ 30 40)"; //???
  //char *str = "(+ 10 20 30 40 50)";
  //char *str = "(+ 10 20 (+ 30 40 50) 60 (+ 70 80) 90)";
  //char *str = "(+ 1 (+ 2 (+ 3 (+ 4 5))))";
  //char *str = "(+ 10 (+ 20 (+ 30 (+ 40 50))))";
  char *str = "(/ (+ 100 (- 300 200) (* 4 500)) 2)";
  ExprNode *head;
  head = parse_expr_string (str);

  printf (" express : %s\n", str);
  printf ("-------------------------\n");
  out_expinfo (head);
  printf ("-------------------------\n");
  printf ("full expr:");
  out_express (head);
  printf ("\n-------------------------\n");
  printf ("Result : %ld\n", expr_node_compute (head));

  expr_node_free (head);
}

/* interactive evalute express */
void
eval_express (void)
{
  ExprNode *elist = NULL;
  char buf[1024] = {0};
  int idx = 0;
  char c;

  printf ("REPL:> ");
  c = fgetc (stdin);
  while (c != EOF)
    {
      if (c == '\n')
	{
	  elist = parse_expr_string (buf);
	  printf ("-------------------------\n");
	  out_expinfo (elist);
	  printf ("-------------------------\n");
	  printf ("full expr:");
	  out_express (elist);
	  printf ("\n-------------------------\n");
	  printf ("Result : %ld\n", expr_node_compute (elist));
	  memset (buf, 0, 1024);
	  expr_node_free (elist); elist = NULL;
	  printf ("REPL:> ");
	  idx = 0; c = fgetc (stdin);
	}
      else
	{
	  buf[idx] = c;
	  idx++; c = fgetc (stdin);
	}
    }
}

/**/
int
main (int argc, char *argv[])
{
  eval_express ();
  return 0;
}
//-----(+ 1 (+ 2 3))-----//

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

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

相关文章

JavaScript对象笔记

JavaScript对象笔记

JavaScript对象笔记 什么是JavaScript对象 JavaScript对象是一组键值对的集合&#xff0c;其中键是字符串&#xff08;通常是字符串&#xff0c;但也可以是符号&#xff09;&#xff0c;值可以是任何数据类型。 特点 动态性&#xff1a;可以在运行时添加、删除或更改属性。灵…
阅读更多...
如何快速使用Unity 的UPR---1资源检测保姆级

如何快速使用Unity 的UPR---1资源检测保姆级

关于我们的性能检测工具已经有很多了&#xff0c;比如UWA的或者是我们的Unity 的UPR 都是很好的&#xff0c;今天说一下UPR吧 官方网址 &#xff1a;UPR - Unity专业性能优化工具 这个是官方给的Demo 选择你的平台就可以 这个可以作为一个参考但是不是很建议用官方的因为我们…
阅读更多...
Qt桌面应用开发 第九天（综合项目一 飞翔的鸟）

Qt桌面应用开发 第九天（综合项目一 飞翔的鸟）

目录 1.鸟类创建 2.鸟动画实现 3.鼠标拖拽 4.自动移动 5.右键菜单 6.窗口透明化 项目需求&#xff1a; 实现思路&#xff1a; 创建项目导入资源鸟类创建鸟动画实现鼠标拖拽实现自动移动右键菜单窗口透明化 1.鸟类创建 ①鸟类中包含鸟图片、鸟图片的最小值下标和最大值…
阅读更多...
【实体配置】.NET开源 ORM 框架 SqlSugar 系列

【实体配置】.NET开源 ORM 框架 SqlSugar 系列

.NET开源 ORM 框架 SqlSugar 系列 【开篇】.NET开源 ORM 框架 SqlSugar 系列【入门必看】.NET开源 ORM 框架 SqlSugar 系列【实体配置】.NET开源 ORM 框架 SqlSugar 系列【Db First】.NET开源 ORM 框架 SqlSugar 系列【Code First】.NET开源 ORM 框架 SqlSugar 系列【数据事务…
阅读更多...
Pytorch-GPU版本离线安装

Pytorch-GPU版本离线安装

最近在复现一项深度学习的工作&#xff0c;发现自己的pytorch是装的cpu版的(好像当时是直接加清华源&#xff0c;默认是cpu版本&#xff09;。从官网在线下载速度太慢&#xff0c;还时不时断开连接&#xff0c;我们可以配置conda的清华源去这个问题&#xff0c;但是考虑到是在用…
阅读更多...
聊聊Flink：这次把Flink的触发器(Trigger)、移除器(Evictor)讲透

聊聊Flink：这次把Flink的触发器(Trigger)、移除器(Evictor)讲透

一、触发器(Trigger) Trigger 决定了一个窗口&#xff08;由 window assigner 定义&#xff09;何时可以被 window function 处理。 每个 WindowAssigner 都有一个默认的 Trigger。 如果默认 trigger 无法满足你的需要&#xff0c;你可以在 trigger(…) 调用中指定自定义的 tr…
阅读更多...
[Redis#12] 常用类型接口学习 | string | list

[Redis#12] 常用类型接口学习 | string | list

目录 0.准备 1.string get | set set_with_timeout_test.cpp set_nx_xx_test.cpp mset_test.cpp mget_test.cpp getrange_setrange_test.cpp incr_decr_test.cpp 2.list lpush_lrange_test.cpp rpush_test.cpp lpop_rpop_test.cpp blpop_test.cpp llen_test.cpp…
阅读更多...
网络安全之IP伪造

网络安全之IP伪造

眼下非常多站点的涉及存在一些安全漏洞&#xff0c;黑客easy使用ip伪造、session劫持、xss攻击、session注入等手段危害站点安全。在纪录片《互联网之子》&#xff08;建议搞IT的都要看下&#xff09;中。亚伦斯沃茨&#xff08;真实人物&#xff0c;神一般的存在&#xff09;涉…
阅读更多...
Spring Web开发（请求）获取JOSN对象| 获取数据（Header）

Spring Web开发（请求）获取JOSN对象| 获取数据（Header）

大家好&#xff0c;我叫小帅今天我们来继续Spring Boot的内容。 文章目录 1. 获取JSON对象2. 获取URL中参数PathVariable3.上传⽂件RequestPart3. 获取Cookie/Session3.1 获取和设置Cookie3.1.1传统获取Cookie3.1.2简洁获取Cookie 3. 2 获取和存储Session3.2.1获取Session&…
阅读更多...
（SAST检测规则-1）Android - 权限管理漏洞

（SAST检测规则-1）Android - 权限管理漏洞

所属分类&#xff1a;Android - 权限管理漏洞缺陷详解&#xff1a;应用未正确实施最小权限原则或滥用已声明的权限可能导致敏感信息泄露。例如&#xff0c;恶意代码利用已授予的权限绕过用户授权&#xff0c;访问通讯录、位置、短信等敏感资源。部分开发者还可能滥用权限以执行…
阅读更多...
EC2还原快照

EC2还原快照

EC2还原快照 AWS EC2 磁盘快照 是您 Amazon Elastic Block Store (EBS) 卷在特定时间点的增量备份。您可以使用快照创建 EBS 卷的副本&#xff0c;以便在出现故障时恢复数据或将数据迁移到其他区域。 创建磁盘快照 找到ec2实例挂载的磁盘&#xff0c;直接选择创建快照 等待创建…
阅读更多...
oracle RAC各版本集群总结和常用命令汇总

oracle RAC各版本集群总结和常用命令汇总

oracle RAC学习 RAC介绍 RAC&#xff1a;高可用集群&#xff0c;负载均衡集群&#xff0c;高性能计算集群 RAC是⼀种⾼可⽤&#xff0c;⾼性能&#xff0c;负载均衡的share-everything的集群 8i:内存融合雏形 内存融合雏形&#xff08;Oracle Parallel Server&#xff09;…
阅读更多...
【聚类】K-Means 聚类（无监督）及K-Means ++

【聚类】K-Means 聚类（无监督）及K-Means ++

1. 原理 2. 算法步骤 3. 目标函数 4. 优缺点 import torch import numpy as np import matplotlib.pyplot as plt from sklearn.cluster import KMeans from sklearn.decomposition import PCA import torch.nn as nn# 数据准备 # 生成数据&#xff1a;100 个张量&#xff0c…
阅读更多...
智慧银行反欺诈大数据管控平台方案（一）

智慧银行反欺诈大数据管控平台方案（一）

智慧银行反欺诈大数据管控平台建设方案的核心在于通过整合先进的大数据技术和深度学习算法&#xff0c;打造一个全面、智能且实时的反欺诈系统&#xff0c;以有效识别、预防和应对各类金融欺诈行为。该方案涵盖数据采集、存储、处理和分析的全流程&#xff0c;利用多元化的数据…
阅读更多...
搭建业务的性能优化指南

搭建业务的性能优化指南

这是一篇搭建业务优化的心路历程&#xff0c;也是写给搭建业务的性能优化指南。 前言 直到今天&#xff0c;淘内的页面大多都迁移到了 SSR&#xff0c;从我们终端平台 - 搭建研发团队的视角看&#xff0c;业务大致可以分为两类 —— 搭建派 和 源码派。 这两者互不冲突&#xf…
阅读更多...
【Db First】.NET开源 ORM 框架 SqlSugar 系列

【Db First】.NET开源 ORM 框架 SqlSugar 系列

.NET开源 ORM 框架 SqlSugar 系列 【开篇】.NET开源 ORM 框架 SqlSugar 系列【入门必看】.NET开源 ORM 框架 SqlSugar 系列【实体配置】.NET开源 ORM 框架 SqlSugar 系列【Db First】.NET开源 ORM 框架 SqlSugar 系列【Code First】.NET开源 ORM 框架 SqlSugar 系列【数据事务…
阅读更多...
搭建私有云存储

搭建私有云存储

1、安装LNMP环境 yum install nginx -y yum install -y nginx mariadb-server php php-fpm php-mysqlnd systemctl restart nginx.service --- 启动Nginx systemctl start mariadb.service ---启动数据库 mysql -e create database lxdb character set utf8 ---创建数据库 my…
阅读更多...
YOLO 标注工具 AutoLabel 支持 win mac linux

YOLO 标注工具 AutoLabel 支持 win mac linux

常见的标注工具&#xff0c;功能基础操作繁琐&#xff0c;无复制粘贴&#xff0c;标签无法排序修改&#xff0c;UI不美观&#xff0c;bug修正不及时&#xff0c;没有集成识别、训练、模型导出… 怎么办呢&#xff1f;AutoLabel它来了 Quick Start 一图胜千言 图像标注 支持YOL…
阅读更多...
qt QGraphicsPolygonItem详解

qt QGraphicsPolygonItem详解

1、概述 QGraphicsPolygonItem是Qt框架中QGraphicsItem的一个子类&#xff0c;它提供了一个可以添加到QGraphicsScene中的多边形项。通过QGraphicsPolygonItem&#xff0c;你可以定义和显示一个多边形&#xff0c;包括其填充颜色、边框样式等属性。QGraphicsPolygonItem支持各…
阅读更多...
Linux网络_网络协议_网络传输_网络字节序

Linux网络_网络协议_网络传输_网络字节序

一.协议 1.概念 协议&#xff08;Protocol&#xff09; 是一组规则和约定&#xff0c;用于定义计算机网络中不同设备之间如何进行通信和数据交换。协议规定了数据的格式、传输方式、传输顺序等详细规则&#xff0c;确保不同设备和系统能够有效地互联互通。 在网络通信中&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023