2. 程式人生 > >普通線段樹——高階資料結構入門

普通線段樹——高階資料結構入門

阿新 • • 發佈：2018-12-08

一.線段樹引入.

線段樹，是一種基於分治思想的高階樹形資料結構，可以支援滿足快速合併性質的資訊維護.

線段樹作為較為容易也較傳統的高階資料結構，應用廣泛，在高階資料結構中佔有重要的地位.

 

二.線段樹概述.

我們先來回憶一下分治，分治的一個應用就是想要得到一個區間的值f(l,r)，這個值不能直接求得，但是可以藉助f(l,mid)和f(mid+1,r)來快速得到，而且對於任意一個x，f(x,x)的值也可以快速得到，那麼就可以通過分治來求得.

一個經典的演算法就是歸併排序，它要排序區間[1,n]，那麼就先排好區間[1,mid]和[mid+1,n]，合併區間[1,mid]和[mid+1,n]已經排好的兩個序列.然後[1,mid]也不能直接排好，就把這個區間也通過兩個子區間的資訊合併...直到區間變成了[x,x]，這個區間直接有序了，就可以直接返回求得排好序的序列.

那麼我們把上述分治的過程畫成一張圖（假設是區間[1,8]）的話：

我們發現這其實是一棵樹，而且我們可以把這個東西顯式建樹，就可以得到一棵線段樹.

 

三.基本操作Merge.

既然一個區間[l,r]的資訊要通過區間[l,mid]和[mid,r]的資訊合併來得到，那麼自然要寫一個函式來實現這個功能了.

雖然一般來說，這個函式的程式碼量通常很小，都不會單獨寫一個函式，但是在這裡還是寫一下吧，這裡以維護區間和為例：

tree Merge(tree a,tree b){
  tree c;
  c.l=a.l;c.r=b.r;
  c.sum=c.sum+b.sum;
  return c;
}

 

四.建樹Build.

建樹的過程其實就是一個分治，然後把每一個節點的資訊存下來.

這裡我們依然以維護區間和為例，設a陣列為初始的值的情況，那麼就分治到葉子（區間[l,r]滿足l=r），就把資訊直接存到葉子上，其它節點的資訊就通過兩個兒子的資訊合併就可以了.

由於我們的分治就是將所有點操作了一遍，而這棵完全二叉樹的節點個數為2n-1，所以建樹是O(n)的.

具體程式碼如下：

void Build(int L,int R,int k=1){
  tr[k].l=L;tr[k].r=R;
  if (L==R){
    tr[k].sum=a[L];
    return;
  }
  int mid=L+R>>1;
  Build(L,mid,k<<1);Build(mid+1,R,k<<1|1);
  tr[k]=Merge(tr[k<<1],tr[k<<1|1]);
}

 

五.單點操作.

我們考慮一個單點操作，比如說單點查詢一個點x的值.這個應該比較容易，可以從根開始不斷往下遞迴找到葉子節點[x,x]，然後直接返回這個葉子的資訊即可.

我們在考慮一個單點修改的操作，比如說給一個點x加上v，那麼我們可以找到葉子[x,x]，講葉子的資訊直接加上v.但是葉子發生改變後，會使該葉子的所有祖先的資訊發生改變，所以我們要在回溯的時候，再讓經過的節點進行merge操作.

由於每次操作最多隻會經過一條從根到葉子的鏈，長度為樹高，而樹高為O(logn)，所以單點操作的時間複雜度為O(logn).

具體程式碼如下：

int Query(int x,int k=1){
  if (tr[k].l==tr[k].r) return tr[k].sum;
  int mid=tr[k].l+tr[k].r>>1;
  if (x<=mid) return Query(x,k<<1);
  else return Query(x,k<<1|1);
}

void Add(int x,int num,int k=1){
  if (tr[k].l==tr[k].r){
    tr[k].sum+=num;
    return;
  }
  int mid=tr[k].l+tr[k].r>>1;
  if (x<=mid) Add(x,num,k<<1);
  else Add(x,num,k<<1|1);
  tr[k]=Merge(tr[k<<1],tr[k<<1|1]);
}

 

六.區間查詢操作.

對於區間查詢[l,r]資訊並的操作，我們當然可以利用上面單點查詢每一個點，然後將資訊並起來，但是這樣就會使時間複雜度變為O(nlogn)，十分不優美.

我們考慮從根節點向下的時候，若要查詢的區間包括在一個節點的左兒子，直接往左兒子向下；右兒子同理；若左右兒子都有，則左右兒子都遞迴進入，最後將兩個兒子中找到的答案合併起來就行了.

