首页 > 其他分享 >线段树入门讲解

线段树入门讲解

时间：2025-01-13 22:21:52浏览次数：1  
标签：ll 入门 val 线段 tree mid tag 讲解 id

有一段时间没有更新了，前面比较忙，所以知识上会有一些跳跃，后面看看有没有时间去补一下吧，没有就算了

那现在就开始说一下线段树

线段树是一种数据结构，他主要是用于实现快速的区间修改和区间求和这两个功能，同时，有别于树状数组，线段树还有更多的是在于其功能的强大和灵活性上，就比如说，树状数组可以用来维护区间和，进行单点修改，但是若是要做到区间修改就需要去使用差分，但是线段树不用，那么线段树又是怎么形成的呢？可以看下面的代码来讲解

（后面模版代码会使用python和C++，题目的代码会主要使用C++来演示（因为python被卡了语言TLE，太难受了））

那么先看一个线段树的模版题
https://www.luogu.com.cn/problem/P3372
这个题是线段树最经典的题目

是维护区间和，那么首先先看看测试用例在使用了线段树之后会变成什么样

(作者手绘的优点抽象)

但是就是这样子，我对于一个区间去做二分，不断地二分，直到左右指针相互到达了同一位置，这时我将其设置为递归出口，标志着递归结束，作为树的叶子节点，标志着结束，之后对于每一个上面的节点，他的值就等于他的左儿子节点和右儿子节点的值的和，这样子，就可以得到线段树了

那么接下来就是代码实现（直接先展示完整代码，剩下的后面再详细讲解）

Python

 
class SegmentTree:
    def __init__(self, n):
        self.n=n
        self.tag=[0]*(4*(n+1))
        self.val=[0]*(4*(n+1))
 
    def pushdown(self,id,ls,rs):
        self.tag[id*2]+=self.tag[id]#标记传给左儿子和右儿子
        self.tag[id*2+1]+=self.tag[id]
        self.val[id*2]+=self.tag[id]*ls#更新左儿子和右儿子的值
        self.val[id*2+1]+=self.tag[id]*rs
        self.tag[id]=0#当前节点标记设置为0
 
    def build(self,id,l,r,arr):
        self.tag[id]=0#建树前初始化标记为0
        if l==r:
            self.val[id]=arr[l]
            return
        mid=(l+r)//2
        self.build(id*2,l,mid,arr)
        self.build(id*2+1,mid+1,r,arr)
        self.val[id]=self.val[id*2]+self.val[id*2+1]
 
    def update(self,L,R,v,id,l,r):
        #L,R是要修改的区间，v是要加上的值,l,r是有效的边界
        if L>r or R<l:
            return
        if L<=l and r<=R:
            self.tag[id]+=v#将当前区间的tag加上v
            self.val[id]+=v*(r-l+1)#将当前区间的值更新
            return
        mid=(l+r)//2
        self.pushdown(id,mid-l+1,r-mid)#标记下传
        self.update(L,R,v,id*2,l,mid)
        self.update(L,R,v,id*2+1,mid+1,r)
        self.val[id]=self.val[id*2]+self.val[id*2+1]
 
    def query(self,L,R,id,l,r):
        #L,R是要查询的区间,l,r是有效的边界
        if L>r or R<l:
            return 0
        if L<=l and r<=R:
            return self.val[id]
        mid=(l+r)//2
        self.pushdown(id,mid-l+1,r-mid)#标记下传
        return self.query(L,R,id*2,l,mid)+self.query(L,R,id*2+1,mid+1,r)
 
    def init(self,arr):
        self.build(1,1,self.n,arr)
 
    def add(self,l,r,v):
        self.update(l,r,v,1,1,self.n)
 
    def get(self,l,r):
        return self.query(l,r,1,1,self.n)
 
import sys
input=sys.stdin.readline
mii=lambda:map(int,input().split())
N,Q=mii()
a=[0]+list(mii())
st=SegmentTree(N)
st.init(a)
for i in range(Q):
    list1=list(mii())
    if list1[0]==1:
        l,r,v=list1[1:]
        st.add(l,r,v)
    elif list1[0]==2:
        l,r=list1[1:]
        print(st.get(l,r))

