29/30, 235«‹2627282930›»

[转]数据库表地址数据（中国地区）

2008-5-30 21:32:03 软件 抢沙发(0)
阅读更多...
Sql, code

有趣的Script_标准体型自测

2008-5-19 22:37:41 算法 抢沙发(0)

最近上健康咨询网发现的一个so easy的计算公式。。。。随意的摘录下。。。。 

 

JavaScript代码
  1. var Weight=70;   
  2. var Ht=175;   
  3. var difference;   
  4. difference = (Weight)/ ((Ht) * (Ht))*10000;   
  5. alert(difference)  

20以下 低体重
20～<25 正常体重
25～<27 超重
≥27 肥胖

阅读更多...
Algorithms

深刻哀悼

2008-5-19 14:26:47 心情 抢沙发(0)

默哀

阅读更多...
My-X-Intend

激动人心的Flash Player 10 API

2008-5-17 17:11:26 开发者 抢沙发(0)
阅读更多...
Adobe-Front-End-Technology, code

[原]网络试衣间幻想曲---纸上谈兵

2008-5-14 22:08:09 软件 抢沙发(1)

由于KingFo曾经初出茅庐第一家公司就有打算做此方面的尝试，但由于本人知识浅薄加上对衣服的理解程度薄弱，所以也就做了半年后离开了，但随着时间的流逝，在脑中呈献的想法堆积的越来越多，故特别为此想法公布于众，在接下来的日子里，我会逐渐尝试任何可能的问题，不过由于目前工作的关系，故仅能浅尝辄止。

Ok，本着本域名取名来自X 加上Intend，本意是超级打算，X就是超级的意思，而Intend是指有此意图，但不一定要做，但是可以让想法共享的网络平台，目前一直希望更多的人能够加入这个队伍中来，但由于本人和本博客系统都有所缺陷，故还望各位一起来加入这个队伍。

本人对外邮箱是 oicuicu@gmail.com,希望收到路过此地，同时希望一起分享自己超级想法的伙伴和我取得联系。

 

嗯，切入正题。

 

首先，目标运行程序是Actionscript3/mxml下搭建的页面级程序，由于目前环境的种种限制，最好的方式是采用2D建制。目前7face，taobao，等多家企业/公司都已经在尝试这方面的内容了。

而2D建制最大的问题就是衣服的和人体对象的贴合程度，以及受众的接受程度。

首先关于贴合程度，如果有CAD数据那自然再好不过，可是由于CAD数据来自衣服制造商，以及目前国内大多数小规模的衣服生产厂商受环境限制基本手工绘制于布料上活着纸张上，所以是非常难以活的的数据。

另外，多数衣服的来自网络商家，故为了适用性达到最广和表现力达到最优本人所想到的方法是如下：

模型制定：
         制作和真人1：1的橡胶充气娃娃
数据采集：
         制作背景比例尺
                类似大多数电影中能看到的囚犯拍照后面的那个标度尺
               拥有标准光圈范围(含各种相机和通用相机)
         制作真人标准云台，(正\两侧\背)
基础库建设：
         标准人体3D数据(1)
                默认以上述娃娃为准
         标准UV展开图网格(2)
                方便人们将数据
         标准人体4面或6面状态图(3)
工具建设：
         绘制和上传系统
              一般用高效的C/C++编写，用来让客户将自行采集的数据编辑和上传 
             使用以上（1）和（2） ，并导存为2D以上（3）
         展示系统
              由swf文件网络中展示
              或专业版下载，让用户条件期望体型，并以3D拟真效果展示

主要构建思想：
        尽量让目前还不能高效3D运算的AS程序尽可能的去分析数据和展示2D的东西
        如果用户真想编辑，务必让用户使用绘制和上传工具
        其他虚拟真实的内容尽量采用小软件的形式

分支思想：
       如果非要让as程序在线进行操作，则需要在损失一定的真实度，让用户针对已拍摄好的对象进行类似PS的操作。

其他智能化研究：
      如研究胖矮高瘦等因素与标准体型间的关系，并建立模型
      研究身体动作与衣服间的连带关系等等
      这些。。。。囧。。。。。好高深，不过不是不可能吧~~~反正尽量让这些方放到非swf中编辑。毕竟如果作为商家不会嫌弃花费5-10分钟整理一个模型的，再说，如果协议统一，就连模型数据都可以成为商品，或者简易的外包项目咯~~（1件2块钱？）
  