但是這樣的時間複雜度貌似還是O(n)，但其實我們可以證明這是O(logn)的.

證明如下：

首先，這個區間[l,r]在每一層，都只會遍歷到最多4個節點.

若會遍歷到4個以上節點，則必定有兩個節點表示的區間是直接被[l,r]包含且是兄弟的關係，那麼這兩個節點應該會在上一層就被遍歷過了，不會在這一層再被遍歷了.

所以，每一層最多會遍歷到4個節點，所以時間複雜度為O(logn).

證畢.

那麼區間查詢程式碼如下（以區間加為例）：

int Query(int L,int R,int k=1){
  if (L==tr[k].l&&R==tr[k].r) return tr[k].sum;
  int mid=tr[k].l+tr[k].r>>1;
  if (R<=mid) return Query(L,R,k<<1);
  else if (L>mid) return Query(L,R,k<<1|1);
    else return Query(L,mid,k<<1)+Query(mid+1,R,k<<1|1); 
}

 

七.區間修改與lazy-tag.

區間修改，我們以給區間[l,r]的每個數加上y為例.

我們考慮與區間查詢類似，直接找到每一個需要修改的修改，然後對每一個區間直接加上y*區間長度.

但是這樣子的話，被修改的節點下所有節點都要修改，但這樣做就會無法修改，暴力修改又太慢，我們該怎麼辦？

我們引入lazy-tag的概念，給每一個修改的節點在打上一個tag標記，表示這個節點下面的所有節點都要增加一個值.

那麼，當我們要查詢點的時候，對所有經過的節點的tag往下推，對下面的節點進行修改，我們把這個過程寫成一個函式pushdown.

那麼我們就可以做到O(logn)修改啦，但是要注意若有tag，最好在任何操作經過任何節點都pushdown.

程式碼如下：

void Update_add(int k,int num){      //為了簡潔寫一個Update函式 
  tr[k].sum+=num*(tr[k].r-tr[k].l+1);
  tr[k].tag+=num; 
}

void Pushdown(int k){
  Update_add(k<<1,tr[k].tag);Update_add(k<<1|1,tr[k].tag);
  tr[k].tag=0;
}

void Add(int L,int R,int num,int k=1){
  if (L==tr[k].l&&R==tr[k].r){
    Update_add(k,num);
    return;
  }
  Pushdown(k);
  int mid=tr[k].l+tr[k].r>>1;
  if (R<=mid) Add(L,R,num,k<<1);
  else if (L>mid) Add(L,R,num,k<<1|1);
    else Add(L,mid,num,k<<1),Add(mid+1,R,num,k<<1);
  tr[k]=Merge(tr[k<<1],tr[k<<1|1]);
}

 

八.例題與程式碼.

現在我們拿出三道例題，分別為luogu3372，luogu3374，luogu3368.

luogu3372程式碼：

#include<bits/stdc++.h>
  using namespace std;

#define Abigail inline void
typedef long long LL;

const int N=500000;

int n,m;
LL a[N+9];
struct tree{
  int l,r;
  LL sum,tag;
}tr[N*4+9];

void Update_add(int k,LL num){
  tr[k].sum+=num*(tr[k].r-tr[k].l+1);
  tr[k].tag+=num;
}

void Pushdown(int k){
  Update_add(k<<1,tr[k].tag);Update_add(k<<1|1,tr[k].tag);
  tr[k].tag=0LL; 
}

void Build(int L,int R,int k=1){
  tr[k].l=L;tr[k].r=R;
  if (L==R){
    tr[k].sum=a[L];
    return;
  }
  int mid=L+R>>1;
  Build(L,mid,k<<1);Build(mid+1,R,k<<1|1);
  tr[k].sum=tr[k<<1].sum+tr[k<<1|1].sum;
}

void Add(int L,int R,LL num,int k=1){
  if (L==tr[k].l&&R==tr[k].r){
    Update_add(k,num);
    return;
  }
  Pushdown(k);
  int mid=tr[k].l+tr[k].r>>1;
  if (R<=mid) Add(L,R,num,k<<1);
  else if (L>mid) Add(L,R,num,k<<1|1);
    else Add(L,mid,num,k<<1),Add(mid+1,R,num,k<<1|1);
  tr[k].sum=tr[k<<1].sum+tr[k<<1|1].sum;
}

