划分树详解——求解整数区间内第K大的值——python3实现
本文题目与代码参考来自程序设计解题策略。
题目重述
题目重述：给定一个数组num = [1,5,2,3,6,4,7,3,0,0]，求出在索引[x,y]之间第K大的值。
比如，求[1,3]中第2大的值。索引[1,3]对应的子数组为[5,2,3]，第2大的值，也是将[5,2,3]排序，排序后为[2,3,5],那么[2,3,5]排第二的值为3，所以这里返回3.
注意：第K大的值，其实是指排序后，第k个值。k为>=1的整数，且k不能超过[1,3]的长度，因为超过就没有意义了。
划分树原理
划分树是一种基于线段树的数据结构，建议可以先了解一下线段树，便于理解本文。基本思想为：将待查找区间划分为两个子区间。不大于数列中间值的元素被分配到左孩子的子区间，简称左子区间；大于数列中间值的元素被分配到右儿子的子区间，简称右子区间。
有以下成立：
- 左子区间的数<=右子区间的数
- 建树时，需保证分到同一子节点的元素之间的相对顺序不变
- 数列含n个整数，对应划分树为
层
例如，题目的整数序列排序后得到[ 0 0 1 2 3 4 5 6 7 ]，中间值为3.划分出下一层的左子区间[ 1 2 3 0 0 ]，中间值为1；下一层的右子区间为[ 5 6 4 7 3 ]，中间值为5；以此类推，直到划分出的所有子区间含单个整数为止。
查找：通过记录下来进入左子区间的数的个数，确定下一个查找的子区间，直到查找范围缩小到单元素区间为止。此时，[x,y]之间第K大的值就被找到了。
划分树介绍
题目数组为[1,5,2,3,6,4,7,3,0,0]，对应划分树结构如下：
第一步是建树，过程如下：
首先是通过对原数列排序找到这个区间的中间位置的值mid（mid=(left+right)/2，mid指索引，而中间值指索引为mid的那个数），不大于中间值的数划入左子区间[left,mid]，大于中间值的数划入右子区间[mid+1,right]。同时，对于第i个数（i是索引，从0开始哦），记录在[left,i]区间内有多少数被划入左子区间。
然后继续对它的左子区间[left,mid]和右子区间[mid+1,right]递归建树，直到划分出最后一层的叶子节点为止。
划分树实际存储
实际划分树是由两个二维数组来存储的。
tree[dep][i]——树中第dep层中第i位置的数
toleft[dep][i]——代表第dep层中，从0位置到i位置有多少个数分入下一层的左子区间。
说了这么多，你可能还是不知道，到底划分树是怎么用的，看如下例子。
划分树结构：
tree二维数组：
toleft二维数组：
根据题目给的num数组，tree和toleft的实际存储如上。具体分析如下：
1.划分树：
以第0层为例，带方框的数代表这个数到达第1层是被划分到左子区间，不带方框则划分到右子区间。
2.tree二维数组：
- 每一行是一个一维数组，而且tree[0]代表的就是第0层的数，而且顺序一样
- 每个一维数组的长度是num的长度
- 树是0-4层，所以tree也是从tree[0]到tree[4]
- 树中最后一层只存了4个数，所以另外6个位置没有用，浪费了，但不得不浪费。False代表该位置没有存数
3.toleft二维数组：
- 每一行是一个一维数组，每个一维数组的长度是num的长度
- toleft[0][i]代表的是tree[0][0]到tree[0][i]中，有几个数会被划分到下一层的左子区间
- 第0层为例，从tree[0][0]到tree[0][0]有tree[0][0]即1这一个数被划分到了左子区间，所以toleft[0][0]为1
- 从tree[0][0]到tree[0][1]只有tree[0][0]即1这一个数被划分到了左子区间，所以toleft[0][1]为1
- 从tree[0][0]到tree[0][2]有tree[0][0]即1、tree[0][2]即2这两个数被划分到了左子区间，所以toleft[0][2]为2
- toleft[dep][i]的值是从树中每个节点开始算的，比如看toleft[1]是[1, 1, 1, 2, 3, 1, 1, 2, 2, 3]，是因为树中，第1层中是两个节点，每个节点各五个数，所以前5个算完，又得从新算有多少个数被划分进左子区间
- 如果层中有的数已经是叶子节点，那么就不存，即存False来代表没有实际意义
- 树有5层，但toleft只有4层，因为最后一层全是叶子节点，全存False那还不如不存了
私认为一篇讲解划分树的博客，如果不给出tree和toleft二维数组的实际存储，那都是在耍流氓==。
划分树查找原理
L=0，R=len(num)-1。即为最小和最大索引。
给定L<=left，right<=R，考虑一般情况，即left和right不在最小最大索引（为了方便理解分析），那么现在整个区间被分了三个区间：
[L,left-1],[left,right],[right+1,R]。分别称为靠左区间，查询区间，靠右区间。这三个区间合起来就是第0层，以[某区间].left代表分到左子区间的数的序列，[某区间].right代表分到右子区间的数的序列。
那么第1层的左子区间肯定是由[L,left-1].left [left,right].left [right+1,R].left依次组成的。
第1层的右子区间肯定是由[L,left-1].right [left,right].right [right+1,R].right依次组成的。
理解上面这几段话非常重要！
分析：
- [L,R].left=[L,left-1].left + [left,right].left + [right+1,R].left
- [L,R]分到左子区间的数，肯定是[L,R]拆分成的小区间分到左子区间的数合起来
- 因为划分树保证了从区间划分到子区间时，保持子区间内相对顺序不变，所以上面说是依次组成
实际例子1：递归到左
L=0，R=9，left=1，right=3，k=2
寻找[1,3]区间中，大小排序第2的数？该区间为[5,2,3]，第2大的数为3，这里我们最终就会找到3。
首先分析第一层，[0,9]被[1,3]分成了三个小区间，[0,0] [1,3] [4,9]，靠左区间分到左子区间的数的个数为1，查询区间分到左子区间的数的个数为2，靠右区间这里不用分析。
既然查询区间分到左子区间的数的个数cnt为2，k为2（k即想找到的第几个数），有k<=cnt，那么这第k个数肯定被分到左子区间了，实际情况也为如此，[1,3]区间代表的[5,2,3]中的[2,3]被分到左子区间，而[5]被分到右子区间。
接下来要分析到第二层（递归到左），但之前要提供新的L，R，left，right（新的left，right即为[1,3].left的最小最大索引）。
因为到左子区间，L不变，R=(L+R)/2 。
因为左子区间是由[0,0].left [1,3].left [4,9].left依次组成的，已经知道[0,0].left的长度为1（上上段已说），且它们三是依次组成，所以新的left是新的L+1即0+1=1。
而新的[left,right]的长度即为cnt，因为想找的数不是在[1,3].left就是在[1,3].right里，现已知这个数分到左子区间的一部分[1,3].left里，那就分析这一部分就行了，[1,3].left的长度为2，那么想找的数肯定就在这两个数里。所以新的right是新的left+cnt-1即1+2-1=2。
所以，新的L，R，left，right分别为0，4，1，2。实际情况也为如此，到了第1层的左子区间，只需要分析[1,2]区间即[2,3]就可以在之后找到想找的数。之后以此类推。递归调用参数表如下：
| dep | L | R | left | right | k |
|---|---|---|---|---|---|
| 0 | 0 | 9 | 1 | 3 | 2 |
| 1 | 0 | 4 | 1 | 2 | 2 |
| 2 | 3 | 4 | 3 | 4 | 2 |
| 3 | 4 | 4 | 4 | 4 | 1 |
递归到left==right时，找到第k大的值tree[dep][left]
实际例子2：递归到右
L=0，R=9，left=3，right=5，k=2
寻找[3,5]区间中，大小排序第2的数？该区间为[3,6,4]，第2大的数为4，这里我们最终就会找到4。
递归到右，还得提供新的k。
- 首先分析第0层，[0,9]被[3,5]分成了三个小区间，[0,2] [3,5] [6,9]，靠左区间分到左子区间的数的个数为2，查询区间分到左子区间的数的个数cnt为1，靠右区间这里不用分析。
- 有k>cnt，那么这第k个数肯定被分到右子区间了。
- 右子区间是由[0,2].right [3,5].right [6,9].right依次组成。
- 要分析到第1层，需提供新的L，R，left，right.
- 因为分到右子区间，所以R不变，L=(L+R)/2 。
新的left和right即为[3,5].right的最小最大索引。 - 查询区间分到右子区间的数的个数cnt为2，靠右区间分到右子区间的数的个数cnt为2。
- 那么从右边排除掉靠右区间分到右子区间的数的个数ant，便是新的right=新的R-ant。（注意ant指的是本段中的ant）
- 查询区间分到右子区间的数的个数cnt为2，即要分析的数就在这2个数里，所以新的left=新的right-cnt+1。（注意ant指的是本段中的ant）之后以此类推。
- 总之，[3,5]中有(5-3+1)-cnt个数被划分到了右子区间，cnt指[3,5]分到左子区间的数的个数（即查询区间.left），cnt为1，本来是要找第2大的数，但是已经有了cnt个即1个数分到左子区间，这分过去的数肯定是[3,5]中较小的数，所以想要找的数的排名就提前了cnt即1，所以新的k为k-cnt
递归调用参数表如下：
| dep | L | R | left | right | k |
|---|---|---|---|---|---|
| 0 | 0 | 9 | 3 | 5 | 2 |
| 1 | 5 | 9 | 6 | 7 | 1 |
| 2 | 5 | 7 | 6 | 6 | 1 |
递归到left==right时，找到第k大的值tree[dep][left]
重要规律：递归调用参数表中，tree树中的dep层中的[left,right]就是我们要分析的范围，发现这个范围在递归的过程中，要么范围不变，要么范围变小，直到变小到[left,right]的长度为1时，便到达递归终点，tree[dep][left]即为想找的第k大值。
划分树——建树
建树的代码，实际上就是根据num数组，返回tree二维数组和toleft二维数组。程序是递归的过程，过程和划分树结构图片一样。
- tree[dep][i]——树中第dep层中第i位置的数
- sort_mid——中间变量，代表当前递归参数left，right为[left,right]时，将[left,right]区间内的数排序后的中间位置的值
- toleft[dep][i]——代表第dep层中，从0位置到i位置有多少个数分入下一层的左子区间。
- lpos和rpos——下一层左子区间和右子区间的开始指针（最小索引）
- same——因为等于sort_mid的数可能有多个，但可能是左边分到左子区间，右边的分到右子区间，这里是记录左边分到左子区间的个数
- count——记录当前节点下，位置left到位置i中有多少分到左子区间
num = [1,5,2,3,6,4,7,3,0,0]#条件
tree = []#二维列表，作为返回值
sort = []#中间变量，是每一个节点的内的元素的排序
toleft = []#二维列表，作为返回值
def build(left,right,dep):
if(left==right):#递归终点
return
if(dep==0):#第一次递归
tree.append(num)
toleft.append([False]*len(num))
else:#不是第一次，当前层的tree不用建了，但toleft得建
if(len(toleft)==(dep)):
toleft.append([False]*len(num))
sort = tree[dep][left:right+1]
sort.sort()#此处可能还能优化
temp_mid = (len(sort)-1)//2
sort_mid = sort[temp_mid]
mid = (left+right)//2
same = mid-left+1#现在是左子区间的长度
for i in range(left,right+1):
if(tree[dep][i] < sort_mid):
same-=1#执行完此循环，便得到左子区间中，sort[mid]的个数
lpos = left
rpos = mid+1
count = 0
#接下来要为下一层建树，但tree[dep+1]这个list还没有建立，需要每次建立
if(len(tree)==(dep+1)):
tree.append([False]*len(num))
for i in range(left,right+1):#tree的i，索引从0开始
if(tree[dep][i] < sort_mid):
tree[dep+1][lpos]=tree[dep][i]
lpos+=1
count+=1
elif( (tree[dep][i] == sort_mid) and (same > 0) ):
tree[dep+1][lpos]=tree[dep][i]
lpos+=1
same-=1
count+=1
else:
tree[dep+1][rpos]=tree[dep][i]
rpos+=1
#上面每次把一个数加入到子区间内
toleft[dep][i] = count
build(left,mid,dep+1)
build(mid+1,right,dep+1)
build(0,len(num)-1,0)
for i in tree:
print(i)
print()
for i in toleft:
print(i) 划分树——查询
def get_ant(toleft,L,R,left,right):
#L>=left right<=R，这是已经成立的
interval_left = 0#在[L,left-1]中进入到左子区间的数的个数
interval_current = 0
if(L<left):#此时在[left,right]的左边，会有一个左边区间
interval_left = toleft[left-1]
elif(L==left):#此时在[left,right]的左边，根本没有左边区间
interval_left = 0
interval_current = toleft[right]
return (interval_current - interval_left,interval_left)
#返回元祖，0元素为查询区间分到左子区间的数的个数
#1元素为靠左区间分到左子区间的数的个数
#第二个值，当接下来递归到左子区间时，能用上
def query(L,R,left,right,dep,k):
if(left==right):
print( dep,L,R,left,right)
return tree[dep][left]
print( dep,L,R,left,right)
mid = (L+R)//2
cnt = get_ant(toleft[dep],L,R,left,right)
#newl,newr是接下来要分析的left,right
if(cnt[0]>=k):
newl=L+cnt[1]
newr=newl+cnt[0]-1
return query(L,mid,newl,newr,dep+1,k)
else:
offset = (R-right) - (toleft[dep][R] - toleft[dep][right])
newr = R - offset
temp = (right-left+1)-cnt[0]
newl = newr - temp + 1
return query(mid+1,R,newl,newr,dep+1,k-cnt[0])
#print(query(0,len(num)-1,1,3,0,2))
#print(query(0,len(num)-1,3,5,0,2))
#print(query(0,len(num)-1,1,5,0,2))
#print(query(0,len(num)-1,4,7,0,2))
#print(query(0,len(num)-1,0,9,0,2))
#print(query(0,len(num)-1,0,4,0,2))
print(query(0,len(num)-1,3,5,0,2))测试用例可能不全，请读者自行新增测试用例。
