要列出在給定時間內與區間 i 重疊的所有區間，我們可以使用區間樹資料結構。 區間樹是用於儲存區間的樹狀資料結構，它使我們能夠有效地查詢與給定區間重疊的所有區間。
在這裡，我將描述一種不對樹進行更改的方法。 此方法基於按區間的起點對區間樹中的節點進行排序，並將最大的端點儲存在其子節點的每個節點中。 這樣，在遍歷樹時，我們可以根據節點的最大端點和查詢間隔的起點來確定是否需要進一步探索子樹。
下面是如何使用 go 實現該方法的示例：
type interval struct type intervaltreenode struct 構造間隔樹的功能（這裡省略具體實現） func buildintervaltree（intervals interval） *intervaltreenode func queryoverlappingintervals（root * intervaltreenode， query interval） [interval if query.start <= node.interval.end 根據子節點的最大端點和 IF 節點的查詢間隔的起始點確定遍歷順序left != nil &&node.left.maxend >= query.start if node.right != nil &&node.right.maxend >= query.start }dfs(root) return result }queryoverlappingintervals 函式採用間隔樹的根節點和查詢間隔，並返回與查詢間隔重疊的所有間隔。 它使用深度優先搜尋 （DFS） 遍歷樹，並根據節點的最大端點和查詢間隔的起點確定是否需要進一步探索子樹。 在遍歷過程中，它還會將找到的重疊間隔新增到結果列表中。
請注意，此方法不會修改樹，因此可以在多個查詢中重用相同的間隔樹。 至於時間複雜度要求 o（min（n， klgn）），其中 n 是區間樹中的節點數，k 是輸出的區間數，lgn 是以 n 為底的對數。 由於我們只對每個節點執行固定數量的操作，並且只遍歷與查詢間隔重疊的節點，因此演算法的時間複雜度可以近似為 o（k + lgn），其中 k 是輸出結果的數量。 但請注意，此近似值並不嚴格等於 o（min（n， klgn）），因為實際時間複雜度取決於查詢間隔與樹的重疊程度。 然而，這種方法在實踐中通常表現出良好的效能。
在此處插入說明。
在此處插入說明。
在此處插入說明。
在 GO 中，我們可以使用 Depth-First Search （DFS） 來解決這個問題。 我們從根節點開始，如果當前節點的間隔與給定的間隔重疊，我們將當前節點的間隔新增到結果列表中。 然後，我們分別對左子樹和右子樹執行相同的操作。 通過這種方式，我們可以找到所有與給定區間重疊的區間，單位為 o（min（n， klgn）） 時間。
以下是實現此演算法的方法：
package mainimport ( "fmt")type interval struct type node struct func newnode(i interval) *node }func overlapsearch(root *node, i interval, result *[interval) if root.interval.low <= i.high &&root.interval.high >= i.low if root.left != nil &&root.left.interval.high >= i.low if root.right != nil &&root.right.interval.low <= i.high }func main() var root *node for _,interval := range intervals i := interval var result interval overlapsearch(root, i, &result) for _,interval := range result }
在此處插入說明。
在此處插入說明。
在此處插入說明。
以下是 go 語言實現的演算法，用於列出給定區間樹 t 中以 o（min（n， k*lg（n））） 時間中與區間 i 重疊的所有區間：
型別 IntervalTreeNode struct func findOverlappingIntervals（T *IntervalTreeNode， i int） [IntervalTreeNode 查詢左子樹左結果 ：= FindOverlappingIntervals（t..]leftchild， i） 查詢右子樹 rightresult ：= findoverlappingintervals（t右柴爾德，我）如果當前節點的間隔與查詢間隔相交，如果 tmax >= i 返回合併的左右子樹的結果列表 return append（append（result， leftresult....）rightresult...
在此處插入說明。
在 GO 中，處理區間樹重疊的方法主要有兩種：
修改間隔樹：通過一系列查詢操作修改區間樹，每次查詢可以**或合併區間，直到找到所有區間重疊的區間i。 該方法的典型時間複雜度為 o（min（n， k * log n）），其中 n 是區間樹中的區間總數，k 是要輸出的重疊區間數。
未修改間隔樹：列出通過遍歷或一系列查詢操作與區間 i 重疊的所有區間，而不修改區間樹。 如果同時構建了間隔樹並且查詢操作速度很快，則此方法的時間複雜度可能接近 o（n）。
下面提供了基於修改區間樹的方法的簡化示例。 需要注意的是，在實踐中，區間樹的具體實現可能比較複雜，可能會有各種優化來適應不同的情況。
package mainimport ( "fmt"interval 表示間隔型別 interval struct intervaltreenode 表示間隔樹型別的節點 intervaltreenode struct intervaltree 表示間隔樹型別 intervaltree struct update 更新間隔樹中間隔的資訊，並返回與新間隔重疊的間隔列表 i func （t * intervaltree） update（i interval） （interval， *intervaltreenode） updatehelper 是 update func 的幫助函式 （t *intervaltree） updatehelper（node *intervaltreenode， i interval， overlaps *[interval， modified *intervaltreenode） 當前節點間隔與 i 重疊，重疊間隔列表首先新增到重疊節點列表中start <= i.start &&i.end <= node.end ） 標記當前節點，需要更新子樹節點lazy++ 如果當前節點有 lazy 標籤，則處理 lazy 標籤 if nodelazy > 0 if node.right != nil node.lazy = 0 } 遞迴處理左右子樹 tupdatehelper(node.left, i, overlaps, modified) if modified == nil ||node.start < modified.start &&node.end > modified.end) t.updatehelper(node.right, i, overlaps, modified)}func main() // ..在這裡，您可以向樹新增更多間隔 假設現在要更新的間隔是 [2， 4] i ：= 間隔重疊，修改後 ：= 樹update(i) fmt.println("重疊間隔："， overlaps） 輸出可能包含 [1， 5]，因為 [2， 4] 與根節點表示的區間 [1， 5]} 重疊如果你不需要。
在此處插入說明。
在此處插入說明。
在此處插入說明。
為了列出在o（min（n， k log n））的時間段中區間樹t中與區間i重疊的所有區間，可以使用“區間**”策略結合中階遍歷方法來解決該問題。 以下是這兩種方法的簡要說明：
方法一：不要修改樹結構該方法利用區間樹的性質，在o（log n）的時間複雜度內找到與區間i重疊的第乙個節點，然後沿著中間遍歷路徑向下遍歷，直到不再有重疊區間。 重複此過程，每次從最後乙個結束位置搜尋下乙個重疊間隔，總共 k 次。
var 結果 intervalvar currentnode *節點查詢並收集 k > 0 的重疊間隔 向下遍歷以收集重疊間隔 collectoverlappingintervals（currentnode， &results， i） 移動到下乙個可能的重疊節點 currentnode = getNextOverlapNode（ currentNode， i） k--}返回結果方法二：修改樹結構（間隔**）。此方法更有效，但需要對樹進行修改。 首先，將間隔 i 作為新節點插入到間隔樹中，該節點將在 o（log n） 時間內完成。 然後進行中階遍歷，如果遍歷過程中遇到的區間與 i 重合，則將其新增到結果集中，並將區間 ** 分成兩部分（與 i 不重疊的部分和與 i 重疊的部分），將與 i 不重疊的部分重新插入到區間樹中。 這樣，後續遍歷就不會重新訪問已處理的重疊間隔。
func splitandcollectintersections(root *node, i interval, results *[interval) splitandcollectintersections(root.left, i, results) if root.interval.overlaps（i） insertintotree（root， newnode） 實現 o（log n） 複雜度 } splitandcollectintersections（root.right, i, results)}func splitinterval(interval interval, target interval) *interval func insertintotree(parent *node, newnode *node)在此處插入說明。
在此處插入說明。
在此處插入說明。
在 GO 中，您可以使用間隔樹（也稱為線樹）來處理此問題。 區間樹是乙個二叉搜尋樹，其中每個節點代表乙個特定的區間。 在這種情況下，我們可以使用陣列來表示樹，陣列的每個元素都對應乙個節點。
我們可以使用兩種型別的查詢：
1.查詢與給定間隔 i 重疊的節點。 這可以通過從根開始，遞迴檢查子節點的間隔是否與 i 相交來完成。 如果它相交，我們遞迴檢查該子節點。 2.查詢包含給定間隔的節點。 這可以通過從根開始，遞迴檢查子節點的間隔是否包含給定的區間來完成。 如果是這樣，我們將遞迴檢查該子節點。 兩個查詢的時間複雜度均為 o（logn）。 因此，如果我們進行 k 個查詢，則總時間複雜度為 o（klogn）。
對於第一種方法，我們在每次查詢後修改樹的結構。 這意味著，如果我們有 k 個查詢，我們需要修改樹 k 次。 這可能會導致效能問題，因為修改樹的操作可能需要大量時間。
對於第二種方法，我們不需要修改樹。 我們只需要在樹中進行查詢。 這將查詢時間複雜度降低到 o（logn），將總時間複雜度降低到 o（klogn）。
下面是 Go 實現的示例**：
type intervaltree struct type intervaltreenode struct func (it *intervaltree) insert(interval interval) func (it *intervaltree) query(low, high int) [interval func (it *intervaltree) query(node *intervaltreenode, low, high, result *[interval) if low <= node.low if node.high <= high }在此處插入說明。
在此處插入說明。
列出給定區間樹 t 中與區間 i 重疊的所有區間，時間複雜度為 o（min（n， k log n）），其中 k 是輸出的區間數。 有兩種方法可以做到這一點。 1.遍歷間隔樹 t 的節點，對於每個節點，檢查其間隔是否與給定間隔 i 重疊。 2.如果節點的間隔與給定的間隔 i 重疊，則該間隔將新增到結果列表中。 3.接下來，根據節點的左子樹和右子樹如何與給定的間隔 i 重疊，對左子樹和右子樹遞迴執行上述操作。 4.重複步驟 1-3，直到遍歷整個間隔樹 t。 5.返回結果列表。 該方法的時間複雜度為 o（min（n， k log n）），其中 n 是區間樹 t 的節點數。 這是因為每個節點都需要檢查與間隔 i 的重疊，並且遞迴過程的最大深度為 log n，因此時間複雜度為 o（min（n， k log n））。
方法二：不要修改樹結構。
1.定義乙個函式 query（node， interval），用於查詢與指定節點下的 interval 重疊的間隔。 2.如果當前節點不存在或當前節點的間隔與給定的間隔間隔不重疊，則返回空列表。 3.如果當前節點的區間完全包含在給定的時間間隔內，則當前節點的區間將新增到結果列表中。 4.否則，以遞迴方式呼叫查詢函式，在當前節點的左右子樹中分別執行查詢操作，並將結果合併到結果列表中。 5.在 main 函式中，呼叫 query（root， i），其中 root 是區間樹 t 的根節點，i 是給定的區間。 6.返回結果列表。 此方法通過遞迴查詢間隔樹的節點，並僅選擇與給定間隔重疊的子樹進行查詢，從而減少不必要的遍歷。 時間複雜度為 o（min（n， k log n）），其中 n 是區間樹 t 中的節點數。
在此處插入說明。
對於區間樹 t 和區間 i，所有與 t 中 i 重疊的區間都應以 o（min（n， klogn）） 時間列出，其中 k 是輸出的區間數。 有兩種方法可以實現這一點。
方法一：查詢並修改樹。
1.對於每個節點 v，在 v 節點上維護乙個集合 s v，將所有與 i 相交的交集儲存在與 v 對應的子樹中。 2.從根 sv 開始遞迴構建這些集合。 如果當前節點 v 表示的區間不與 i 相交，則 s v 為空集。 否則，將遞迴計算左側和右側子樹上的集合，並將結果合併到 sv 中。 3.最後，在遍歷整個樹的同時，檢查儲存在每個節點 v 中的區間是否與 i 相交，並輸出相交區間。 該方法在查詢操作過程中修改了樹結構，但可以保證時間複雜度為 o（min（n， klogn））。
方法二：不要修改樹結構。
1.遍歷整個間隔樹 t，從根節點開始。 2.對於每個節點 v，如果當前節點所表示的區間不與 i 相交，則無需繼續向下搜尋該分支。 3.如果當前節點所代表的區間與i相交，則需要進一步判斷：如果是葉節點，則直接輸出當前區間; 如果它不是葉節點，則遞迴遍歷左右子樹，找到與 i 相交的區間，然後輸出。 4.在遍歷整個樹的過程中，只需要訪問與 i 相交的部分，而無需修改樹結構。 該方法不修改樹結構，但也可以保證時間複雜度為o（min（n， klogn））。
以上是列出 t 中所有與 i 重疊的區間的兩種方法，並選擇其中乙個適合您的方案。
在此處插入說明。
在 Go 中，要列出區間樹 t 中與區間 i 在 o（min（n， klgn）） 時間內重疊的所有區間，我們可以做兩件事：
此方法涉及對樹的多個查詢操作，每個查詢操作都會修改樹的結構。 在每次查詢中，我們可以選擇乙個特定的點，使查詢間隔盡可能小，從而減少查詢次數。 這種方法的關鍵是如何選擇正確的查詢點。
func listoverlappingintervals（root *intervalnode， i [2]int） [intervalnode，如果當前節點的間隔與給定的間隔 i 重疊，則結果集 if node.]interval[0] <= i[1] &node.interval[1] >= i[0] 遞迴搜尋左右子樹 leftoverlap ：= search（node.left, i) rightoverlap := search(node.對，我）如果左子樹和右子樹之間存在重疊，則返回 true if leftoverlap &&& 如果左子樹有重疊，則嘗試在右子樹中搜尋較小的間隔，如果 leftoverlap 如果右子樹有重疊，則嘗試在左子樹中搜尋較小的間隔，如果 rightoverlap 返回 false } 從根節點搜尋 search（root， i） 返回結果}func listoverlappingintervals（root *intervalnode， i [2]int） [intervalnode，如果當前節點的間隔與給定的間隔 i 重疊，則結果集 if node.]interval[0] <= i[1] &node.interval[1] >= i[0] 遞迴搜尋左右子樹 search（node.left, i, stack) search(node.right， i， stack） 回溯，從堆疊中刪除當前節點 *stack = （*stack）[：len（*stack）-1] } 從根節點搜尋 search（root， i， &stack） 將堆疊中的節點轉換為結果集 ， node ：= range stack return result}在此處插入說明。
在此處插入說明。
在此處插入說明。
以下是用 Go 語言實現的演算法，它列出了以 o（min（n， klogn）） 時間為單位與給定區間 i 重疊的區間。 此演算法不修改樹，而是使用幫助程式函式遍歷樹並收集重疊間隔。
package mainimport "fmt"type interval struct type node struct func newnode(interval interval) *node }func collectoverlappingintervals(root *node, i interval, result *[node) if i.start< current.interval.start else }func listoverlappingintervals(root *node, i interval) [node func main() root.left = newnode(interval) root.right = newnode(interval) i := interval overlappingintervals := listoverlappingintervals(root, i) for _,interval := range overlappingintervals }在此處插入說明。
在此處插入說明。