使用js，左依赖合并单元格

 

合并的效果图

 

代码：

 

 

	render: function(){
		/**
		 * landmark = y ,diffs = x
		 */
		var iterateMerge = function(landmark,diffs){
			
			if(diffs.length<1 || landmark.length<1){
				return ;//exit
			}
			//目前是先合并行，再循环列
			
			var last =false;//上一行是被合并的吗
			var firstRow  = landmark[0];
			var colsindex = rows[firstRow].cells.length-diffs[0];
			var mergeCell = $(rows[firstRow].cells[colsindex]);
			var counter = 2;
			var landmark_2 = $A(landmark);
			for(var j=1;j<landmark.length;j++){
				var rowindex = landmark[j];
				/*
				 * 前依赖的行合并，需要考虑前面列合并后，后面列序号变化的事实
				 * 观察得，z左依赖，右计数
				 */
				colsindex = rows[rowindex].cells.length-diffs[0];
				var tempCell = $(rows[rowindex].cells[colsindex]);
				
				if(mergeCell.innerHTML == tempCell.innerHTML){
					//do sth
					tempCell.destroy();
					mergeCell.addClass("crossCell");
					mergeCell.set("rowspan", counter++);
					last=true;
					//
					if(j==landmark.length-1){//the last merged one
						iterateMerge(landmark_2,diffs.slice(1));
					            return ;
                                                        }
				}else{
					mergeCell = tempCell;
					if(!last){
						landmark_2.erase(landmark[j-1]);
					}else{//last one was merged,but this not
						var offset = landmark_2.indexOf(landmark[j]);
						iterateMerge(landmark_2.slice(0,offset),diffs.slice(1));
						iterateMerge(landmark_2.slice(offset),diffs);
					            return ;
                                                           }
				}
			}
		}
		// iterateMerge end	
		var landmark = new Array();
		var rows = this.container.rows;
		var cellsLength = rows[0].cells.length;
		
		for(var k=0;k<10;k++){
			landmark.push(k);
		}
		
		var sorted = this.columns.sort(function(a,b){return a-b;});
		var diffs = new Array();
		for(var x = 0,l= sorted.length;x<l;x++){
			diffs.push(cellsLength-sorted[x]);
		}
		iterateMerge(landmark,diffs);
	}

  这实现的关键在：

1.左依赖，需要递归，需要分组

2.右计数（原因见注释）

代码使用了mootools的基础库。

landmark值要合并的行的数组

 this.columns是需要合并列的数组。

 diffs是使用右计数的this.columns的对应差数组

 

明白这个后其实就可以做右依赖了。

 

其实这个是典型的汉诺塔问题。

稍微有点变形而已。

假设：

问题为：F

[A-G] 为landmark数组[1-10]为列数组

 

那么

 

F =function([A-G],[1-10]){

    //do sth

    F([x-D],[1-10]);

    F([E-G],[2-10]) ;

}

问题就转为为如何确定x的值。