之后是C++

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define MAXN 100010
 
ll n, m;
ll a[MAXN];
 
struct Node{
	ll val, tag;
}tree[MAXN * 4];
 
void build(ll id, ll l,ll r) {
	tree[id].tag = 0;
	if (l == r) {
		tree[id].val = a[l];
		return;
	}
	ll mid = (l + r) >> 1;
	build(id * 2, l, mid);
	build(id * 2 + 1, mid + 1, r);
	tree[id].val = tree[id * 2].val + tree[id * 2 + 1].val;
}
 
void pushdown(ll id, ll ls, ll rs) {
	if (tree[id].tag == 0) {
		return;
	}
	tree[id * 2].tag += tree[id].tag;
	tree[id * 2 + 1].tag += tree[id].tag;
	tree[id * 2].val += tree[id].tag * ls;
	tree[id * 2+1].val += tree[id].tag * rs;
	tree[id].tag = 0;
}
 
void update(ll L, ll R, ll v, ll l, ll r,ll id) {
	//L,R是操作区间，l,r是有效边界
	if (L > r || R < l){
		return;
	}
	if (L <= l && r <= R) {
		tree[id].tag += v;
		tree[id].val += v * (r - l + 1);
		return;
	}
	ll mid = (r + l) >> 1;
	pushdown(id, mid - l + 1, r - mid);
	update(L, R, v, l, mid, id * 2);
	update(L, R, v, mid + 1, r, id * 2 + 1);
	tree[id].val = tree[id * 2].val + tree[id * 2+1].val;
 
}
 
ll query(ll L, ll R ,ll l ,ll r ,ll id) {
	if (L > r || R < l) {
		return 0;
	}
	if (L <= l && r <= R) {
		return tree[id].val;
	}
	ll mid = (l + r) >> 1;
	pushdown(id, mid-l + 1, r - mid);
	return query(L, R, l, mid, id * 2) + query(L, R, mid + 1, r, id * 2 + 1);
}
 
 
int main() {
	cin >> n >> m;
	for (ll i = 1; i <= n; i++) {
		cin >> a[i];
	}
 
	build(1, 1, n);
	ll opt, l, r,k;
	for (ll i = 1; i <= m; i++) {
		cin >> opt;
		if (opt == 1) {
			cin >> l >> r >> k;
			update(l, r, k, 1, n, 1);
		}
		else if (opt == 2) {
			cin >> l >> r;
			cout << query(l, r, 1, n, 1) << endl;
		}	
	}
}

这里面我们就先看build这个函数，通常，在处理线段树的题目时，首先，我们通常会使用一个叫做id的标记来记录，这个是一个约定俗成的惯例（其实也是有规律的，可以参考二进制），对于一个节点，对于一个节点的左儿子，他的id为id2，他的右儿子为id2+1，那么这个时候看build函数，

build函数接受了3个参数，分别是id,l,r那么在递归后是对区间进行二分，那么便是假设中间的为mid=(l+r)//2(其实使用位运算左移和//2在C++11之后好像区别不是特别大了，不会因为这个把时间给卡了)，然后他就被分成了两个区间，分别是[l,mid]和[mid+1,r]，这样子就完成了一个线段树的建树

但是在build函数中出现了一个东西，tree[id].tag=0(在C++里面，python也有类似的)，这个东西又是做什么的，这个便是设计到了线段树的区间修改和区间查询这两个重要功能的实现，也是线段树的精髓，叫做懒标记（lazytag）。

那么如果我要对一个区间进行修改，比如增加某一个特定的值，那么朴素的做法就是去将区间每一个值都增加一个value，假设区间的长度是m那么他所需的时间是m，这无疑是一个比较慢的做法，但是如果说我将他要增加某一个value的行为使用一个标记不断的将树的每一个节点给标记上，那么接下来，我每一次要查询的时候就随着递归不断地将标记给向下转移，这样子，就可以实现了一个区间上的修改。