LL Query(int L,int R,int k=1){
  if (L==tr[k].l&&R==tr[k].r) return tr[k].sum;
  Pushdown(k);
  int mid=tr[k].l+tr[k].r>>1;
  if (R<=mid) return Query(L,R,k<<1);
  else if (L>mid) return Query(L,R,k<<1|1);
    else return Query(L,mid,k<<1)+Query(mid+1,R,k<<1|1); 
}

Abigail into(){
  scanf("%d%d",&n,&m);
  for (int i=1;i<=n;++i)
    scanf("%lld",&a[i]);
}

Abigail work(){
  Build(1,n);
}

Abigail getans(){
  int opt,l,r;
  LL x;
  for (int i=1;i<=m;++i){
    scanf("%d",&opt);
    if (opt==1){
      scanf("%d%d%lld",&l,&r,&x);
      Add(l,r,x);
    }else{
      scanf("%d%d",&l,&r);
      printf("%lld\n",Query(l,r));
    }
  }
}

int main(){
  into();
  work();
  getans();
  return 0;
}

luogu3374程式碼：

#include<bits/stdc++.h>
  using namespace std;

#define Abigail inline void
typedef long long LL;

const int N=500000;

int n,m;
LL a[N+9];
struct tree{
  int l,r;
  LL sum;
}tr[N*4+9];

void Build(int L,int R,int k=1){
  tr[k].l=L;tr[k].r=R;
  if (L==R){
    tr[k].sum=a[L];
    return;
  }
  int mid=L+R>>1;
  Build(L,mid,k<<1);Build(mid+1,R,k<<1|1);
  tr[k].sum=tr[k<<1].sum+tr[k<<1|1].sum;
}

void Add(int x,LL num,int k=1){
  if (tr[k].l==tr[k].r){
    tr[k].sum+=num;
    return;
  }
  int mid=tr[k].l+tr[k].r>>1;
  if (x<=mid) Add(x,num,k<<1);
  else Add(x,num,k<<1|1);
  tr[k].sum=tr[k<<1].sum+tr[k<<1|1].sum; 
}

LL Query(int L,int R,int k=1){
  if (tr[k].l==L&&tr[k].r==R) return tr[k].sum;
  int mid=tr[k].l+tr[k].r>>1;
  if (R<=mid) return Query(L,R,k<<1);
  else if (L>mid) return Query(L,R,k<<1|1);
    else return Query(L,mid,k<<1)+Query(mid+1,R,k<<1|1);
}

Abigail into(){
  scanf("%d%d",&n,&m);
  for (int i=1;i<=n;++i)
    scanf("%lld",&a[i]);
}

Abigail work(){
  Build(1,n);
}

Abigail getans(){
  int opt,l,r;
  LL x;
  for (int i=1;i<=m;++i){
    scanf("%d",&opt);
    if (opt==1){
      scanf("%d%lld",&l,&x);
      Add(l,x);
    }else{
      scanf("%d%d",&l,&r);
      printf("%lld\n",Query(l,r));
    }
  }
}

int main(){
  into();
  work();
  getans();
  return 0;
}

luogu3368程式碼：

#include<bits/stdc++.h>
  using namespace std;

#define Abigail inline void
typedef long long LL;

const int N=500000;

int n,m;
LL a[N+9];
struct tree{
  int l,r;
  LL sum,tag;
}tr[N*4+9];

void Update_add(int k,LL num){
  tr[k].sum+=num*(tr[k].r-tr[k].l+1);
  tr[k].tag+=num;
}

void Pushdown(int k){
  Update_add(k<<1,tr[k].tag);Update_add(k<<1|1,tr[k].tag);
  tr[k].tag=0;
}

void Build(int L,int R,int k=1){
  tr[k].l=L;tr[k].r=R;
  if (L==R){
    tr[k].sum=a[L];
    return;
  }
  int mid=L+R>>1;
  Build(L,mid,k<<1);Build(mid+1,R,k<<1|1);
  tr[k].sum=tr[k<<1].sum+tr[k<<1|1].sum;
}

void Add(int L,int R,LL num,int k=1){
  if (tr[k].l==L&&tr[k].r==R){
    Update_add(k,num);
    return;
  }
  Pushdown(k);
  int mid=tr[k].l+tr[k].r>>1;
  if (R<=mid) Add(L,R,num,k<<1);
  else if (L>mid) Add(L,R,num,k<<1|1);
    else Add(L,mid,num,k<<1),Add(mid+1,R,num,k<<1|1);
  tr[k].sum=tr[k<<1].sum+tr[k<<1|1].sum;
}

