GTX log 6

5.24-7.2

相关算法

判断两颗二叉树相等

有两种方法：一种是递归比较。另一种是二叉树的遍历。

先说二叉树的遍历。由于先序遍历再加上中序遍历能唯一确定一棵二叉树。故，对这两棵树分别进行先序和中序遍历，比较这两棵树的先序遍历序列和中序遍历序列，如果都一样则说明这两棵二叉树是一样的。这里用了两次遍历。时间复杂度为O(2N)

首先比较根结点是不是一样的；如果根结点一样，再继续比较根的左右孩子是不是一样的，这是一个递归过程。


struct BinaryNode {
	char data;
}

struct BinaryTree {
	int data;
	BinaryNode *lc;
	BinaryNode *rc;
}

bool isEqual(BinaryTree A, BinaryTree B) {
	if (A == NULL && B == NULL)
		return true;
	if (!A || !B)
		return false;
	if (A->data == T2 -> data)
		return isEqual(A->lc, B->lc) && isEqual(A -> rc, B -> rc)
	else
		return false;
}

判断二叉树是另一颗二叉树子结构 pointer or value

个人感觉判断子结构要比判断子树困难一点，如果是子树，那么它一定是子结构；但是反过来不成立。

判断子结构的核心思路其实与 (1) 中判断两棵树是否相同是一致的。只不过对于 (1) 而言，只要有一个结点不相同了，那这二棵二叉树就不是一样的了。而对于子结构而言，有可能某个结点的子树中包含了子结构。

首先遍历二叉树A的根结点8，由于二叉树B的根为4，两者不同。此时我们可以判断出这两棵树是不相同的。

但是，我们还不能判断出二叉树B 不是二叉树A 的子结构。还需要进一步判断。这个判断，就是一个递归过程了。递归如下：

判断二叉树A的根结点的左子树是否包含了二叉树B，若未包含，再判断二叉树A的根结点的右子树是否包含了二叉树B

从前面的 (2) 可知，我们可以用判断子结构的实现，来判断子树。

若二叉树B是二叉树A的子结构，且二叉树A的根结点与二叉树B的根结点不相同。那么，二叉树B就是二叉树A的子树了。

故这种方法的时间复杂度也为O(NK)

此外，还有另外一种方法：可将该问题转化为串的匹配问题。如果二叉树是B是二叉树A的子树，

则二叉树B的中序遍历序列 (前序、后序应该也是可以的吧)是二叉树A的中序遍历序列的一个子串。

从而，可以用KMP算法实现字符串匹配。如果匹配成功，则说明二叉树B是二叉树A的子树，反之则不是。

DP算法

https://blog.csdn.net/u010900754/article/details/55015018

https://blog.csdn.net/cr496352127/article/details/77934132?locationNum=10&fps=1

字符串匹配算法

朴素匹配算法


int navie_string_matcher(char *T, char *P)
{
	lenOri = strlen(T)
	lenMod = strlen(P)
	
	for i = 0;i<lenOri;i++ {
		for j = 0;j<lenMod;j++ {
			if P[j] != T[i+j] 匹配位数 是一样同步的
				break // 如果不匹配 则 跳出 offset ++ 
			if j = lenMod - 1 // 匹配完毕
				return s;
		}
	}
}

Rabin-Karp 算法

以十进制数来表示字符串算法匹配中更加方便。

给定一个模式串P[1-m]，同理在文本串T[s+1..s+m]表示文本串中某段与模式串长度相等的一串字符，那么分别用数字p,t表示这两个字符串，通过比较数字p和t的大小，就可确定字符串是否匹配而无需用模式串中字符依次匹配文本串。

也就是直接比较数字防止额外的依次遍历

也可以用于字符串分类？

数学中有霍纳法则,我们运用霍纳法则在O(m)内计算p：

p=P[m]+10(P[m-1]+10(P[m-2]+…+10(P[2]+10P1)…)))


#include "stdio.h"
#include "string.h"
#include "math.h"

char* substr(char* p, int start, int end)
{
	char *q = malloc(sizeof(char)*(end-start+1))
	int i = 0;
	for(;i<end-start+1;i++) {
		*(q+i) = *(p+start+i)
	}
	return q;
}

void Rabin_karp_matcher(char T[], char P[], int d, int q)
{
	n = strlen(T)
	m = strlen(P)
	h = ((int)pow(d, m-1))
	p=0
	t=0
	for(i=0;i<m;i++) {
		p=(d*p+P[i]-'a')%q;//求p
        t =(d*t +T[i]-'a')%q;
        t0=(d*t0 +T[i]-'a');//求初始t0=num(T[1,m])
	}
	int s;
    for(s=0;s<=n-m;s++)
    {
            if(p==t&&(strcmp(P,substr(T,s,s+m-1))==0))
         //  if(p==t)
           {

                printf("%d\n",s);
           }

           printf("%d  %d  %c \n",t,p,T[s]);
           int tem=t0;
           t0=(d*(tem-(T[s]-'a')*h)+T[s+m]-'a');//求ts+1;
           t=t0%q;
  //              int tem=t;
   //             t=(d*(tem-(T[s]-'a')*h)+T[s+m]-'a')%q;

    }
}