那么来讲一下具体的代码实现，可以参考update函数和pushdown函数

    def pushdown(self,id,ls,rs):
        self.tag[id*2]+=self.tag[id]#标记传给左儿子和右儿子
        self.tag[id*2+1]+=self.tag[id]
        self.val[id*2]+=self.tag[id]*ls#更新左儿子和右儿子的值
        self.val[id*2+1]+=self.tag[id]*rs
        self.tag[id]=0#当前节点标记设置为0
 
    def update(self,L,R,v,id,l,r):
        #L,R是要修改的区间，v是要加上的值,l,r是有效的边界
        if L>r or R<l:
            return
        if L<=l and r<=R:
            self.tag[id]+=v#将当前区间的tag加上v
            self.val[id]+=v*(r-l+1)#将当前区间的值更新
            return
        mid=(l+r)//2
        self.pushdown(id,mid-l+1,r-mid)#标记下传
        self.update(L,R,v,id*2,l,mid)
        self.update(L,R,v,id*2+1,mid+1,r)
        self.val[id]=self.val[id*2]+self.val[id*2+1]

在这里pushdown函数就是用来实现标记下移的功能，先将左右儿子的标记作为下移，之后就对当前节点的左右儿子进行更新，去增加一个value*长度的值，之后，将当前位置的标记设置为0，这样子就清空了当前的节点的标记，

然后就是update函数，就是与pushdown函数进行结合，来使用，那么update也可以分为三种情况，分别是1）递归当前的位置与要修改的位置没有关系 2）递归到的当前位置在当前的修改位置范围内 3）递归到的当前位置在修改区间的部分范围 对于第一种情况，就直接return返回结果，而对于第二种情况，递归到当前修改位置的时候，这时就对区间的tag和value进行修改，而若是第三种情况，这进行标记下传并且进行向下递归

而下一步就是区间的查询操作，请看query函数

    def query(self,L,R,id,l,r):
        #L,R是要查询的区间,l,r是有效的边界
        if L>r or R<l:
            return 0
        if L<=l and r<=R:
            return self.val[id]
        mid=(l+r)//2
        self.pushdown(id,mid-l+1,r-mid)#标记下传
        return self.query(L,R,id*2,l,mid)+self.query(L,R,id*2+1,mid+1,r)

同样的，也是分为三种情况来进行讨论，原理一样，就不一一赘述了，只是这里面选择直接递归，和一般题解会去讨论mid是靠近左还是右的不一样，不过并没有什么关系就是了。

然后就是在最后就可以返回区间查询的值了，这道题就可以过了

（一开始还有点抵触线段树，然后用树状数组，结果MLE了）

然后再看后面的一些关于线段树的变式，这里的代码统一使用C++来演示
https://www.luogu.com.cn/problem/P4145
这个题其实和之前的线段树模版差不多，但是这里是涉及了开根号的处理方法，那么这里怎么处理呢？首先先对比一下前面的，我们发现使用懒标记去进行区间修改时，问题是比较明显的，他必须满足一个f(a+b)=f(a)+f(b)的关系式（f表示对应的操作，这里面表示满足结合律），那么这个开根号的情况肯定不满足的，因为，所以这里没有办法使用懒标记，所以怎么办呢？

那就不用呗，直接修改也不是不行。

#include<bits/stdc++.h>
#define ll long long
#define MAXN (int)1e5+10
using namespace std;
 
struct {
	ll val,maxnum;
}tree[4*MAXN];
 
int m, n;
ll a[MAXN];
int k;
ll l, r;
 
