知道样本均值(M)和标准差(ST)时： 

置信区间下限：a=M - n*ST; 置信区间上限：a=M + n*ST;  

当求取90% 置信区间时 n=1.645  

当求取95% 置信区间时 n=1.96 

当求取99% 置信区间时 n=2.576 

n值见t分布表格

今天在LeetCode上面做了一道排序题：合并区间。该题也不算太难，先用非常暴力的方法解决了。该步骤如下：

1.初始化每一个区间的最小值min与最大值max

2.遍历所有区间，找到区间下限最小的那个，并用min，max记入。

3.删除步骤2找到的区间

4.遍历剩下的所有区间，如果该区间的最小值小于或等于步骤2中的最大值，记入该区间的最大值。

5.如果该区间的最大值大于max，那么max 就等于该最大值。

6.重复步骤4,5若干次，并在结束后删除所有符合步骤4的区间，添加【min,max】为合并后的区间

7.但剩下的区间数大于零时，重复操作上述过程
 def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        lists = []
        while (len(intervals)>0):
            min = 100000
            index = 0
            for a in range(len(intervals)):
                if min> intervals[a][0]:
                    min = intervals[a][0] 
                    max = intervals[a][1]
                    index = a 
            intervals.remove(intervals[index])
            n = 10
            while(n):
                re = []
                for a in range(len(intervals)):
                    if max >= intervals[a][0]:
                        if max <= intervals[a][1]:
                            max = intervals[a][1]
                        re.append(intervals[a])
                n -= 1
                intervals = [a for a in intervals if a not in re]
            lists.append([min,max])
        return lists
        

上述操作没有涉及的如何算法的思想，下面让我们在用另外一种操作，先按区间的最小值排好序，然后再遍历。排序后可以合并的区间是连续的，这样就省去了上面的步骤6的重复操作4,5，从而提高了程序的效率。

具体步骤就不写了，基本与上面的相似。
 def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        intervals.sort(key=lambda x: x[0])
        merges = []
        for a in intervals:
            if not merges or merges[-1][-1] < a[0]:
                merges.append(a)
            else:
                if merges[-1][-1] < a[-1]:
                    merges[-1][-1] = a[-1]
        return merges

Thank for your time !! ,
ps: 参考LeetCode官方解析。

--测试数据
DECLARE @t TABLE(ID int PRIMARY KEY,col decimal(10,2))
INSERT @t SELECT 1 ,26.21
UNION ALL SELECT 2 ,88.19
UNION ALL SELECT 3 , 4.21
UNION ALL SELECT 4 ,76.58
UNION ALL SELECT 5 ,58.06
UNION ALL SELECT 6 ,53.01
UNION ALL SELECT 7 ,18.55
UNION ALL SELECT 8 ,84.90
UNION ALL SELECT 9 ,95.60

--统计
SELECT a.Description,
	Record_count=COUNT(b.ID),
	[Percent]=CASE 
		WHEN Counts=0 THEN '0.00%'
		ELSE CAST(CAST(
			COUNT(b.ID)*100./c.Counts
			as decimal(10,2)) as varchar)+'%'
		END
FROM(
	SELECT sid=1,a=NULL,b=30  ,Description='<30' UNION ALL
	SELECT sid=2,a=30  ,b=60  ,Description='>=30 and <60' UNION ALL
	SELECT sid=3,a=60  ,b=75  ,Description='>=60 and <75' UNION ALL
	SELECT sid=4,a=75  ,b=95  ,Description='>=75 and <95' UNION ALL
	SELECT sid=5,a=95  ,b=NULL,Description='>=95' 
)a LEFT JOIN @t b 
	ON (b.col=a.a OR a.a IS NULL)
	CROSS JOIN(
		SELECT COUNTS=COUNT(*) FROM @t
	)c
GROUP BY a.Description,a.sid,c.COUNTS
ORDER BY a.sid
/*--结果:
Description    Record_count  Percent
------------------- ------------------ ---------------------- 
<30          3            33.33%
>=30 and <60  2            22.22%
>=60 and <75  0            0.00%
>=75 and <95  3            33.33%
>=95         1            11.11%
--*/

根节点区间长度为N的线段树，其层数的上下限
层数上限
记命题P(n)表示根节点区间长度从1,2,3到2^n的线段树，这些线段树的层数小于等于n+1。
1. 易知根节点区间长度为1的线段树层数为1；根节点区间长度为2的线段树层数为2；即当n=1时，P(n)成立。
2. 假设当n=k(k>=1)时，P(n)成立，证明P(n+1)成立。
3. 综合1、2两步，可知对任意自然数n>=1,命题P(n)成立。
其中第二步的证明过程如下：
对P(n+1)中的线段树按照区间长度从小到大拆成两部分，于是想要证明P(n+1)成立，只需证明后半部分线段树的层数上限小于等于n+2。
根据线段树的构造原理，对根节点作一次划分之后，其左右两棵子树的区间长度分别为：
<2^n - 2^(n-1) + 1, 2^n - 2^(n-1)    >,
<2^n - 2^(n-1) + 1, 2^n - 2^(n-1) + 1>,
...
<2^n - 1          , 2^n - 1          >,
<2^n              , 2^n - 1          >,
<2^n              , 2^n              >.
可知这些子树的根节点区间长度与层数关系满足命题P(n)。 那么加上划分之前的真正的根节点，则有根节点区间长度从1,2,3到2^(n+1)的线段树，这些线段树的层数小于等于n+2，即P(n+1)成立。
层数下限
什么时候层数会尽可能少呢？当然是每层都尽可能铺满，仅余下最后一层未铺满的情况。类似完全二叉树的样子。

当最后一层铺满时，层数为log2(N)+1

当最后一层未铺满时，？
后记
最开始的疑惑是如果N为2的整数次幂当然没有问题，很容易就划分出一棵满二叉树。当它不是整数次幂时，随着区间的划分必会出现左子树比右子树区间长度多1的情况，最后会不会导致树的层数比整数次幂大呢？