Blore's Home

article

0%

Posted on
Symbols count in article: 268

Shell笔记

原文 https://missing-semester-cn.github.io/

在shell中导航

pwd：获取当前工作目录。
cd：切换目录。. 表示当前目录，..表示上级目录。
ls：看指定目录下包含哪些文件。
mv：用于重命名或移动文件
cp：拷贝文件
mkdir：新建文件夹
man (cmd)：展现指令文档（用户手册）
(cmd) -h/--help：指令帮助信息

在程序间创建连接

< file 和 > file：将程序的输入输出流分别重定向到文件

>>：向一个文件追加内容

|：将一个程序的输出和另外一个程序的输入连接起来

Posted on Edited on
Symbols count in article: 3.6k

OS 宏定义 queue.h

一、基础定义

LIST_HEAD(name, type)

1
2
3
4
#define LIST_HEAD(name, type)                                           	\
        struct name {                                                           \
                struct type *lh_first;  /* first element */                     \
        }

参数

name - 链表名

type - 链表内储存单元名

作用

用于定义链表类型

LIST_HEAD_INITIALIZER(head) （存疑）

1
2
#define LIST_HEAD_INITIALIZER(head)                                     \
        { NULL }

作用

返回NULL，用于初始化链表头

LIST_ENTRY(type)

1
2
3
4
5
#define LIST_ENTRY(type)                                                	\
        struct {                                                                \
                struct type *le_next;   /* next element */                      \
                struct type **le_prev;  /* address of previous next element */  \
        }

参数

type - 链表内储存单元名

作用

链表项，定义在链表储存单元中，用于指向前/后储存单元。实际使用中作为储存单元的一部分出现。

LIST_EMPTY(head)

1
#define LIST_EMPTY(head)        ((head)->lh_first == NULL)

参数

head - 链表头指针

作用

判断链表是否为空

LIST_FIRST(head)

1
#define LIST_FIRST(head)        ((head)->lh_first)

参数

head - 链表头指针

作用

返回链表中第一个元素指针

LIST_FOREACH(var, head, field)

1
2
3
4
#define LIST_FOREACH(var, head, field)                                  \
        for ((var) = LIST_FIRST((head));                                \
                 (var);                                                 \
                 (var) = LIST_NEXT((var), field))

参数

var - 遍历用链表储存单元指针（迭代器）

head - 链表头指针

field - 链表项（数据类型定义为LIST_ENTRY）

作用

遍历链表中所有元素

LIST_INIT(head)

1
2
3
#define LIST_INIT(head) do {                                            \
                LIST_FIRST((head)) = NULL;                              \
        } while (0)

参数

head - 链表头指针

作用

初始化链表头指针指向为空

LIST_INSERT_AFTER(listelm, elm, field)

1
2
3
4
5
6
7
8
#define LIST_INSERT_AFTER(listelm, elm, field) do {														\
		LIST_NEXT((elm), field) = LIST_NEXT((listelm), field);										\
		if (LIST_NEXT((listelm), field) != NULL) {																\
			LIST_NEXT((listelm), field)->field.le_prev = &LIST_NEXT((elm), field);	\
		}																																					\
		LIST_NEXT((listelm), field) = (elm);																			\
		(elm)->field.le_prev = (listelm);																					\
        } while (0)

参数

listelm - 链表中原有储存单元指针

elm - 新储存单元指针

field - 链表项（数据类型定义为LIST_ENTRY）

作用

将 elm 插到已有元素 listelm 之后。

LIST_INSERT_BEFORE(listelm, elm, field)

1
2
3
4
5
6
#define LIST_INSERT_BEFORE(listelm, elm, field) do {		                \
                (elm)->field.le_prev = (listelm)->field.le_prev;                \
                LIST_NEXT((elm), field) = (listelm);                            \
                *(listelm)->field.le_prev = (elm);                              \
                (listelm)->field.le_prev = &LIST_NEXT((elm), field);            \
        } while (0)