void build(ll L, ll R, ll id) {
	if (L == R) {
		tree[id].val = a[L];
		return;
	}
	ll mid = (L + R) >> 1;
	build(L, mid, id * 2);
	build(mid + 1, R, id * 2 + 1);
	tree[id].val = tree[id * 2].val + tree[id * 2 + 1].val;
	tree[id].maxnum = max(tree[id * 2].maxnum, tree[id * 2 + 1].maxnum);
}
 
 
void update(ll L, ll R, ll id, ll l, ll r) {
	// l,r 是要更新的区间， L,R是递归到当前位置的区间；
 
	if (R < l || r < L ) {
		return;
	}
 
	if (L == R && l<=L && r>=R) {
		
		tree[id].val = floor(sqrt(tree[id].val));
		tree[id].maxnum = floor(sqrt(tree[id].val));
		return;
	}
	ll mid = (L + R) >> 1;
	if (tree[id * 2].val > 1) {
		update(L, mid, id * 2, l, r);
	}
	if (tree[id * 2 + 1].val > 1) {
		update(mid + 1, R, id * 2 + 1, l, r);
	}
	tree[id].val = tree[id * 2 + 1].val + tree[id * 2].val;
	tree[id].maxnum = max(tree[id * 2].maxnum, tree[id * 2 + 1].maxnum);
}
 
ll query(ll L, ll R, ll id, ll l, ll r) {
	if (R < l || r < L) {
		return 0;
	}
	if (l<=L && r>=R) {
		return tree[id].val;
	}
	ll mid = (L + R) >> 1;
	return query(L, mid, id * 2, l, r) + query(mid + 1, R, id * 2 + 1,l, r);
}
 
int main() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
	}
	build(1, n, 1);
 
	
	cin >> m ;
	for (int i = 1; i <= m; i++) {
 
		cin >> k >> l >> r;
		if (k == 0) {
			update(1, n, 1, l, r);
		}
		else if (k == 1) {
			cout << query(1, n, 1, l, r)<<endl;
 
 
		}
	}
}

就这样信心满满的交了一发，但是作为一个蒟蒻，我也不出所料的得到了这个结果

于是就开始优化，我于是就开始想想怎么优化，我发现如果进行开根号的操作，最后都会接近于1，所以若是我递归到当前位置之后发现当前为1之后，就不用往下继续处理了，于是就修改了一下，代码，，就AC了，下面是源代码

 
#include<bits/stdc++.h>
#define ll long long
#define MAXN (int)1e5+10
using namespace std;
 
struct {
	ll val,maxnum;
}tree[4*MAXN];
 
int m, n;
ll a[MAXN];
int k;
ll l, r;
 
ll int read() {
	ll x = 0;
	char c = getchar();
	while (!isdigit(c)) {
		c = getchar();
	}
	while (isdigit(c)) {
		x = (x << 3) + (x << 1) + c - '0';
		c = getchar();
	}
	return x;
}
 
void build(ll L, ll R, ll id) {
	if (L == R) {
		tree[id].val = a[L];
		tree[id].maxnum = a[L];
		return;
	}
	ll mid = (L + R) >> 1;
	build(L, mid, id * 2);
	build(mid + 1, R, id * 2 + 1);
	tree[id].val = tree[id * 2].val + tree[id * 2 + 1].val;
	tree[id].maxnum = max(tree[id * 2].maxnum, tree[id * 2 + 1].maxnum);
}
 
 
void update(ll L, ll R, ll id, ll l, ll r) {
	// l,r 是要更新的区间， L,R是递归到当前位置的区间；
 
	if (R < l || r < L ) {
		return;
	}
	if (L == R && l<=L && r>=R) {
		
		tree[id].val = floor(sqrt(tree[id].val));
		
		tree[id].maxnum = floor(sqrt(tree[id].maxnum));
		
		return;
	}
	ll mid = (L + R) >> 1;
	if (tree[id * 2].maxnum > 1) {
		update(L, mid, id * 2, l, r);
	}
	if (tree[id].maxnum > 1) {
		update(mid + 1, R, id * 2 + 1, l, r);
	}
	tree[id].val = tree[id * 2 + 1].val + tree[id * 2].val;
	tree[id].maxnum = max(tree[id * 2].maxnum, tree[id * 2 + 1].maxnum);
}
 
ll query(ll L, ll R, ll id, ll l, ll r) {
	if (R < l || r < L) {
		return 0;
	}
	if (l<=L && r>=R) {
		return tree[id].val;
	}
	ll mid = (L + R) >> 1;
	return query(L, mid, id * 2, l, r) + query(mid + 1, R, id * 2 + 1,l, r);
}
 