OK~ 纸上谈兵就到这吧，部分数据待进行中，如果路过的您有此类相通的想法，或者更好的建议，请及时联系我哦，哈哈

困了，音乐。。。。。。。

阅读更多...
My-X-Intend, Adobe-Front-End-Technology, Experience

SQLite B+树实现代码

2008-5-13 2:10:49 开发者 抢沙发(0)

 from: http://www.sqlite.com.cn/MySqlite/6/373.Html

C++代码
  1. /* btrees.h */    
  2. /*   
  3. * 平衡多路树的一种重要方案。   
  4. * 在 1970 年由 R. Bayer 和 E. McCreight 发明。   
  5. */    
  6. #define M 1    
  7. /* B 树的阶，即非根节点中键的最小数目。   
  8. * 有些人把阶定义为非根节点中子树的最大数目。   
  9. */    
  10. typedef int typekey;    
  11. typedef struct btnode { /* B-Tree 节点 */    
  12. int d; /* 节点中键的数目 */    
  13. typekey k[2*M]; /* 键 */    
  14. char *v[2*M]; /* 值 */    
  15. struct btnode *p[2*M+1]; /* 指向子树的指针 */    
  16. } node, *btree;    
  17. /*   
  18. * 每个键的左子树中的所有的键都小于这个键，   
  19. * 每个键的右子树中的所有的键都大于等于这个键。   
  20. * 叶子节点中的每个键都没有子树。   
  21. */    
  22.   
  23. /* 当 M 等于 1 时也称为 2-3 树   
  24. * +----+----+   
  25. * | k0 | k1 |   
  26. * +-+----+----+---   
  27. * | p0 | p1 | p2 |   
  28. * +----+----+----+   
  29. */    
  30. extern int btree_disp; /* 查找时找到的键在节点中的位置 */    
  31. extern char * InsValue; /* 与要插的键相对应的值 */    
  32.   
  33. extern btree search(typekey, btree);    
  34. extern btree insert(typekey,btree);    
  35. extern btree delete(typekey,btree);    
  36. extern int height(btree);    
  37. extern int count(btree);    
  38. extern double payload(btree);    
  39. extern btree deltree(btree);    
  40. /* end of btrees.h */    
  41.   
  42. /*******************************************************/  