int main()
{

        char T[100], P[100];
        scanf("%s",T);
        scanf("%s",P);
        RABIN_KARP_MATCHER(T,P,10,13);

        return 0;
}

有限自动机

https://blog.csdn.net/u011467044/article/details/55008649

KMP

在模式P匹配文本T时，当匹配到最后一位不匹配时，朴素字符串匹配的做法是P往前移动一位继续匹配

可是根据我们的观察发现更有效的做法是P可以直接往前移动两位

如上个人理解PI数组主要记录当前匹配无效时下次的有效偏移位数，避免无效的偏移。
KMP算法充分利用已匹配的信息，避免重复的匹配过程。


#include<stdio.h>
#include<string.h>
#define MAX_LEN 20
int PI[MAX_LEN];

void Compute_prefix_fun(char P[])
{
    int m,k,q;
    m=strlen(P);
    PI[0]=0;
    k=0;
    for(q=1;q<m;++q)
    {
        while((k>0)&&P[k]!=P[q])
        {
            //q=PI[q];
            k=PI[k];
        }
        if(P[k]==P[q])
            k=k+1;

        PI[q]=k;
    }

}
void  KMP_matcher(char T[],char P[])
{
    int n,m,q,i;
    n=strlen(T);
    m=strlen(P);
    Compute_prefix_fun(P);
    q=0;
    for(i=0;i<n;i++)
    {
        while((q>0)&&P[q]!=T[i])
        {
            q=PI[q-1];
        }
        if(P[q]==T[i])
            q=q+1;
        if(q==m)
        {
            printf("%d\n",i-m+1);
            q=PI[q-1];
        }

    }

}
int main()
{


    char T[20],P[20];
    scanf("%s",T);
    scanf("%s",P);
    KMP_matcher(T,P);
    return 0;
}

PHP

常量 PHP_SAPI 判断当前运行模式


if (PHP_SAPI == "cli" // "cgi") {
	//
}

Throwable 是PHP7以上才有的涵盖更多 Exception 选项

PHP 从 MySQL 查出来的可能会多 \r\n 的字符不符合可以去掉

str_replace

call_user_func_array

对函数不定参数函数可以进行解构操作方便使用

Linux

pstree 查看当前进程树

可以通过 pstree 看到当前进程树

如何构建磁盘满的状态？

首先将 dev/ramX 挂在一个目录这个目录的可写入大小大概为100M左右

dd if=/dev/zero of=sun.txt bs=5000000M count=10

就充满了这个分区

例如 PHP file_put_content 默认存储会导致报错

fswatch (MAC) inotifyWait (linux)

文件监控

inotifywait -e modify -e create -e move --format '%T %w%f %Xe %e ' -m --exclude .tmp$ --exclude '^*.[0-9a-zA-Z]{6}$'  -r --timefmt '%a %b %d %T %Y'  /data1/ms/template /data1/ms/template.test /data1/ms/resource

远程运维工具 SaltStack

Golang

Go cmd.exec 执行目录问题

rsync的时候为了创建新文件夹在target上，需要R参数，但是必须cd 到指定目录

go的执行shell命令是不可以直接cd的

通过

1 2	cmd := exec.Command("ls") cmd.Dir="/"

即可

Go for 启动闭包函数携程带来的坑

原代码


for i,checker := range k.checkers {
	go func () {
		checker(k)
	}()
}

结果发现 range 并且启动了之后启动的都是同一个checker

修改代码后发现


for i,checker := range k.checkers {
	go func (checker Checker) {
		checker(k)
	}(checker)
}

运行了正常的checkers

得知 go 在开启携程时遇到 for 并不会立即开启携程会在for range 之后开启因此需要在go func 内部进行传参保证每次启动的闭包函数正确

Go 多协程读写 Map 会报错

map不是线程(goroutine)安全的。

增加 Sync.Mutex 互斥所或者 RWMutex 读写锁可以解决问题

对于 hashMap的更新问题

如果多线程在访问hashMap

可以 read dirty save 三个

写入的 dirty

读取的时候如果 dirty 有则读dirty 并且写入read

如果扩容的时候读read

然后底层扩容然后进行read dirty 综合判断后复制

time.Duration

话说这个感觉 Go 真的是画蛇添足了

time.sleep(time.Duration(k.sleep_time) * time.second)

真的是冗长的代码

Go 的fswatch库

官方不支持 -r 的递归监控放弃吧 inotify + fswatch

defer

defer 会在函数return 之前执行用于一些句柄等资源的回收但是会造成性能的削减

Go 运行时内存堆栈分析

参考备忘录 Markdown 传不上来

posted @ 2018-09-10 23:37 guoguoqingzhe 阅读(228) 评论(0) 编辑收藏举报

刷新页面返回顶部

guoguoqingzhe