int main() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
	}
	build(1, n, 1);
	
	
	cin >> m ;
	for (int i = 1; i <= m; i++) {
 
		cin >> k >> l >> r;
		if (l > r)swap(l, r);
		if (k == 0) {
			update(1, n, 1, l, r);
		}
		else if (k == 1) {
			cout << query(1, n, 1, l, r)<<endl;
 
		}
	}
}

https://www.luogu.com.cn/problem/P1471
这个题的思路比较巧妙

他是一个对懒标记的应用，除此之外，还有就是线段树的结构在建树的时候也发生了改变，这里在建树的时候，会存在3个不同的value，分别是tag，value，还有square，这三个，所以我在建立线段树的时候会需要分别处理三个值

那么这时，他的build函数就会与之不同，像这样子

void pushup(ll id) {
	tree[id].square = tree[id * 2].square + tree[id * 2 + 1].square;
	tree[id].val = tree[id * 2].val + tree[id * 2 + 1].val;
}
 
 
void build(ll id, ll l, ll r) {
	tree[id].tag = 0;
	if (l == r) {
		tree[id].val = a[l];
		tree[id].square = pow(a[l], 2);
		return;
	}
 
	ll mid = (l + r) >> 1;
	build(id * 2, l, mid);
	build(id * 2 + 1, mid + 1, r);
	pushup(id);
}

其实和普通的线段树并没有太大的区别，之后就是他的pushdown函数，以及update函数，query函数

先看pushdown函数，pushdown函数他在这里的处理如下

void pushdown(ll id, ll ls, ll rs) {
	tree[id * 2].tag += tree[id].tag;
	tree[id * 2 + 1].tag += tree[id].tag;
	tree[id * 2].square += (2 * tree[id * 2].val * tree[id].tag + ls * pow(tree[id].tag, 2));
	tree[id * 2 + 1].square += (2 * tree[id * 2 + 1].val * tree[id].tag + rs * pow(tree[id].tag, 2));
	tree[id * 2].val += tree[id].tag * ls;
	tree[id * 2 + 1].val += tree[id].tag * rs;
	tree[id].tag = 0;
}

这里面除了更新tag之外，还要对square和value进行更新，在这里进行更新的时候要注意一定是先更新square在更新val，因为square的更新根据完全平方公式是需要使用val来进行维护的，所以说在这里一定要处理square之后再去处理val，

然后就是update函数

void update(ll L, ll R, ll id, ll l, ll r,ll v) {
	//L,R表示要查询的区间，l,r表示递归到的位置
	if (r<L || l>R) {
		return;
	}
	if (L <= l && r <= R) {
		tree[id].tag += v;
		tree[id].square += 2 * v * tree[id].val + pow(v, 2) * (r - l + 1);
		tree[id].val += v * (r - l + 1);
		return;
	}
	ll mid = (l + r) >> 1;
	pushdown(id, mid - l + 1, r - mid);
	update(L, R, id * 2, l, mid, v);
	update(L, R, id * 2 + 1, mid + 1, r, v);
	pushup(id);
}

这里也是一样，先处理square在处理val，别的没有太大的区别

最后就是query函数

这里会出现两个query函数，一个是用来处理query正常的val的，另一个是用来处理square的，这里和普通的query没有太多的区别

double query_val(ll L, ll R, ll id, ll l, ll r) {
	if (r<L || l>R) {
		return 0;
	}
	if (L <= l && r <= R) {
		return tree[id].val;
	}
	ll mid = (l + r) >> 1;
	pushdown(id, mid - l + 1, r - mid);
	return query_val(L, R, id * 2, l, mid) + query_val(L, R, id * 2 + 1, mid + 1, r);
}

最后就是如何去求均值和方差，但是方差的公式需要变形，推理如下，可知

所以我们就可以通过这种方式去求出方差了

#include<bits/stdc++.h>
#define ll long long
#define MAXN (int)1e6+10
 
using namespace std;
long double a[MAXN];
ll n, m;
ll opt, x, y;
long double k;
struct {
	long double tag, val, square;
}tree[MAXN*4];
 