C++代码
  1. /*******************************************************/    
  2.   
  3. /* btrees.c */    
  4. #include    
  5. #include    
  6. #include "btrees.h"    
  7.   
  8. btree search(typekey, btree);    
  9. btree insert(typekey,btree);    
  10. btree delete(typekey,btree);    
  11. int height(btree);    
  12. int count(btree);    
  13. double payload(btree);    
  14. btree deltree(btree);    
  15.   
  16. static void InternalInsert(typekey, btree);    
  17. static void InsInNode(btree, int);    
  18. static void SplitNode(btree, int);    
  19. static btree NewRoot(btree);    
  20.   
  21. static void InternalDelete(typekey, btree);    
  22. static void JoinNode(btree, int);    
  23. static void MoveLeftNode(btree t, int);    
  24. static void MoveRightNode(btree t, int);    
  25. static void DelFromNode(btree t, int);    
  26. static btree FreeRoot(btree);    
  27.   
  28. static btree delall(btree);    
  29. static void Error(int,typekey);    
  30.   
  31. int btree_disp; /* 查找时找到的键在节点中的位置 */    
  32. char * InsValue = NULL; /* 与要插的键相对应的值 */    
  33. static int flag; /* 节点增减标志 */    
  34. static int btree_level = 0; /* 多路树的高度 */    
  35. static int btree_count = 0; /* 多路树的键总数 */    
  36. static int node_sum = 0; /* 多路树的节点总数 */    
  37. static int level; /* 当前访问的节点所处的高度 */    
  38. static btree NewTree; /* 在节点分割的时候指向新建的节点 */    
  39. static typekey InsKey; /* 要插入的键 */    
  40.   
  41. btree search(typekey key, btree t)    
  42. {    
  43. int i,j,m;    
  44. level=btree_level-1;    
  45. while (level >= 0){    
  46. for(i=0, j=t->d-1; i t->k[m])?(i=m+1):(j=m));    
  47. if (key == t->k){    
  48. btree_disp = i;    
  49. return t;    
  50. }    
  51. if (key > t->k) /* i == t->d-1 时有可能出现 */    
  52. i++;    
  53. t = t->p;    
  54. level--;    
  55. }    
  56. return NULL;    
  57. }    
  58.   
  59. btree insert(typekey key, btree t)    
  60. {    
  61. level=btree_level;    
  62. InternalInsert(key, t);    
  63. if (flag == 1) /* 根节点满之后，它被分割成两个半满节点 */    
  64. t=NewRoot(t); /* 树的高度增加 */    
  65. return t;    
  66. }    
  67.   
  68. void InternalInsert(typekey key, btree t)    
  69. {    
  70. int i,j,m;    
  71.   
  72. level--;    
  73. if (level < 0){ /* 到达了树的底部: 指出要做的插入 */    
  74. NewTree = NULL; /* 这个键没有对应的子树 */    
  75. InsKey = key; /* 导致底层的叶子节点增加键值+空子树对 */    
  76. btree_count++;    
  77. flag = 1; /* 指示上层节点把返回的键插入其中 */    
  78. return;    
  79. }    
  80. for(i=0, j=t->d-1; i t->k[m])?(i=m+1):(j=m));    
  81. if (key == t->k) {    
  82. Error(1,key); /* 键已经在树中 */    
  83. flag = 0;    
  84. return;    
  85. }    
  86. if (key > t->k) /* i == t->d-1 时有可能出现 */    
  87. i++;    
  88. InternalInsert(key, t->p);    
  89.   
  90. if (flag == 0)    
  91. return;    
  92. /* 有新键要插入到当前节点中 */    
  93. if (t->d < 2*M) {/* 当前节点未满 */    
  94. InsInNode(t, i); /* 把键值+子树对插入当前节点中 */    
  95. flag = 0; /* 指示上层节点没有需要插入的键值+子树，插入过程结束 */    
  96. }    
  97. else /* 当前节点已满，则分割这个页面并把键值+子树对插入当前节点中 */    
  98. SplitNode(t, i); /* 继续指示上层节点把返回的键值+子树插入其中 */    
  99. }    
  100.   
  101. /*   
  102. * 把一个键和对应的右子树插入一个节点中   
  103. */    
  104. void InsInNode(btree t, int d)    
  105. {    
  106. int i;    
  107. /* 把所有大于要插入的键值的键和对应的右子树右移 */    
  108. for(i = t->d; i > d; i--){    
  109. t->k = t->k[i-1];    
  110. t->v = t->v[i-1];    
  111. t->p[i+1] = t->p;    
  112. }    
  113. /* 插入键和右子树 */    
  114. t->k = InsKey;    
  115. t->p[i+1] = NewTree;    
  116. t->v = InsValue;    
  117. t->d++;    
  118. }    
  119. /*   
  120. * 前件是要插入一个键和对应的右子树，并且本节点已经满   
  121. * 导致分割这个节点，插入键和对应的右子树，   
  122. * 并向上层返回一个要插入键和对应的右子树   
  123. */    
  124. void SplitNode(btree t, int d)    
  125. {    
  126. int i,j;    
  127. btree temp;    
  128. typekey temp_k;    
  129. char *temp_v;    
  130. /* 建立新节点 */    
  131. temp = (btree)malloc(sizeof(node));    
  132. /*   
  133. * +---+--------+-----+-----+--------+-----+   
  134. * | 0 | ...... | M | M+1 | ...... |2*M-1|   
  135. * +---+--------+-----+-----+--------+-----+   
  136. * |<- M+1 ->|<- M-1 ->|   
  137. */    
  138. if (d > M) { /* 要插入当前节点的右半部分 */    
  139. /* 把从 2*M-1 到 M+1 的 M-1 个键值+子树对转移到新节点中,   
  140. * 并且为要插入的键值+子树空出位置 */    
  141. for(i=2*M-1,j=M-1; i>=d; i--,j--) {    
  142. temp->k[j] = t->k;    
  143. temp->v[j] = t->v;    
  144. temp->p[j+1] = t->p[i+1];    
  145. }    
  146. for(i=d-1,j=d-M-2; j>=0; i--,j--) {    
  147. temp->k[j] = t->k;    
  148. temp->v[j] = t->v;    
  149. temp->p[j+1] = t->p[i+1];    
  150. }    
  151. /* 把节点的最右子树转移成新节点的最左子树 */    
  152. temp->p[0] = t->p[M+1];    
  153. /* 在新节点中插入键和右子树 */    
  154. temp->k[d-M-1] = InsKey;    
  155. temp->p[d-M] = NewTree;    
  156. temp->v[d-M-1] = InsValue;    
  157. /* 设置要插入上层节点的键和值 */    
  158. InsKey = t->k[M];    
  159. InsValue = t->v[M];    
  160.   
  161. }    
  162. else { /* d <= M */    
  163. /* 把从 2*M-1 到 M 的 M 个键值+子树对转移到新节点中 */    
  164. for(i=2*M-1,j=M-1; j>=0; i--,j--) {    
  165. temp->k[j] = t->k;    
  166. temp->v[j] = t->v;    
  167. temp->p[j+1] = t->p[i+1];    
  168. }    
  169. if (d == M) /* 要插入当前节点的正中间 */    
  170. /* 把要插入的子树作为新节点的最左子树 */    
  171. temp->p[0] = NewTree;    
  172. /* 直接把要插入的键和值返回给上层节点 */    
  173. else { /* (d /* 把节点当前的最右子树转移成新节点的最左子树 */    
  174. temp->p[0] = t->p[M];    
  175. /* 保存要插入上层节点的键和值 */    
  176. temp_k = t->k[M-1];    
  177. temp_v = t->v[M-1];    
  178. /* 把所有大于要插入的键值的键和对应的右子树右移 */    
  179. for(i=M-1; i>d; i--) {    
  180. t->k = t->k[i-1];    
  181. t->v = t->v[i-1];    
  182. t->p[i+1] = t->p;    
  183. }    
  184. /* 在节点中插入键和右子树 */    
  185. t->k[d] = InsKey;    
  186. t->p[d+1] = NewTree;    
  187. t->v[d] = InsValue;    
  188. /* 设置要插入上层节点的键和值 */    
  189. InsKey = temp_k;    
  190. InsValue = temp_v;    
  191. }    
  192. }    
  193. t->d =M;    
  194. temp->d = M;    
  195. NewTree = temp;    
  196. node_sum++;    
  197. }    
  198.   
  199. btree delete(typekey key, btree t)    
  200. {    
  201. level=btree_level;    
  202. InternalDelete(key, t);    
  203. if (t->d == 0)    
  204. /* 根节点的子节点合并导致根节点键的数目随之减少，   
  205. * 当根节点中没有键的时候，只有它的最左子树可能非空 */    
  206. t=FreeRoot(t);    
  207. return t;    
  208. }    
  209.   
  210. void InternalDelete(typekey key, btree t)    
  211. {    
  212. int i,j,m;    
  213. btree l,r;    
  214. int lvl;    
  215.   
  216. level--;    
  217. if (level < 0) {    
  218. Error(0,key); /* 在整个树中未找到要删除的键 */    
  219. flag = 0;    
  220. return;    
  221. }    
  222. for(i=0, j=t->d-1; i t->k[m])?(i=m+1):(j=m));    
  223. if (key == t->k) { /* 找到要删除的键 */    
  224. if (t->v != NULL)    
  225. free(t->v); /* 释放这个节点包含的值 */    
  226. if (level == 0) { /* 有子树为空则这个键位于叶子节点 */    
  227. DelFromNode(t,i);    
  228. btree_count--;    
  229. flag = 1;    
  230. /* 指示上层节点本子树的键数量减少 */    
  231. return;    
  232. } else { /* 这个键位于非叶节点 */    
  233. lvl = level-1;    
  234. /* 找到前驱节点 */    
  235. r = t->p;    
  236. while (lvl > 0) {    
  237. r = r->p[r->d];    
  238. lvl--;    
  239. }    
  240. t->k=r->k[r->d-1];    
  241. t->v=r->v[r->d-1];    
  242. r->v[r->d-1]=NULL;    
  243. key = r->k[r->d-1];    
  244. }    
  245. }    
  246. else if (key > t->k) /* i == t->d-1 时有可能出现 */    
  247. i++;    
  248. InternalDelete(key,t->p);    
  249. /* 调整平衡 */    
  250. if (flag == 0)    
  251. return;    
  252. if (t->p->d < M) {    
  253. if (i == t->d) /* 在最右子树中发生了删除 */    
  254. i--; /* 调整最右键的左右子树平衡 */    
  255. l = t->p;    
  256. r = t->p[i+1];    
  257. if (r->d > M)    
  258. MoveLeftNode(t,i);    
  259. else if(l->d > M)    
  260. MoveRightNode(t,i);    
  261. else {    
  262. JoinNode(t,i);    
  263. /* 继续指示上层节点本子树的键数量减少 */    
  264. return;    
  265. }    
  266. flag = 0;    
  267. /* 指示上层节点本子树的键数量没有减少，删除过程结束 */    
  268. }    
  269. }    
  270.   
  271. /*   
  272. * 合并一个节点的某个键对应的两个子树   
  273. */    
  274. void JoinNode(btree t, int d)    
  275. {    
  276. btree l,r;    
  277. int i,j;    
  278. l = t->p[d];    
  279. r = t->p[d+1];    
  280.   
  281. /* 把这个键下移到它的左子树 */    
  282. l->k[l->d] = t->k[d];    
  283. l->v[l->d] = t->v[d];    
  284. /* 把右子树中的所有键值和子树转移到左子树 */    
  285. for (j=r->d-1,i=l->d+r->d; j >= 0 ; j--,i--) {    
  286. l->k = r->k[j];    
  287. l->v = r->v[j];    
  288. l->p = r->p[j];    
  289. }    
  290. l->p[l->d+r->d+1] = r->p[r->d];    
  291. l->d += r->d+1;    
  292. /* 释放右子树的节点 */    
  293. free(r);    
  294. /* 把这个键右边的键和对应的右子树左移 */    
  295. for (i=d; i < t->d-1; i++) {    
  296. t->k = t->k[i+1];    
  297. t->v = t->v[i+1];    
  298. t->p[i+1] = t->p[i+2];    
  299. }    
  300. t->d--;    
  301. node_sum--;    
  302. }    
  303. /*   
  304. * 从一个键的右子树向左子树转移一些键，使两个子树平衡   
  305. */    
  306. void MoveLeftNode(btree t, int d)    
  307. {    
  308. btree l,r;    
  309. int m; /* 应转移的键的数目 */    
  310. int i,j;    
  311. l = t->p[d];    
  312. r = t->p[d+1];    
  313. m = (r->d - l->d)/2;    
  314.   
  315. /* 把这个键下移到它的左子树 */    
  316. l->k[l->d] = t->k[d];    
  317. l->v[l->d] = t->v[d];    
  318. /* 把右子树的最左子树转移成左子树的最右子树   
  319. * 从右子树向左子树移动 m-1 个键+子树对 */    
  320. for (j=m-2,i=l->d+m-1; j >= 0; j--,i--) {    
  321. l->k = r->k[j];    
  322. l->v = r->v[j];    
  323. l->p = r->p[j];    
  324. }    
  325. l->p[l->d+m] = r->p[m-1];    
  326. /* 把右子树的最左键提升到这个键的位置上 */    
  327. t->k[d] = r->k[m-1];    
  328. t->v[d] = r->v[m-1];    
  329. /* 把右子树中的所有键值和子树左移 m 个位置 */    
  330. r->p[0] = r->p[m];    
  331. for (i=0; id-m; i++) {    
  332. r->k = r->k[i+m];    
  333. r->v = r->v[i+m];    
  334. r->p = r->p[i+m];    
  335. }    
  336. r->p[r->d-m] = r->p[r->d];    
  337. l->d+=m;    
  338. r->d-=m;    
  339. }    
  340. /*   
  341. * 从一个键的左子树向右子树转移一些键，使两个子树平衡   
  342. */    
  343. void MoveRightNode(btree t, int d)    
  344. {    
  345. btree l,r;    
  346. int m; /* 应转移的键的数目 */    
  347. int i,j;    
  348. l = t->p[d];    
  349. r = t->p[d+1];    
  350.   
  351. m = (l->d - r->d)/2;    
  352. /* 把右子树中的所有键值和子树右移 m 个位置 */    
  353. r->p[r->d+m]=r->p[r->d];    
  354. for (i=r->d-1; i>=0; i--) {    
  355. r->k[i+m] = r->k;    
  356. r->v[i+m] = r->v;    
  357. r->p[i+m] = r->p;    
  358. }    
  359. /* 把这个键下移到它的右子树 */    
  360. r->k[m-1] = t->k[d];    
  361. r->v[m-1] = t->v[d];    
  362. /* 把左子树的最右子树转移成右子树的最左子树 */    
  363. r->p[m-1] = l->p[l->d];    
  364. /* 从左子树向右子树移动 m-1 个键+子树对 */    
  365. for (i=l->d-1,j=m-2; j>=0; j--,i--) {    
  366. r->k[j] = l->k;    
  367. r->v[j] = l->v;    
  368. r->p[j] = l->p;    
  369. }    
  370. /* 把左子树的最右键提升到这个键的位置上 */    
  371. t->k[d] = l->k;    
  372. t->v[d] = l->v;    
  373. l->d-=m;    
  374. r->d+=m;    
  375. }    
  376. /*   
  377. * 把一个键和对应的右子树从一个节点中删除   
  378. */    
  379. void DelFromNode(btree t, int d)    
  380. {    
  381. int i;    
  382. /* 把所有大于要删除的键值的键左移 */    
  383. for(i=d; i < t->d-1; i++) {    
  384. t->k = t->k[i+1];    
  385. t->v = t->v[i+1];    
  386. }    
  387. t->d--;    
  388. }    
  389. /*   
  390. * 建立有两个子树和一个键的根节点   
  391. */    
  392. btree NewRoot(btree t)    
  393. {    
  394. btree temp;    
  395. temp = (btree)malloc(sizeof(node));    
  396. temp->d = 1;    
  397. temp->p[0] = t;    
  398. temp->p[1] = NewTree;    
  399. temp->k[0] = InsKey;    
  400. temp->v[0] = InsValue;    
  401. btree_level++;    
  402. node_sum++;    
  403. return(temp);    
  404. }    
  405. /*   
  406. * 释放根节点，并返回它的最左子树   
  407. */    
  408. btree FreeRoot(btree t)    
  409. {    
  410. btree temp;    
  411. temp = t->p[0];    
  412. free(t);    
  413. btree_level--;    
  414. node_sum--;    
  415. return temp;    
  416. }    
  417.   
  418. void Error(int f,typekey key)    
  419. {    
  420. if (f)    
  421. printf("Btrees error: Insert %d! ",key);    
  422. else    
  423. printf("Btrees error: delete %d! ",key);    
  424. }    
  425.   
  426. int height(btree t)    
  427. {    
  428. return btree_level;    
  429. }    
  430.   
  431. int count(btree t)    
  432. {    
  433. return btree_count;    
  434. }    
  435. double payload(btree t)    
  436. {    
  437. if (node_sum==0)    
  438. return 1;    
  439. return (double)btree_count/(node_sum*(2*M));    
  440. }    
  441. btree deltree (btree t)    
  442. {    
  443. level=btree_level;    
  444. btree_level = 0;    
  445. return delall(t);    
  446.   
  447. }    
  448. btree delall(btree t)    
  449. {    
  450. int i;    
  451. level--;    
  452. if (level >= 0) {    
  453. for (i=0; i < t->d; i++)    
  454. if (t->v != NULL)    
  455. free(t->v);    
  456. if (level > 0)    
  457. for (i=0; i<= t->d ; i++)    
  458. t->p=delall(t->p);    
  459. free(t);    
  460. }    
  461. return NULL;    
  462. }    
  463.   
  464. /* end of btrees.c */   