LL Query(int x,int k=1){
  if (tr[k].l==tr[k].r) return tr[k].sum;
  Pushdown(k);
  int mid=tr[k].l+tr[k].r>>1;
  if (x<=mid) return Query(x,k<<1);
  else return Query(x,k<<1|1);
}

Abigail into(){
  scanf("%d%d",&n,&m);
  for (int i=1;i<=n;++i)
    scanf("%lld",&a[i]);
}

Abigail work(){
  Build(1,n);
}

Abigail getans(){
  int opt,l,r;
  LL x;
  for (int i=1;i<=m;++i){
    scanf("%d",&opt);
    if (opt==1){
      scanf("%d%d%lld",&l,&r,&x);
      Add(l,r,x);
    }else{
      scanf("%d",&l);
      printf("%lld\n",Query(l));
    }
  }
}

int main(){
  into();
  work();
  getans();
  return 0;
}

 

相關推薦

普通線段樹——高階資料結構入門

一.線段樹引入. 線段樹，是一種基於分治思想的高階樹形資料結構，可以支援滿足快速合併性質的資訊維護. 線段樹作為較為容易也較傳統的高階資料結構，應用廣泛，在高階資料結構中佔有重要的地位.   二.線段樹概述. 我們先來回憶一下分治，分治的一個應用就是想要得到一個區間

【線段樹】資料結構

【描述】 在看了 jiry_2 的課件《Segment Tree Beats!》後，小 O 深深沉迷於這種能單次 O(logn) 支援區間與一個數取 min/max，查詢區間和等資訊的資料結構，於是他決定做一道與區間與 一個數取 min/max 的好題。 這題是這樣的：你得到了一個長度為 n

C Primer Plus--高階資料結構之二叉樹

目錄 二叉搜尋樹 Binary Search Tree 用C構建二叉樹ADT 樹結構的定義 C Primer Plus--高階資料結構表示之二叉樹 二叉搜尋樹 Binary Search Tree 二叉樹是一種高階資料結構。樹中的每個節點都包含一個專案和兩個指向其他

郝斌資料結構入門--P63-樹的儲存

郝斌資料結構入門--P63-樹的儲存   完全二叉樹： 先把一棵樹轉換為滿二叉樹，再把最底層最右邊刪掉，意味著下圖黃色框可以刪掉，不儲存。剩下的一棵樹就是完全二叉樹。   為什麼一個二叉樹以陣列的方式儲存時，必須要求這個數是完全二叉樹？ 上圖紅色是真

郝斌資料結構入門--P60--樹的定義與分類

郝斌資料結構入門--P60--樹   樹和森林就是以遞迴的方式定義的。 樹和圖的很多演算法都是以遞迴來實現的。   非線性結構-----樹 樹的定義 專業定義： 1.有且只有一個稱為根的節點 2.有若干個互不相交的子樹，這些子樹本身也是一棵樹

郝斌資料結構入門--P75-鏈式二叉樹具體遍歷程式演示

郝斌資料結構入門--P75-鏈式二叉樹具體遍歷程式演示   知道遞迴的實現與應用，二叉樹的遍歷就容易了。   程式碼如下： #include <stdio.h> #include <malloc.h> struct BTNode {

郝斌資料結構入門--P70-樹 已知兩種遍歷序列求原始二叉樹

郝斌資料結構入門--P70-樹 已知兩種遍歷序列求原始二叉樹   已知先序、中序、後序任何一種序列，不能夠找到原始二叉樹。 經過研究發現，已知一棵樹的兩種序列，可以把二叉樹求出來。 也經過研究發現，已知先序和後序，無法還原出原始的二叉樹。 最終表明，通過  先

郝斌資料結構入門--P67-二叉樹的先序、中序、後序遍歷

郝斌資料結構入門--P67-二叉樹的先序、中序、後序遍歷   技巧：先、中、後序，是針對訪問根節點的位置來定義的。先序，先訪問根。中序，中間訪問根。後序，最後訪問根。   二叉樹的遍歷 （數是一個非線性的，通過先序、中序、後序遍歷把非線性的儲存線性的硬體上）

高階資料結構的學習與實現之 Trie樹，字典樹

第一次自學一種新的資料結構，感覺學會利用資源很重要，參考別人寫的部落格，谷歌搜尋一下關於這中資料結構的一些問題，解決等，學會搜尋資料，學習並掌握一門資料結構並不是很難。 要知道相關的基本知識，主要應用與哪一方面，還有它的具體實現是如何的。 在編碼的時候還是會遇到各種問題，需

