连连看连接算法Javascript版

继连连看连接算法Python版后，我将该算法移植到了Javascript上，为在浏览器版连连看做准备。

功能及使用方法参照另外一篇：连连看连接算法Python版。

值得一提的是由于Javascript语言没有Java中Map那样的<k,v>对应的数据结构，所以在实现这样的结构时就要另辟蹊径了，通用的方法应该是构建一个相关的类，并提供相应的方法操作。不过我发现一个简易的方法，适合将字符串(String)与任意类型数据相关联。具体方法是使用Javascript中类的属性可以使用数组存取方式(L[index]来访问)，可以使用属性名的字符串访问属性，还可以使用delete删除属性，当需要新建或修改一个对应关系的时候，就直接使用O[String]=Object新建或修改指定属性保存对应对象，当删除对应关系时使用delete O[String]即可，当这样就可以实现Map的功能了。

 

下面代码没有注释，注释可参见连连看连接算法Python版。

 

1. function _index(_value){
2.     for(var v in this){
3.         if(this[v] == _value){
4.             return new Number(v)
5.         }
6.     }
7.     return -1;
8. }
10. function _remove(_value){
11.     var _index = this.index(_value);
12.     this.splice(_index,1);
13. }
15. function _insert(_position,_value){
16.     this.splice(_position,0,_value);
17. }
19. Array.prototype.index = _index;
20. Array.prototype.insert = _insert;
21. Array.prototype.remove = _remove;
23. function Point(_x,_y,_value){
24.     this.x = _x;
25.     this.y = _y;
26.     this.value = _value;
27.     this.directs = null;
28.     this.changed = 0;
29. }
31. function _createDirect(_pre,_target){
32.     this.directs = new Array();
33.     var stx = _target.x - this.x;
34.     var sty = _target.y - this.y;
35.     if(stx >= 0){
36.         this.directs.push("right");
37.         this.directs.push("left");
38.     }
39.     else{
40.         this.directs.push("left");
41.         this.directs.push("right");
42.     }
43.     if(sty >= 0){
44.         this.directs.insert(1,"up");
45.         this.directs.push("down");
46.     }
47.     else{
48.         this.directs.insert(1,"down");
49.         this.directs.push("up");
50.     }
51.     if (_pre == null){
52.         return ;
53.     }
54.     var spx = _pre.x - this.x;
55.     var spy = _pre.y - this.y;
56.     if (spx == 0){
57.         if (spy == 1){
58.             this.directs.remove("up");
59.         }
60.         else{
61.             this.directs.remove("down");
62.         }
63.     }
64.     else{
65.         if (spx == 1){
66.             this.directs.remove("right");
67.         }
68.         else{
69.             this.directs.remove("left");
70.         }
71.     }
72. }
74. function _forward(_pre,_target){
75.     if(this.directs == null){
76.         this.createDirect(_pre,_target);
77.     }
78.     if(this.directs.length == 0){
79.         return null;
80.     }
81.     var direct = null;
82.     var tmpDirect = null;
83.     var x = null;
84.     var y = null;
85.     var p = null;
86.     while(true){
87.         if(this.directs.length == 0){
88.             break;
89.         }
90.         tmpDirect = this.directs.shift();
91.         switch(tmpDirect){
92.             case "up":
93.                 x = this.x;
94.                 y = this.y + 1;
95.                 break;
96.             case "down":
97.                 x = this.x;
98.                 y = this.y - 1;
99.                 break;
100.             case "left":
101.                 x = this.x - 1;
102.                 y = this.y;
103.                 break;
104.             case "right":
105.                 x = this.x + 1;
106.                 y = this.y;
107.                 break;
108.             default:
109.                 throw new Error("error direct");
110.                 break;
111.         }
112.         p = points[x][y];
113.         if(p.value > 0 && p != _target){
114.             continue;
115.         }
116.         else{
117.             direct = tmpDirect;
118.             if(_pre == null){
119.                 this.changed = 1;
120.             }
121.             else{
122.                 if((_pre.x - this.x) == 0 && (p.x - this.x) == 0){
123.                     this.changed = 0;
124.                 }
125.                 else{
126.                     if((_pre.y - this.y) == 0 && (p.y - this.y) == 0){
127.                         this.changed = 0;
128.                     }
129.                     else{
130.                         this.changed = 1;
131.                     }
132.                 }
133.             }
134.             break;
135.         }
136.     }
137.     return direct;
138. }
140. function _equals(_point){
141.     if (_point == null){
142.         return false;
143.     }
144.     if (this.x == _point.x && this.y == _point.y){
145.         return true;
146.     }
147.     else{
148.         return false;
149.     }
150. }
152. Point.prototype.createDirect = _createDirect;
153. Point.prototype.forward = _forward;
154. Point.prototype.equals = _equals;
156. var points = new Array();
157. var valueStack = new Array();
159. function createPoints(w,h){
160.     var temp;
161.     var tempValue;
162.     pointStack(w,h);
163.     for(var _x = 0 ; _x < w ; _x++){
164.         temp = new Array();
165.         for(var _y = 0 ; _y < h ; _y++){
166.             if(_x == 0 || _x == (w-1) || _y == 0 || _y == (h-1)){
167.                 tempValue = 9;
168.             }
169.             else{
170.                 if(_x == 1 || _x == (w-2) || _y == 1 || _y == (h-2)){
171.                     tempValue = 0;
172.                 }
173.                 else{
174.                     tempValue = valueStack.pop();
175.                 }
176.             }
177.             temp[_y] = new Point(_x,_y,tempValue);
178.         }
179.         points[_x] = temp;
180.     }
181. }
183. function pointStack(w,h){
184.     var size = (w*h-(w*4+h*4-16))/2;
185.     var pointValue;
186.     for(var i = 0 ; i < size ; i++){
187.         while(true){
188.             pointValue = Math.floor(Math.random()*9);
189.             if(pointValue != 0){
190.                 break;
191.             }
192.         }
193.         valueStack.insert(Math.floor(Math.random()*valueStack.length),pointValue);
194.         valueStack.insert(Math.floor(Math.random()*valueStack.length),pointValue);
195.     }
196. }
198. function linkPoints(_source,_target){
199.     var path = new Array();
200.     var fail = new Object();
201.     var change = 0;
202.     var _current = _source;
203.     var direct = null;
204.     var _x,_y;
205.     while(true){
206.         //alert("current--"+pointStr(_current)+"change:"+change);
207.         if(_current == _target && change < 4){
208.             for(var p in path){
209.                 path[p].directs = null;
210.             }
211.             return path;
212.         }
213.         if(change == 4){
214.             _current.directs = null;
215.             fail[(_current.x+"_"+_current.y)] = change;
216.             _current = path.pop();
217.             change = change - _current.changed;
218.             continue;
219.         }
220.         if(_current == _source){
221.             direct = _current.forward(null,_target);
222.         }
223.         else{
224.             direct = _current.forward(path[path.length-1],_target);
225.         }
226.         if(direct != null){
227.             if(direct == "up"){
228.                 _x = _current.x;
229.                 _y = _current.y + 1;
230.             }
231.             if(direct == "down"){
232.                 _x = _current.x;
233.                 _y = _current.y - 1;
234.             }
235.             if(direct == "left"){
236.                 _x = _current.x - 1;
237.                 _y = _current.y ;
238.             }
239.             if(direct == "right"){
240.                 _x = _current.x + 1;
241.                 _y = _current.y;
242.             }
243.             if(fail[(_x+"_"+_y)] != null){
244.                 if (change >= fail[(_x+"_"+_y)]){
245.                     continue;
246.                 }
247.                 else{
248.                     delete fail[(_x+"_"+_y)];
249.                 }
250.             }
251.             change = change + _current.changed;
252.             path.push(_current);
253.             _current = points[_x][_y];
254.         }
255.         else{
256.             if(_current == _source){
257.                 _source.directs = null;
258.                 return false;
259.             }
260.             else{
261.                 _current.directs = null;
262.                 fail[(_current.x+"_"+_current.y)] = change;
263.                 _current = path.pop();
264.                 change = change - _current.changed;
265.             }
266.         }
267.     }
268. }
270. /*function pointStr(p){
271.     return " x:"+p.x+" y:"+p.y+" value:"+p.value;
272. }
273. */