参数

listelm - 链表中原有储存单元指针

elm - 新储存单元指针

field - 链表项（数据类型定义为LIST_ENTRY）

作用

将 elm 插到已有元素 listelm 之前。

LIST_INSERT_HEAD(head, elm, field)

1
2
3
4
5
6
#define LIST_INSERT_HEAD(head, elm, field) do {                   		      \
                if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)    	      \
                        LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field); \
                LIST_FIRST((head)) = (elm);                                           \
                (elm)->field.le_prev = &LIST_FIRST((head));                           \
        } while (0)

参数

head - 链表头指针

elm - 新储存单元指针

field - 链表项（数据类型定义为LIST_ENTRY）

作用

将elm 插到头部结构体指针head对应链表的头部

LIST_INSERT_TAIL(head, elm, field)

1
2
3
4
5
6
7
8
9
10
11
12
13
#define LIST_INSERT_TAIL(head, elm, field) do {								\
		if (LIST_FIRST((head)) != NULL) {																						\
        LIST_NEXT((elm), field) = LIST_FIRST((head));														\
        while(LIST_NEXT(LIST_NEXT((elm), field), field) != NULL) {							\
        	LIST_NEXT((elm), field) = LIST_NEXT(LIST_NEXT((elm), field), field);	\
				}																																				\
				LIST_NEXT(LIST_NEXT((elm), field), field) = (elm);											\
				(elm)->field.le_prev = &LIST_NEXT(LIST_NEXT((elm), field), field);			\
				LIST_NEXT((elm), field) = NULL;																					\
		} else {																																		\
				LIST_INSERT_HEAD((head), (elm), field);																	\
		}																																						\
	} while (0)

参数

head - 链表头指针

elm - 新储存单元指针

field - 链表项（数据类型定义为LIST_ENTRY）

作用

将elm 插到头部结构体指针head对应链表的尾部

LIST_NEXT(elm, field)

1
#define LIST_NEXT(elm, field)   ((elm)->field.le_next)

参数

elm - 储存单元指针

field - 链表项（数据类型定义为LIST_ENTRY，elm成员变量）

作用

返回指向下一储存单元的指针

LIST_REMOVE(elm, field)

1
2
3
4
5
6
#define LIST_REMOVE(elm, field) do {                                    	\
                if (LIST_NEXT((elm), field) != NULL)                            \
                        LIST_NEXT((elm), field)->field.le_prev =                \
                                        (elm)->field.le_prev;                   \
                *(elm)->field.le_prev = LIST_NEXT((elm), field);                \
        } while (0)

参数

elm - 储存单元指针

field - 链表项（数据类型定义为LIST_ENTRY，elm成员变量）

作用

从链表中移除elm

TAILQ_HEAD(name, type)

1
2
3
4
5
#define TAILQ_HEAD(name, type)                                          	\
        struct name {                                                           \
                struct type *tqh_first; /* first element */                     \
                struct type **tqh_last; /* addr of last next element */         \
        }

TAILQ_ENTRY(type)

1
2
3
4
5
#define TAILQ_ENTRY(type)                                               	\
        struct {                                                                \
                struct type *tqe_next;  /* next element */                      \
                struct type **tqe_prev; /* address of previous next element */  \
        }

二、理解

  • le_prev使用双重指针（?）
  • 链表内无malloc/free机制
  • 链表头的le_prev指向自身地址

Posted on Edited on In
Symbols count in article: 3k

概述

层次分析法(AHP法)是一种解决多目标的复杂问题的定性与定量相结合的决策分析方法。该方法将定量分析与定性分析结合起来，用决策者的经验判断各衡量目标能否实现的标准之间的相对重要程度，并合理地给出每个决策方案的每个标准的权数，利用权数求出各方案的优劣次序，比较有效地应用于那些难以用定量方法解决的课题。

Read more »