void pushdown(ll id, ll ls, ll rs) {
	tree[id * 2].tag += tree[id].tag;
	tree[id * 2 + 1].tag += tree[id].tag;
	tree[id * 2].square += (2 * tree[id * 2].val * tree[id].tag + ls * pow(tree[id].tag, 2));
	tree[id * 2 + 1].square += (2 * tree[id * 2 + 1].val * tree[id].tag + rs * pow(tree[id].tag, 2));
	tree[id * 2].val += tree[id].tag * ls;
	tree[id * 2 + 1].val += tree[id].tag * rs;
	tree[id].tag = 0;
}
 
void pushup(ll id) {
	tree[id].square = tree[id * 2].square + tree[id * 2 + 1].square;
	tree[id].val = tree[id * 2].val + tree[id * 2 + 1].val;
}
 
void build(ll id, ll l, ll r) {
	tree[id].tag = 0;
	if (l == r) {
		tree[id].val = a[l];
		tree[id].square = pow(a[l], 2);
		return;
	}
 
	ll mid = (l + r) >> 1;
	build(id * 2, l, mid);
	build(id * 2 + 1, mid + 1, r);
	pushup(id);
}
 
void update(ll L, ll R, ll id, ll l, ll r,long double v) {
	//L,R表示要查询的区间，l,r表示递归到的位置
	if (r<L || l>R) {
		return;
	}
	if (L <= l && r <= R) {
		tree[id].tag += v;
		tree[id].square += 2 * v * tree[id].val + pow(v, 2) * (r - l + 1);
		tree[id].val += v * (r - l + 1);
		return;
	}
	ll mid = (l + r) >> 1;
	pushdown(id, mid - l + 1, r - mid);
	update(L, R, id * 2, l, mid, v);
	update(L, R, id * 2 + 1, mid + 1, r, v);
	pushup(id);
}
 
double query_val(ll L, ll R, ll id, ll l, ll r) {
	if (r<L || l>R) {
		return 0;
	}
	if (L <= l && r <= R) {
		return tree[id].val;
	}
	ll mid = (l + r) >> 1;
	pushdown(id, mid - l + 1, r - mid);
	return query_val(L, R, id * 2, l, mid) + query_val(L, R, id * 2 + 1, mid + 1, r);
}
 
double query_var(ll L, ll R, ll id, ll l, ll r) {
	if (r<L || l>R) {
		return 0;
	}
	if (L <= l && r <= R) {
		return tree[id].square;
	}
	ll mid = (l + r) >> 1;
	pushdown(id, mid - l + 1, r - mid);
	return query_var(L, R, id * 2, l, mid) + query_var(L, R, id * 2 + 1, mid + 1, r);
 
}
 
int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
	}
	build(1, 1, n);
	
	for (int i = 1; i <= m; i++) {
		cin >> opt;
		if (opt == 1) {
			cin >> x >> y >> k;
			update(x, y, 1, 1, n, k);
			
		}
		else if (opt == 2) {
			cin >> x >> y;
			double ans = query_val(x, y, 1, 1, n) / (y - x + 1);
			printf("%.4lf\n", ans);
		}
		else if (opt == 3) {
			cin >> x >> y;
			double ans1 = pow(query_val(x, y, 1, 1, n) / (y - x + 1), 2);
			double ans = -ans1 + query_var(x, y, 1, 1, n) / (y - x + 1);
			printf("%.4lf\n", ans);
 
		}
	}
	
}

ok，那就到这里就结束了

标签：ll,入门,val,线段,tree,mid,tag,讲解,id
From： https://www.cnblogs.com/fufufuf/p/18669541

