节点排序 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 < n; i++){
              ap = a[i],bp = b[i]
              if(ap !== bp){
                while(ap = ap.nextSibling){
                  if(ap === bp){
                    return -1
                  }
                }
                return 1
              }
            }
            return a.length-b.length;
     },
    uniqueSort : function(nodes){
        var length = nodes.length;
        var LCA = Rage.getLCA(nodes);
        var lists = Rage.getLists(nodes,LCA);
        lists.sort(Rage.sortList);
        var list, i = 0, result = [];
        while(list = lists[i++]){
            result[result.length] list.pop();
        }
        if(result.length !== length){
            result.unshift(LAC);
            if(result.length != length){
                hasDuplicate = true;
            }
        }
        return result;
    }
}

下面是第二版，经过改进，终于比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 < n; i++){
      ap = a[i],bp = b[i]
      if(ap !== bp){
        while(ap = ap.nextSibling){
          if(ap === bp){
            return -1
          }
        }
        return 1
      }
    }
    return a.length-b.length;
  },
  uniqueSort : function(nodes){
    var length = nodes.length;
    var lists = Rage.getLists(nodes);
    lists.sort(function(a,b){
      return a.length - b.length;
    });
    var depth = lists[0].length, length = lists.length, parent, cut, ii = 0;
    for(var i =0; i < depth; i++){
      parent = lists[0][i];
      cut = true;
      for(var j = 1;j <  length; j++){
        if(parent !== lists[j][i]){
          cut = false;
          break;
        }
      }
      if(cut){
        ii++
      }else{
        break;
      }
    }
    var LCA = lists[0][ii-1];
    lists = Rage.sliceList(lists,ii);
    lists.sort(Rage.sortList);
    var list, i = 0, result = [];
    while(list = lists[i++]){
      result[result.length] = list.pop();
    }
      
    if(result.length !== length){
      result.unshift(LCA);
      if(result.length != length){
        hasDuplicate = true;
      }
    }
    return result;
  }
}