节点排序 2

对支持sourceIndex的HTML文档的节点重排，使用JK提供的思路，速度至少比单纯使用nodes.sort(function(a,b){return a.sourceIndex - b.sourceIndex})这种方式快两倍：

//灵感来自
//http://www.cnblogs.com/jkisjk/archive/2011/01/28/array_quickly_sortby.html
        var hasDuplicate = false;
        var sortBy = function(nodes){
          var result = [], array = [], n = nodes.length, i = n, node;
          while(node = nodes[--n]){
            (array[n] = new Number(~~node.sourceIndex))._ = node;
          }
          array.sort(function(a,b){
            if(a === b) hasDuplicate = true;
            return a - b ;
          });
          while( i )
            result[--i] = array[i]._;
          return result;
        }

但标准浏览器不支持这属性，在IE中，XML文档也没有此属性，这时就需要跟据节点的parentNode与nextSibling，但如果单单是两两比较，速度是提升不了的。因此我们就转而比较最近公共祖先的孩子们的顺序了。这时，算法的威力就体现出来了。这是第一版，根据某一朋友提供的LCA搞出来的东西，当然大体思路还是归功于JK大神。但实际效果不如意，比jQuery的那个sortOrder慢，估计问题出在求LCA上。

//根据这里JK提供的思路
//http://www.cnblogs.com/rubylouvre/archive/2011/01/28/1947286.html#2020900
var tick = 0, hasDuplicate = false;
var Rage = {
//form http://www.cnblogs.com/GrayZhang/archive/2010/12/29/find-closest-common-parent.html
	getLCA:function(nodes){
		var hash = {}, i = 0,
			attr = "data-find"+(++tick),
			length = nodes.length,
			node,
			parent,
			counter = 0,
			uuid;
		while(node = nodes[i++]){
			parent = node;
			while(parent){
				if(parent.nodeType === 1){
					break;
				}
				uuid = parent.getAttribute(attr);
				if(!uuid){
					uuid = "_" + (++counter);
					parent.setAttribute(attr,uuid);
					hash[uuid] = {node:parent,count:1};
				}else{
					hash[uuid].count ++;
				}
				parent = parent.parentNode;
			}
		}
		for(var i in hash){
			if(hash[i].count === length){
				return hash[i].node;
			}
		}
	},
	getList : function(nodes,parent){//获取当前元素到最近公共祖先间的所有祖先，包括自己
		var list = [];
		while(node){
			if(node === parent){
				break;
			}
			list.unshift(node);
			node = node.parentNode;
		}
		return list;
	},
	getLists : function(){
		var lists = [], getList = Rage.getList, i=0, node, list;
		while(node = nodes[i++]){
			list = getList(node,parent);
			if(list.length){
				lists[ lists.length ] = list;
		    }
		}
		return lists;
	},
         sortList : function(a,b){
            var n = Math.min(a.length,b.length),ap,bp;
            for(var i=0; i 
下面是第二版，经过改进，终于比jQuery的那个快上三倍（测试对象为拥有260多个节点的文档）
        var hasDuplicate = false;
        var Rage = {

          getList : function(node){
            var list = [];
            while(node){
              if(node.nodeType === 9){
                break;
              }
              list.unshift(node);
              node = node.parentNode;
            }
            return list;
          },
          getLists : function(nodes){
            var lists = [], getList = Rage.getList, i=0, node;
            while(node = nodes[i++]){
              lists[ lists.length ] = getList(node);
            }
            return lists;
          },
          sliceList : function(lists,num){
            var result = [], i = 0, list;
            while(list = lists[i++]){
              list = list.slice(num);
              if(list.length){
                result[ result.length ] = list;
              }
            }
            return result;
          },
          sortList : function(a,b){
            var n = Math.min(a.length,b.length),ap,bp;
            for(var i=0; i