相关文章

  • 数位 dp 入门
    如果余生有浪漫的星河，日子慢慢过。《如果我们在余生相遇》现在发现我们理解一件事情，其实是基于我们的认知去理解的。所以一些以前理解不了的事情，或者说当时难以理解的事情，过一段时间，再去看，可能恍然大悟。#include<iostream>#include<algorithm>#include<vector>usin......
  • SQL刷题快速入门（二）
    其他章节：SQL刷题快速入门（一）承接上一章节，本章主要讲SQL的运算符、聚合函数、SQL保留小数的几种方式三个部分运算符SQL支持多种运算符，用于执行各种操作，如算术运算、比较、赋值、逻辑运算等。以下是一些常见的SQL运算符类型及其示例：算术运算符+（加）-（减）*（乘）/（除）%（取模）SELECT......
  • 【黑灰产】杀猪盘作案流程讲解
    作案步骤何谓杀猪盘，指的是诈骗分子利用网络交友，获取受害人充分信任后，诱导受害人投资赌博的一种电信诈骗方式。“杀猪盘”是“从业者们”（诈骗团伙）自己起的名字，是指放长线“养猪”诈骗，养得越久，诈骗得越狠。整个杀猪盘作案流程可以分为三个步骤：找猪、养猪、杀猪。作案流程整......
  • Kali高手都在用的环境变量技巧，学会这些就能实现隐蔽渗透！黑客技术零基础入门到精通教程
    大家好，我们今天继续更新《黑客视角下的KaliLinux的基础与网络管理》中的管理用户环境变量。为了充分利用我们的黑客操作系统KaliLinux，我们需要理解和善于使用环境变量，这样会使我们的工具更具便利，甚至具有一定的隐蔽性。1.环境变量基础概念1.1什么是变量？变量在计算机......
  • 【PS不常见教程】减淡工具、加深工具和海绵工具的讲解
    观前小提示：本文内容为我原创成果，若您需要转载或引用其中图片或文字内容，请记得标注来源是“璞子的家”哦，感谢您的尊重，理解与支持，谢谢啦！所谓教程的目的是为了让大家能够更加清楚的了解软件，是更加深入的了解，真的不敢高台教化，不敢为人师，与网上的各位“所谓老师”不敢比肩，我......
  • 1130: 【入门】简单a+b（字符串式子a+b）
    看到了吗，不是正常的输入a和b，然后直接相加，而是一个式子，没关系，一个字符串对于电脑而言奥秘多多，给电脑一个式子，他会反应吗？是不是不会。诶，但是让他去提取，那就是“怎么看都看不够”，嘿嘿，开个玩笑，就是提取字符串里的信息可以解决不少问题，这题就是这样。下面是代码：#include<bits/stdc......
  • Apache Hop从入门到精通 第三课 Apache Hop下载&安装
    1、下载官方下载地址：https://hop.apache.org/download/，本教程是基于apache-hop-client-2.11.0.zip进行解压，需要jdk17，小伙伴们可以根据自己的需求下载相应的版本。如下图所示2、下载jdk17（https://www.microsoft.com/openjdk）本次下载jdk包为microsoft-jdk-17.0.13-macos-x64.......
  • STM32 HAL库函数入门指南：从原理到实践
    1STM32HAL库概述STM32HAL(HardwareAbstractionLayer)库是ST公司专门为STM32系列微控制器开发的一套硬件抽象层函数库。它的核心设计理念是在应用层与硬件层之间建立一个抽象层，这个抽象层屏蔽了底层硬件的具体实现细节，为开发者提供了一套统一的、标准化的应用程序接口（API）......
  • 【网络安全渗透测试零基础入门】一文带你0基础挖到逻辑漏洞（非常详细），轻松成为朋友眼中
    前言这是七海给粉丝盆友们整理的网络安全渗透测试入门阶段逻辑漏洞渗透与防御教程本文主要讲解如何从零基础带你挖到逻辑漏洞喜欢的朋友们，记得给我点赞支持和收藏一下，关注我，学习黑客技术。逻辑漏洞概述由于程序逻辑不严谨或逻辑太过复杂，导致一些逻辑分支不能正常处理或......
  • 万字详解内网渗透该怎么学！黑客技术零基础入门到精通实战教程建议收藏！
    前言：本文主要记录了作者之前在内网渗透的一个全方面的学习过程，包括如何从外网找到入口点，之后如何提权，然后如何在内网中进行一个信息收集，当存在域的情况下又是怎么收集信息，然后通过代理来进一步横向，不论是一层代理还是两层，本文都有涉及，以及一些常见的代理工具的使用方法、权......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99