資料結構入門---初始二叉樹（下）

這篇文章我們準備將二叉樹實現為具體的程式碼 首先我們要從二叉樹的遍歷說起。二叉樹的遍歷主要有四種形式 1. 前序遍歷 方法：如果二叉樹為空，則直接返回。如果二叉樹非空，則訪問根結點，再前序遍歷左子樹，然後前序遍歷右子樹 我們可以知道這樣的遍歷方式是以遞迴

Redis從入門到高可用，分散式實踐 二（高階資料結構和持久化）

慢查詢 pipeline 釋出訂閱 bitmap（點陣圖） string型別，最大512mb 注意setbit偏移量，可能有較大耗時 點陣圖要合理使用

nginx 學習八 高階資料結構之基數樹ngx_radix_tree_t

1 nginx的基數樹簡介 基數樹是一種二叉查詢樹，它具備二叉查詢樹的所有優點：檢索、插入、刪除節點速度快，支援範圍查詢，支援遍歷等。在nginx中僅geo模組使用了基數樹。nginx的基數樹使用ngx_radix_tree_t這個結構體表示的。ngx_radix_tree

資料結構入門--線索二叉樹

當我們遍歷一棵二叉樹時，我們會得到整棵樹資料的一個序列（前or中or後），可以知道一個數據結點的前驅或者後繼是哪個結點。但是，對於每個結點的結構，我們只能從中得知某結點的左右孩子的資訊，要得到前驅/後繼結點的資訊就要遍歷一遍二叉樹，這樣豈不是很麻煩？我們能不能有

資料結構入門-樹的遍歷以及二叉樹的建立

樹定義： 有且只有一個稱為根的節點 有若干個互不相交的子樹，這些子樹本身也是一個樹 通俗的講： 樹是有結點和邊組成， 每個結點只有一個父結點，但可以有多個子節點 但有一個節點例外，該節點沒有父結點，稱為根節點 一、專業術語 結點、父結點、子結點、根結點 深度：從根節點到最底層結點的層數稱為深度，根節點

高階資料結構---紅黑樹及其插入左旋右旋程式碼java實現

前面我們說到的二叉查詢樹，可以看到根結點是初始化之後就是固定了的，後續插入的數如果都比它大，或者都比它小，那麼這個時候它就退化成了連結串列了，查詢的時間複雜度就變成了O(n),而不是理想中O(logn),就像這個樣子      如果我們有一個平衡機制，讓這棵樹可以動起來，比如將

高階資料結構---堆樹和堆排序

堆樹介紹： 之前在二叉樹的時候說到過一種特殊的二叉樹---完全二叉樹（除了最後一層，其他層的每個結點都是滿的，且最後一層結點全部靠左排列，這樣就可以很方便的用陣列來表示，下標從0開始如果父結點索引是i那麼它兩個子結點的索引就是2i+1和2i+2,具體的圖解見二叉樹）。而堆樹又是一種特殊的完全二叉樹。它的每一個

POJ-3667 線段樹區間合並入門題

\n 向上 urn 開始 連續 每次 線段樹 最大連續 () 題意：長度為n的區間，m個操作，一開始都是0 1 x表示求出長度為x的0的連續區間的最左端，並把這個區間變成1 2 x y表示將區間[x,y]變成0 線段樹的區間合並第一題： 每次維護左端連續區間長

郝斌資料結構入門--P50--遞迴

郝斌資料結構入門--P50--遞迴   定義： 一個函式自己直接或間接呼叫自己。   舉例： 1、求階乘 #include <stdio.h> //假定n的值是1或大於1的值 long f(long n) { if (1 == n)

郝斌資料結構入門---P30---棧

郝斌資料結構入門---P30---棧   線性結構的常見應用之一：棧（只能頭部插入，頭部刪除） 定義：一種可以實現“ 先進後出 ”的儲存結構，棧類似於箱子 分類：靜態棧，動態棧 演算法：出棧pop，入棧push（壓棧） 應用：函式呼叫，中斷，表示式求值，記憶體分配，

玩轉資料結構入門與進階——第一章：陣列

內容大綱： 使用Java中的陣列 二次封裝屬於我們自己的陣列 向陣列中新增元素 陣列中查詢元素和修改元素 包含，搜尋，刪除功能 使用泛型 動態陣列 簡單的時間複雜度分析 均攤複雜度和防止複雜度振盪 一、java中的陣列 把資