阅读更多...
Sql, code

B+ 树的组织结构

2008-5-13 1:59:22 软件 抢沙发(0)

  

、B+树索引的总体结构
①B+树索引是一个多级索引，但是其结构不同于多级顺序索引；
②B+树索引采用平衡树结构，即每个叶结点到根的路径长度都相同；
③每个非叶结点有到n个子女，n对特定的树是固定的；
④B+树的所有结点结构都相同，它最多包含n-1个搜索码值K1、K2、…、Kn-1，以及n个指针P1、P2、…、Pn，每个结点中的搜索码值按次序存放，即如果i<j，那么Ki<Kj，如图8-3-1所示。
图8-3-1：B+树的结点结构 
2、B+树索引的叶结点
①指针Pi(i=1,2,…,n-1)指向具有搜索码值Ki的一个文件记录或一个指针（存储）桶，桶中的每个指针指向具有搜索码值Ki的一个文件记录。指针桶只在文件不按搜索码顺序物理存储时才使用。指针Pn具有特殊的作用；
②每个叶结点最多可有n-1个搜索码值，最少也要有个搜索码值。各个叶结点中搜索码值的范围互不相交。要使B+树索引成为稠密索引，数据文件中的各搜索码值都必须出现在某个叶结点中且只能出现一次；
③由于各叶结点按照所含的搜索码值有一个线性顺序，所以就可以利用各个叶结点的指针Pn将叶结点按搜索码顺序链接在一起。这种排序能够高效地对文件进行顺序处理，而B+树索引的其他结构能够高效地对文件进行随机处理，如图8-3-2所示。
图8-3-2：B+树索引的叶结点结构示例 
3、B+树索引的非叶结点
①B+树索引的非叶结点形成叶结点上的一个多级（稀疏）索引；
②非叶结点的结构和叶结点的结构相同，即含有能够存储n-1个搜索码值和n个指针的存储单元的数据结构。只不过非叶结点中的所有指针都指向树中的结点；
③如果一个非叶结点有m个指针，则≤m≤n。若m<n，则非叶结点中指针Pm之后的所有空闲空间作为预留空间，与叶结点的区别在于结点的最后一个指针Pm和Pn的位置与指向不同，如图8-3-3所示；
图8-3-3：B+树索引的非叶结点结构 
④在一个含有m个指针的非叶结点中，指针Pi(i=2,…,m-1)指向一棵子树，该子树的所有结点的搜索码值大于等于Ki-1而小于Ki。指针Pm指向子树中所含搜索码值大于等于Km-1的那一部分，而指针P1指向子树中所含搜索码值小于K1的那一部分，如图8-3-4所示。
图8-3-4：B+树索引的非叶结点中指针Pi的指向
4、B+树索引的根结点
①根结点的结构也与叶结点相同；
②根结点包含的指针数可以小于。但是，除非整棵树只有一个结点，否则根结点必须至少包含两个指针。图8-3-5给出一个B+树结构的示意图。
图8-3-5：account关系的B+树索引结构 

 

来源：http://www.sqlite.com.cn/MySqlite/6/373.Html 

阅读更多...
Sql

SQLite的SQL语法---select

2008-5-13 1:57:03 开发者 抢沙发(0)

SELECT

sql-statement ::= SELECT [ALL | DISTINCT] result [FROM table-list]
[WHERE expr]
[GROUP BY expr-list]
[HAVING expr]
[compound-op select]*
[ORDER BY sort-expr-list]
[LIMIT integer [( OFFSET | , ) integer]]
result ::= result-column [, result-column]*
result-column ::= * | table-name . * | expr [ [AS] string ]
table-list ::= table [join-op table join-args]*
table ::= table-name [AS alias] |
( select ) [AS alias]
join-op ::= , | [NATURAL] [LEFT | RIGHT | FULL] [OUTER | INNER | CROSS] JOIN
join-args ::= [ON expr] [USING ( id-list )]
sort-expr-list ::= expr [sort-order] [, expr [sort-order]]*
sort-order ::= [ COLLATE collation-name ] [ ASC | DESC ]
compound_op ::= UNION | UNION ALL | INTERSECT | EXCEPT
阅读更多...
Sql
29/30, 235«‹2627282930›»
系统公告
Blog具有长期的置顶项，欢迎同学使用RSS订阅本Blog，便于在第一时间获知最新文章。
文章分类
搜索
随机文章
最新评论
标签云集
My-X-Intend Front-End-Technology Experience Adobe-Front-End-Technology code Sql Rules Algorithms Settings Web-Technology
站点数据
文章数量: 235 篇
评论数量: 47 条
标签数量: 19 个
引用通告: 1 条
总访问数: 544308 次
友情链接

Powered by Roclog v5.0.2

Copyright © 2009-2010 X-Intend. All rights reserved.

浙ICP备09082105号