├── .idea
    ├── dictionaries
    │   └── Luffy.xml
    ├── jsLibraryMappings.xml
    ├── misc.xml
    ├── modules.xml
    ├── offer-javascript.iml
    ├── vcs.xml
    └── watcherTasks.xml
├── 01-findInMatrixArray
    └── findInMatrixArray.js
├── 02-replaceSpace
    └── replaceSpace.js
├── 03-printListTailToHead
    └── printListTailToHead.js
├── 04-rebuildBinaryTree
    └── rebuildBinaryTree.js
├── 05-arrayToQueue
    └── arrayToQueue.js
├── 06-minNumberInRotateArray
    └── minNumberInRotateArray.js
├── 07-fibonacci
    └── fibonacci.js
├── 08-jumpFloor
    └── jumpFloor.js
├── 09-rectCover
    └── rectCover.js
├── 10-numberOf1
    └── numberOf1.js
├── 11-doublePower
    └── doublePower.js
├── 12-reOrderArray
    └── reOrderArray.js
├── 13-findKthFromTail
    └── findKthFromTail.js
├── 14-reverseList
    └── reverseList.js
├── 15-merge
    └── merge.js
├── 16-HasSubTree
    └── hasSubTree.js
├── 17-Mirror
    └── mirror.js
├── 18-printMatrix
    └── printMatrix.js
├── 19-minArr
    └── minArr.js
├── 20-isPopOrder
    └── isPopOrder.js
├── 21-lastOrderTree
    └── lastOrderTree.js
├── 22-findPath
    └── findPath.js
├── 23-complexList
    └── complexList.js
├── 24-permMutation
    ├── permMutation字符串无重复.js
    ├── permMutation字符串有重复.js
    └── test.js
├── 25-MoreThanHalfNum_Solution
    └── MoreThanHalfNum_Solution.js
├── 26-GetLeastNumbers_Solution
    └── GetLeastNumbers_Solution.js
├── 27-FindGreatestSumOfSubArray
    └── FindGreatestSumOfSubArray.js
├── 29-PrintMinNumber
    └── PrintMinNumber.js
├── 30-GetUglyNumber_Solution
    └── GetUglyNumber_Solution.js
├── README.md
└── 上传操作


/.idea/dictionaries/Luffy.xml:
--------------------------------------------------------------------------------
1 | <component name="ProjectDictionaryState">
2 |   <dictionary name="Luffy" />
3 | </component>


--------------------------------------------------------------------------------
/.idea/jsLibraryMappings.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="JavaScriptLibraryMappings">
4 |     <includedPredefinedLibrary name="ECMAScript 6" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="JavaScriptSettings">
4 |     <option name="languageLevel" value="ES6" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="ProjectModuleManager">
4 |     <modules>
5 |       <module fileurl="file://$PROJECT_DIR$/.idea/offer-javascript.iml" filepath="$PROJECT_DIR$/.idea/offer-javascript.iml" />
6 |     </modules>
7 |   </component>
8 | </project>


--------------------------------------------------------------------------------
/.idea/offer-javascript.iml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <module type="WEB_MODULE" version="4">
 3 |   <component name="NewModuleRootManager">
 4 |     <content url="file://$MODULE_DIR$">
 5 |       <excludeFolder url="file://$MODULE_DIR$/.tmp" />
 6 |       <excludeFolder url="file://$MODULE_DIR$/temp" />
 7 |       <excludeFolder url="file://$MODULE_DIR$/tmp" />
 8 |     </content>
 9 |     <orderEntry type="inheritedJdk" />
10 |     <orderEntry type="sourceFolder" forTests="false" />
11 |   </component>
12 | </module>


--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="VcsDirectoryMappings">
4 |     <mapping directory="$PROJECT_DIR$" vcs="Git" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/.idea/watcherTasks.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="ProjectTasksOptions" suppressed-tasks="Babel" />
4 | </project>


--------------------------------------------------------------------------------
/01-findInMatrixArray/findInMatrixArray.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/5.
 3 |  */
 4 | /**
 5 |  * @param target 目标
 6 |  * @param array 原数组
 7 |  * @returns {boolean} 结果，查找到true，未查找到false
 8 |  *思路
 9 |  * 因为二维数组排序方式是特别的，从左到右从上到下依次递增，因此采取从左下角或者右上角作为起点去排查
10 |  * 每一次排查至少可以去掉一列或者一行或者直接找到元素
11 |  */
12 | function findInMatrix(target, array) {
13 |     var row = array.length;  // 行数
14 |     var col = array[0].length;  // 列数
15 |     // 从左下角开始比较
16 |     var currentRow = row - 1; //当前行数
17 |     var currentColumn = 0; //当前所在列数
18 |     while(currentRow >= 0 && currentColumn <= col - 1) { // 注意这里有等于号
19 |         if (target > array[currentRow][currentColumn]) {
20 |             currentColumn++;
21 |         } else if (target < array[currentRow][currentColumn]) {
22 |             currentRow--;
23 |         } else {
24 |             return true; //找到目标
25 |         }
26 |     }
27 |     return false; //未找到目标
28 | }


--------------------------------------------------------------------------------
/02-replaceSpace/replaceSpace.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/5.
 3 |  */
 4 | /**
 5 |  *
 6 |  * @param str 目标字符串
 7 |  * @returns {string|void|XML}
 8 |  *JavaScript天生优势，正则表达式替换语句，将字符串中的空格替换为%20
 9 |  */
10 | function replaceSpace1(str) {
11 |     // write code here
12 |     //使用JavaScript之中的正则表达式进行替换
13 |     return str.replace(/\s/g,'%20');
14 | }
15 | /**
16 |  * 利用字符串拼接特性，临时字符串不断将空格拼接成%20也可以
17 |  * @param str
18 |  * @returns {string}
19 |  */
20 | function replaceSpace2(str) {
21 |     var newString="";
22 |     for(var i=0;i<str.length;i++)
23 |     {
24 |         if(str[i]===' ')
25 |         {
26 |             newString=newString+"%20";
27 |             continue;
28 |         }
29 |         newString+=str[i];
30 |     }
31 |     return newString;
32 | }


--------------------------------------------------------------------------------
/03-printListTailToHead/printListTailToHead.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/5.
 3 |  */
 4 | //从尾到头打印链表元素
 5 | /**
 6 |  * 思路:从头遍历链表将值以unshift的方式存入数组中，从头打印数组即可
 7 |  * @param list 目标链表
 8 |  */
 9 | function ListNode(x){
10 |  this.val = x;
11 |  this.next = null;
12 |  }
13 | var head = new ListNode(1);
14 | var a = new ListNode(2);
15 | head.next = a;
16 | var b = new ListNode(3);
17 | a.next = b;
18 | function printListTailToHead(list) {
19 |     var res=[]; //将链表的值存入数组，存入方式为unshift
20 |     while(list){
21 |         res.unshift(list.val);  // unshift()：向数组的开头添加一个或更多元素,并返回新的长度
22 |         list=list.next;
23 |     }
24 |     return res;
25 | }
26 | console.log(printListTailToHead(head)); //3,2,1从尾开始打印链表


--------------------------------------------------------------------------------
/04-rebuildBinaryTree/rebuildBinaryTree.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/6.
 3 |  */
 4 | //二叉树叶子节点
 5 | function TreeNode(x) {
 6 |  this.val = x;
 7 |  this.left = null;
 8 |  this.right = null;
 9 |  }
10 | /**
11 |  * 思路，根节点是先序遍历的第一个节点，从根节点开始构建二叉树
12 |  * 中序遍历节点，直到找到与根节点相同的节点，左侧为左子树，右侧为右子树
13 |  * 之后，递归构建左右子树
14 |  * @param preOrder 先序遍历序列
15 |  * @param minOrder 中序遍历序列
16 |  * @returns {*}
17 |  */
18 | function rebuildBinaryTree(preOrder,minOrder) {
19 |     // write code here
20 |     if(preOrder.length == 0 || minOrder.length == 0 ) {
21 |         return null;
22 |     }
23 |     var treeNode = new TreeNode(preOrder[0]);
24 |     for(var i = 0; i < preOrder.length; i++) {
25 |         if (minOrder[i] === preOrder[0]) {
26 |             treeNode.left = rebuildBinaryTree(preOrder.slice(1, i+1), minOrder.slice(0, i)); //左子树的先序和左子树的中序
27 |             treeNode.right = rebuildBinaryTree(preOrder.slice(i+1),minOrder.slice(i+1)); //右子树的先序和右子树的中序
28 |         }
29 |     }
30 |     return treeNode;
31 | }
32 | var pre=[1,2,4,7,3,5,6,8];
33 | var min = [4,7,2,1,5,3,8,6];
34 | var tree = rebuildBinaryTree(pre,min);
35 | //先序遍历输出二叉树
36 | function preOrder(node){//先序遍历
37 |     if(node!=null){
38 |         console.log(node.val);
39 |         preOrder(node.left);
40 |         preOrder(node.right);
41 |     }
42 | }
43 | preOrder(tree); //12473568
44 | 


--------------------------------------------------------------------------------
/05-arrayToQueue/arrayToQueue.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/6.
 3 |  */
 4 | //用两个栈实现队列，包含pop和push操作
 5 | /**
 6 |  * 思路：首先声明一个栈的数据结构，包含push和pop操作
 7 |  * 队列是先进先出的，因此需要两个栈，一个用来存所有入队的元素，一个用来存所有出队的元素
 8 |  * push操作：将数据压入stack1即可
 9 |  * pop操作：因为是先进先出，所以stack2的顺序应该与stack1顺序相反，那么可以将stack1的元素不断弹出并压入stack2
10 |  * 每次出队操作都需要将stack2弹出即可
11 |  * @constructor
12 |  */
13 | function Stack(){
14 |     var arr = [];
15 |     this.push = function (node){
16 |         arr.push(node);
17 |         return arr;
18 |     };
19 |     this.pop = function(){
20 |         return arr.pop();
21 |     };
22 |     this.isEmpty = function(){
23 |         return arr.length === 0;
24 |     };
25 | }
26 | var stack1 = new Stack();
27 | var stack2 = new Stack();
28 | function push(node) {
29 |     // write code here
30 |     stack1.push(node);
31 | }
32 | function pop() {
33 |     // write code here
34 |     if(stack1.isEmpty() && stack2.isEmpty()){
35 |         throw new Error("empty queue");
36 |     }
37 |     if(stack2.isEmpty()){
38 |         while(!stack1.isEmpty()){
39 |             stack2.push(stack1.pop());
40 |         }
41 |     }
42 |     return stack2.pop();
43 | }


--------------------------------------------------------------------------------
/06-minNumberInRotateArray/minNumberInRotateArray.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/6.
 3 |  */
 4 | /**
 5 |  * 旋转数组之中的最小元素
 6 |  * @param arr
 7 |  * @returns {*}
 8 |  */
 9 | function minNumberInRotateArray(arr) {
10 |     // write code here
11 |     var left = 0;
12 |     var right = arr.length-1;
13 |     var mid = left;
14 |     
15 |     if (arr.length == 0) return;
16 |     
17 |     while(arr[left] >= arr[right]){
18 |         if(right-left == 1){
19 |             mid = right;
20 |             break;
21 |         }
22 |         mid = Math.floor((left+right)/2)
23 |         if(arr[mid] >= arr[left]){
24 |             left = mid;
25 |         }
26 |         else if(arr[mid] < arr[left]){
27 |             right = mid;
28 |         }
29 |         else if(arr[mid] == arr[right] && arr[mid] == arr[left]){
30 |             return inOrder(arr);
31 |         }
32 |     }
33 |     return arr[mid];
34 | }
35 | function inOrder(arr){
36 |     var min = arr[0];
37 |     for(var i = 0; i<arr.length; i++){
38 |         if(min > arr[i]){
39 |             min = arr[i];
40 |         }
41 |     }
42 |     return min;
43 | }


--------------------------------------------------------------------------------
/07-fibonacci/fibonacci.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/8.
 3 |  */
 4 | /**
 5 |  * 常规递归解法：时间复杂度以及栈空间不允许，不是好解法
 6 |  * @param n
 7 |  * @returns {*}
 8 |  * @constructor
 9 |  */
10 | function Fibonacci(n)
11 | {
12 |     // write code here
13 |     if(n==0){
14 |         return 0;
15 |     }
16 |     if(n==1){
17 |         return 1;
18 |     }
19 |     return Fibonacci(n-2)+Fibonacci(n-1);
20 | }
21 | /**
22 |  * 合理解法，只需要把每一次求出来的结果存起来，不断用前两次相加即可。
23 |  * @param n
24 |  * @returns {number}
25 |  * @constructor
26 |  */
27 | function Fibonacci(n)
28 | {
29 |     // write code here
30 |     if(n==0){
31 |         return 0;
32 |     }
33 |     if(n==1){
34 |         return 1;
35 |     }
36 |     var frontOne = 1; //前一个结果也就是f(n-1)
37 |     var frontTwo = 0; //前两个结果,也就是f(n-2)
38 |     var fiboN = 0; //第n个
39 |     for(var i=2;i<=n;i++){
40 |         fiboN = frontOne + frontTwo; //前两个相加
41 |         frontTwo = frontOne;  //f(n-2) => f(n-1)
42 |         frontOne = fiboN; //f(n-1) => f(n)
43 |     }
44 |     return fiboN;
45 | }


--------------------------------------------------------------------------------
/08-jumpFloor/jumpFloor.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/8.
 3 |  */
 4 | /**
 5 |  * 菲波那切数列的变形
 6 |  * 如果只有一个台阶，只有一种方法，如果有两个台阶，有两种方法
 7 |  * 当台阶>2时,第一次跳跃有两种不同的选择：第一种跳一个台阶，此时跳法数目等于后面n-1个台阶的跳法数目
 8 |  * 第二种是第一次跳两个台阶，剩下的跳法数目等于后面n-2个台阶的跳法数目
 9 |  * 因此：f(n) = f(n-1)+f(n-2)
10 |  * @param number
11 |  * @returns {number}
12 |  */
13 | function jumpFloor(number)
14 | {
15 |     // write code here
16 |     if(number == 1){
17 |         return 1;
18 |     }
19 |     if(number == 2){
20 |         return 2;
21 |     }
22 |     var frontOne = 2; //前一个结果也就是f(n-1)
23 |     var frontTwo = 1; //前两个结果,也就是f(n-2)
24 |     var fiboN = 0; //第n个
25 |     for(var i=3;i<=number;i++){
26 |         fiboN = frontOne + frontTwo; //前两个相加
27 |         frontTwo = frontOne;  //f(n-2) => f(n-1)
28 |         frontOne = fiboN; //f(n-1) => f(n)
29 |     }
30 |     return fiboN;
31 | }
32 | /**
33 |  * 跳台阶变形，由数学归纳法可以知道，每个台阶对于青蛙来说有两种可能，跳或者不挑
34 |  * 因此，n个台阶的跳法应为2的(n-1)次幂
35 |  * @param number
36 |  * @returns {*}
37 |  */
38 | function jumpFloorII(number) {
39 |     if (number < 0) return;
40 |     if (number >= 0 && number <= 2) return number;
41 |     return 2 * jumpFloorII(number - 1)
42 | }


--------------------------------------------------------------------------------
/09-rectCover/rectCover.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/8.
 3 |  */
 4 | /**
 5 |  * 还是斐波那契数列
 6 |  * 如果第一个小矩形竖着放，则还剩下f(n-1)种摆法
 7 |  * 如果第一个小矩形横着放，那么对应着下方的也必须是一个横着放的小矩形，右侧就剩下f(n-2)种方法
 8 |  * @param n
 9 |  * @returns {*}
10 |  */
11 | function rectCover(n)
12 | {
13 |     // write code here
14 |     if(n==0){
15 |         return 0;
16 |     }
17 |     if(n==1 || n==2){
18 |         return n;
19 |     }
20 |     var frontOne = 2; //前一个结果也就是f(n-1)
21 |     var frontTwo = 1; //前两个结果,也就是f(n-2)
22 |     var fiboN = 0; //第n个
23 |     for(var i=3;i<=number;i++){
24 |         fiboN = frontOne + frontTwo; //前两个相加
25 |         frontTwo = frontOne;  //f(n-2) => f(n-1)
26 |         frontOne = fiboN; //f(n-1) => f(n)
27 |     }
28 |     return fiboN;
29 | }


--------------------------------------------------------------------------------
/10-numberOf1/numberOf1.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/8.
 3 |  */
 4 | /**
 5 |  * 书上的优秀解法，有几个1就循环几次
 6 |  * @param n
 7 |  * @returns {number}
 8 |  * @constructor
 9 |  */
10 | function NumberOf1(n) {
11 |     var count = 0;
12 |     while(n) {
13 |         ++count;
14 |         n = (n - 1) & n;
15 |     }
16 |     return count;
17 | }
18 | /**
19 |  * 常规解法：从最低位开始循环判断那一位是否为1
20 |  * @param n
21 |  * @returns {*}
22 |  * @constructor
23 |  */
24 | function NumberOf1(n) {
25 |     var count = 0;
26 |     var flag = 1;
27 |     while(flag){
28 |         if(n&flag){
29 |             count++;
30 |         }
31 |         flag = flag << 1;
32 |     }
33 |     return count;
34 | }
35 | /**
36 |  * javascript特有解法：如果n>0，将n转换成二进制字符串，然后循环判断里面1的个数
37 |  * 如果n<0，将负数转换成正确的二进制补码形式在转换成字符串，在循环判断
38 |  * @param n
39 |  * @returns {*}
40 |  * @constructor
41 |  */
42 | function NumberOf1(n) {
43 |     // write code here
44 |     //-123的二进制表示为-1111011，123的为1111011，因此首先要得到负数二进制的补码表示
45 |     //其后面部分的补码0000101 = 122的正码1111011按位取反，
46 |     //这个正码加上前面的0即是再全部按位取反即得-123的补码表示
47 |     if(n < 0){
48 |         n = -n;
49 |         n = n-1;
50 |         var str = (Array(32).join("0")+n.toString(2)).slice(-32);
51 |         str = exchange(str);
52 |     }else{
53 |         var str = (Array(32).join("0")+n.toString(2)).slice(-32);
54 |     }
55 |     
56 |     return cal(str);
57 | }
58 | //计算1的个数
59 | function cal(str){
60 |     var sum = 0;
61 |     for(var i = 0; i < str.length; i++){
62 |         if(str[i] == 1){
63 |             sum ++;
64 |         }
65 |     }
66 |     return sum;
67 | }
68 | //如果是负数，0变1，1变0
69 | function exchange(str){
70 |     var arr = str.split('');
71 |     for(var i = 0; i < arr.length; i++){
72 |         if(arr[i] == 0){
73 |             arr[i] = 1;
74 |         }else {
75 |             arr[i] = 0;
76 |         }
77 |     }
78 |     str = arr.join("");
79 |     return str;
80 | }


--------------------------------------------------------------------------------
/11-doublePower/doublePower.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/8.
 3 |  */
 4 | /**
 5 |  * JavaScript方便解法，调用Math函数的pow方法
 6 |  * @param base
 7 |  * @param exponent
 8 |  * @returns {number}
 9 |  * @constructor
10 |  */
11 | function Power(base, exponent) {
12 |     // write code here
13 |     return Math.pow(base,exponent);
14 | }
15 | /**
16 |  * 常规解法：需要考虑到底数为0以及指数小于0的情况
17 |  */
18 | var INVALID_INPUT = false; //判断输入是否合法
19 | function Power(base,exponent) {
20 |     //非法输入，返回0.0
21 |     if(equal(base,0.0) && exponent <0){
22 |         INVALID_INPUT = true;
23 |         return 0.0;
24 |     }
25 |     var absExpomemt = Math.abs(exponent);
26 |     var result = 1.0;
27 |     for(var i = 1;i<=absExpomemt;i++){
28 |         result *= base;
29 |     }
30 |     if(exponent < 0){
31 |         result = 1.0/result;
32 |     }
33 |     return result;
34 | }
35 | /**
36 |  * javascript中的浮点数减法不是精确的，用一个函数来近似相等
37 |  * @param num1
38 |  * @param num2
39 |  */
40 | function equal(num1,num2) {
41 |     if((num1-num2>-0.0000001)&&(num1-num2)<0.0000001){
42 |         return true;
43 |     }else {
44 |         return false;
45 |     }
46 | }


--------------------------------------------------------------------------------
/12-reOrderArray/reOrderArray.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/13.
 3 |  */
 4 | /**
 5 |  * 输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
 6 |  *  思路：利用两个临时数组，一个存奇数，一个存偶数，然后将偶数添加到奇数后面
 7 |  *  @param array
 8 |  * @returns {*}
 9 |  */
10 | function reOrderArray(array) {
11 |     // write code here
12 |     if(array.length==0||array.length==1){
13 |         return array;
14 |     }
15 |     var jArr = [];
16 |     var oArr = [];
17 |     for(var i = 0,len=array.length;i<len;i++){
18 |         if(array[i]%2==0){
19 |             oArr.push(array[i]);
20 |         }else{
21 |             jArr.push(array[i]);
22 |         }
23 |     }
24 |     //第一种方式，prototype
25 |     Array.prototype.push.apply(jArr,oArr);
26 |     //第二种方式
27 |     jArr.concat(oArr);
28 |     delete oArr;//删除额外空间
29 |     return jArr;
30 | }


--------------------------------------------------------------------------------
/13-findKthFromTail/findKthFromTail.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/13.
 3 |  */
 4 | /**
 5 |  * 输出链表的倒数k个节点
 6 |  * 思路：定义两个指针p,q分别指向头指针，p向前移动k-1个，之后q和p不断向后移动，直到p到链表尾部，q就指向链表倒数第k个
 7 |  * @param head
 8 |  * @param k
 9 |  * @returns {*}
10 |  * @constructor
11 |  */
12 | function ListNode(x){
13 |  this.val = x;
14 |  this.next = null;
15 |  }
16 | function FindKthfromTail(head, k) {
17 |     if(!head||k<=0){
18 |         return null;
19 |     }else{
20 |         var q=head;
21 |         var p=head;
22 |         for(var i=0;i<k-1;i++){
23 |             if(p.next) {
24 |                 p=p.next;
25 |             }else{
26 |                 return null;
27 |             }
28 |         }
29 |         for(;p.next;p=p.next){
30 |             q=q.next;
31 |         }
32 |         return q;
33 |     }
34 | }


--------------------------------------------------------------------------------
/14-reverseList/reverseList.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/13.
 3 |  */
 4 | /**
 5 |  * 反转链表
 6 |  * 思路，不断将指针反转，然后将最后一个节点返回，就是反转之后的链表
 7 |  * @param pHead
 8 |  * @returns {*}
 9 |  * @constructor
10 |  */
11 | function ReverseList(pHead) {
12 |     var pCur = null;
13 |     var pNext = null;
14 |     while(pHead !== null){
15 |         pNext = pHead.next;
16 |         pHead.next = pCur;
17 |         pCur = pHead;
18 |         pHead = pNext;
19 |     }
20 |     return pCur;
21 | }


--------------------------------------------------------------------------------
/15-merge/merge.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/13.
 3 |  */
 4 | /**
 5 |  * 思路：
 6 |  ① 如果 pHead1 和 pHead2 中有一个为空，则 result 是另一个；
 7 |  ② 如果 pHead1 的头结点值小于 pHead2，那么 result 的头结点为 pHead1 的头结点，其 next 为 pHead1.next 和 pHead2 比较的结果。同理对 pHead2 也一样。
 8 |  ③ 因此本题可采用递归的方法。
 9 |  * @param pHead1
10 |  * @param pHead2
11 |  * @returns {*}
12 |  * @constructor
13 |  */
14 | function Merge(pHead1, pHead2) {
15 |     // write code here
16 |     if (pHead1 == null) {
17 |         return pHead2;
18 |     } else if (pHead2 == null) {
19 |         return pHead1;
20 |     }
21 |     var result = {};
22 |     if (pHead1.val < pHead2.val) {
23 |         result = pHead1;
24 |         result.next = Merge(pHead1.next, pHead2);
25 |     } else {
26 |         result = pHead2;
27 |         result.next = Merge(pHead1, pHead2.next);
28 |     }
29 |     return result;
30 | }


--------------------------------------------------------------------------------
/16-HasSubTree/hasSubTree.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/14.
 3 |  */
 4 | /* function TreeNode(x) {
 5 |  this.val = x;
 6 |  this.left = null;
 7 |  this.right = null;
 8 |  } */
 9 | /**
10 |  * 思路：
11 |  ① 有关二叉树的算法问题，一般都可以通过递归来解决。那么写成一个正确的递归程序，首先一定要分析正确递归结束的条件。
12 |  ② 如果根节点相同则递归调用 isSubtree()，如果根节点不相同，则判断 root1 的左子树和 root2 是否相同，再判断右子树和 tree2 是否相同;
13 |  ③ 注意 null 的条件，HasSubTree 中，如果两棵树都不为空才进行判断，isSubtree 中，如果 root2 为空，则说明第二棵树遍历完了，即匹配成功;
14 |  ④ root1 为空有两种情况：(1) 如果 root1为空 && root2 不为空说明不匹配，(2) 如果 root1 为空，root2 为空，说明匹配。
15 |  * @param root1
16 |  * @param root2
17 |  * @returns {*}
18 |  */
19 | function isSubtree(root1, root2) {
20 |     if (root2 == null) return true;
21 |     if (root1 == null) return false;
22 |     if (root1.val == root2.val) {
23 |         return isSubtree(root1.left, root2.left)
24 |             && isSubtree(root1.right, root2.right);
25 |     } else {
26 |         return false;
27 |     }
28 | }
29 | function HasSubtree(pRoot1, pRoot2)
30 | {
31 |     if (pRoot1 == null || pRoot2 == null) {
32 |         return false;
33 |     }
34 |     return isSubtree(pRoot1, pRoot2)
35 |         || HasSubtree(pRoot1.left, pRoot2)
36 |         || HasSubtree(pRoot1.right, pRoot2);
37 | }


--------------------------------------------------------------------------------
/17-Mirror/mirror.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/6/14.
 3 |  */
 4 | /**
 5 |  * 思路：
 6 |  ① 有关二叉树的算法问题，一般都可以通过递归来解决。那么写一个正确的递归程序，首先一定要分析正确递归结束的条件。
 7 |  ② 先前序遍历这棵树的每个结点，如果遍历到的结点有子结点，就交换它的两个子节点；
 8 |  ③ 当交换完所有的非叶子结点的左右子结点之后，就得到了树的镜像。
 9 |  * @param root
10 |  * @constructor
11 |  */
12 | function Mirror(root) {
13 |     // write code here
14 |     if(root === null) {
15 |         return;
16 |     }
17 |     var temp = root.left;
18 |     root.left = root.right;
19 |     root.right = temp;
20 |     Mirror(root.left);
21 |     Mirror(root.right);
22 | }


--------------------------------------------------------------------------------
/18-printMatrix/printMatrix.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/11.
 3 |  */
 4 | var matrix = [
 5 |     [1,2,3,4],
 6 |     [5,6,7,8],
 7 |     [9,10,11,12],
 8 |     [13,14,15,16]
 9 | ];
10 | function printMatrix(matrix) {
11 |     var row = matrix.length;
12 |     var col = matrix[0].length;
13 |     var result = [];
14 |     if(row==0||col==0){
15 |         return result;
16 |     }
17 |     //定义上下左右位置
18 |     var left = 0, //从左到右，第一次是从0开始
19 |         top = 0, //从上到下，第一次从0开始
20 |         right = matrix[0].length-1, // 从右到左，第一次从倒数第一行倒数第二个开始
21 |         bottom = matrix.length -1; // 从下到上，第一次从第一列倒数第二个开始
22 |     //循环条件，当left<right ,top<bottom时
23 |     while(left<=right && top<=bottom){
24 |         //从左到右
25 |         for(var i=left;i<=right;i++){
26 |             result.push(matrix[top][i]);
27 |         }
28 |         //从上到下
29 |         for(var j=top+1;j<=bottom;j++){
30 |             result.push(matrix[j][right]);
31 |         }
32 |         //从右到左
33 |         if(top!=bottom){
34 |             for(var m=right-1;m>=left;m--){
35 |                 result.push(matrix[bottom][m]);
36 |             }
37 |         }
38 |         //从下到上
39 |         if(left!=right){
40 |             for(var n=bottom-1;n>top;n--){
41 |                 result.push(matrix[n][left]);
42 |             }
43 |         }
44 |         left++;
45 |         top++;
46 |         right--;
47 |         bottom--;
48 |     }
49 |     return result;
50 | }
51 | console.log(printMatrix(matrix));


--------------------------------------------------------------------------------
/19-minArr/minArr.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/11.
 3 |  */
 4 | var arr = [];
 5 | function push(node) {
 6 |     // write code here
 7 |     arr.push(node);
 8 | }
 9 | function pop() {
10 |     // write code here
11 |     return arr.pop();
12 | }
13 | function top() {
14 |     // write code here
15 |     return arr[arr.length-1];
16 | }
17 | function min() {
18 |     // write code here
19 |     //return Math.min.apply(Math, arr);
20 |     return Math.min(...arr);
21 | }


--------------------------------------------------------------------------------
/20-isPopOrder/isPopOrder.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/11.
 3 |  */
 4 | function IsPopOrder(pushV, popV){
 5 |     // write code here
 6 |     var stack = [];
 7 |     for(var i=0,j=0;i<pushV.length;i++){
 8 |         stack.push(pushV[i]);//先按照顺序压入元素
 9 |         //当stack的最后一个元素和出栈的元素顺序相等的时候，进行出栈
10 |         while(j < popV.length && stack[stack.length - 1] == popV[j]){
11 |             j++;
12 |             stack.pop();
13 |         }
14 |     }
15 |     //上述过程结束之后如果stack为空，表示是一个出栈顺序，否则不是一个出栈顺序
16 |     if(stack.length==0){
17 |         return true;
18 |     }else{
19 |         return false;
20 |     }
21 | }


--------------------------------------------------------------------------------
/21-lastOrderTree/lastOrderTree.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/11.
 3 |  */
 4 | /*
 5 | 相关知识：
 6 | 二叉查找树 (Binary Search Tree)，(又：二叉搜索树，二叉排序树) 它或者是一棵空树，或者是具有下列性质的二叉树：
 7 | 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
 8 | 它的左、右子树也分别为二叉排序树。
 9 | 思路：
10 | ① 根据二叉搜索树的特点，序列的最后一个元素是根结点，其左子树全都比根结点小，右子树全都比根节点大。
11 | ② 将根结点前面的数组分为左右连个部分，左侧部分都小，右侧部分都大；
12 | ③ 如果右侧部分有比根节点小的元素，那么就不是后序遍历，如此递归进行。
13 | */
14 | function VerifySquenceOfBST(sequence) {
15 |     // write code here
16 |     var n = sequence.length;
17 |     var i = 0;
18 |     if (n == 0) {
19 |         return false;
20 |     }
21 |     while (n--) {
22 |         while (sequence[i] < sequence[n])
23 |             i++;
24 |         while (sequence[i] > sequence[n])
25 |             i++;
26 |         
27 |         if (i < n) return false;
28 |         
29 |         i = 0;
30 |     }
31 |     return true;
32 | }


--------------------------------------------------------------------------------
/22-findPath/findPath.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/11.
 3 |  */
 4 | /*
 5 | 思路：
 6 | ① 前序遍历二叉树，每次更新当前路径的和 curtSum；
 7 | ② 判断当前结点是否是叶子结点，以及 curtSum 是否等于 expectNumber。如果是，把当前路径保存在 res 结果中；
 8 | ③ 若不符合条件，则弹出此结点。
 9 | */
10 | function FindPath(root, expectNumber) {
11 |     var result = [];
12 |     if (root === null) {
13 |         return result;
14 |     }
15 |     dfsFind(root, expectNumber, [], 0, result);
16 |     return result;
17 | }
18 | //深度遍历，知道找到一条路径和为目标值，之后将路径push到result中，result中存的是路径数组
19 | function dfsFind(root, expectNumber, path, currentSum, result) {
20 |     currentSum += root.val;
21 |     path.push(root.val);
22 |     if (currentSum == expectNumber && root.left == null && root.right == null) {
23 |         result.push(path.slice(0));
24 |     }
25 |     if (root.left != null) {
26 |         dfsFind(root.left, expectNumber, path, currentSum, result);
27 |     }
28 |     if (root.right != null) {
29 |         dfsFind(root.right, expectNumber, path, currentSum, result);
30 |     }
31 |     path.pop();
32 | }


--------------------------------------------------------------------------------
/23-complexList/complexList.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/12.
 3 |  */
 4 | function RandomListNode(x) {
 5 |     this.label = x;
 6 |     this.next = null;
 7 |     this.random = null;
 8 | }
 9 | function Clone(pHead) {
10 |     if (!pHead) {
11 |         return null;
12 |     }
13 |     // 复制头结点
14 |     var node = new RandomListNode(pHead.label);
15 |     node.random = pHead.random;
16 |     // 递归其他节点
17 |     node.next = Clone(pHead.next);
18 |     return node;
19 | }


--------------------------------------------------------------------------------
/24-permMutation/permMutation字符串无重复.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/12.
 3 |  */
 4 | function removeArrRepeat(str) {
 5 |     var arr = str.split('');
 6 |     var repeat = {};
 7 |     var resArr = [];
 8 |     arr.forEach(function (item) {
 9 |         if(!repeat[item]){
10 |             repeat[item] = true;
11 |             resArr.push(item);
12 |         }
13 |     })
14 |     return resArr.sort();
15 | }
16 | function swap(arr,ch1,ch2) {
17 |     var item = arr[ch1];
18 |     arr[ch1] = arr[ch2];
19 |     arr[ch2] = item;
20 | }
21 | function perm(arr,begin,end,res) {
22 |     var result="";
23 |     if(end==begin){         //一到递归的出口就输出数组，此数组为全排列
24 |         for(var i=0;i<=end;i++){
25 |             result+=arr[i];
26 |         }
27 |         res.push(result);
28 |     }else {
29 |         for(var j=begin;j<=end;j++){
30 |             swap(arr,begin,j);      //for循环将begin~end中的每个数放到begin位置中去
31 |             perm(arr,begin+1,end,res);  //假设begin位置确定，那么对begin+1~end中的数继续递归
32 |             swap(arr,begin,j);      //换过去后再还原
33 |         }
34 |     }
35 |     return res;
36 | }
37 | function Permutation(str) {
38 |     // write code here
39 |     var arr = removeArrRepeat(str);
40 |     console.log(perm(arr,0,arr.length-1,[]));
41 | }
42 | Permutation("bac");


--------------------------------------------------------------------------------
/24-permMutation/permMutation字符串有重复.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/12.
 3 |  */
 4 | function sortString(arr, sortTemp, res) {
 5 |     if (arr.length == 0) {
 6 |         res.push(sortTemp);
 7 |     } else {
 8 |         var isRepeat = {};
 9 |         for (var i = 0; i < arr.length; i++) {
10 |             if (!isRepeat[arr[i]]) {
11 |                 var temp = arr.splice(i, 1)[0]; // 取出第i个字符
12 |                 sortTemp+= temp; // 第i个字符设为前缀
13 |                 sortString(arr, sortTemp, res);
14 |                 arr.splice(i, 0, temp); // 补全取出的元素，恢复原字符串
15 |                 sortTemp= sortTemp.slice(0, sortTemp.length - 1); // 清空sortTemp
16 |                 isRepeat[temp] = true;
17 |             }
18 |         }
19 |     }
20 |     return res;
21 | }
22 | function Permutation(str) {
23 |     var result = [];
24 |     if (str.length <= 0) {
25 |         return [];
26 |     }
27 |     var sortTemp= "";
28 |     var arr = str.split("");
29 |     result = sortString(arr, sortTemp, []);
30 |     return result;
31 | }
32 | console.log(Permutation("aac"));


--------------------------------------------------------------------------------
/24-permMutation/test.js:
--------------------------------------------------------------------------------
 1 | function swap(arr,ch1,ch2) {
 2 |     var item = arr[ch1];
 3 |     arr[ch1] = arr[ch2];
 4 |     arr[ch2] = item;
 5 | }
 6 | function perm(arr,begin,end,res) {
 7 |     var result="";
 8 |     if(end==begin){         //一到递归的出口就输出数组，此数组为全排列
 9 |         for(var i=0;i<=end;i++){
10 |             result+=arr[i];
11 |         }
12 |         res.push(result);
13 |     }else {
14 |         for(var j=begin;j<=end;j++){
15 |             swap(arr,begin,j);      //for循环将begin~end中的每个数放到begin位置中去
16 |             perm(arr,begin+1,end,res);  //假设begin位置确定，那么对begin+1~end中的数继续递归
17 |             swap(arr,begin,j);      //换过去后再还原
18 |         }
19 |     }
20 |     return res;
21 | }
22 | function Permutation(str) {
23 |     // write code here
24 |     var result=[];
25 |     if(str.length==0){
26 |         return result;
27 |     }
28 |     var arr = str.split("").sort();
29 |     result = perm(arr,0,arr.length-1,[]);
30 |     var res = [];
31 |     var temp = {};
32 |     result.forEach(function (item) {
33 |         if(!temp[item]){
34 |             temp[item] = true;
35 |             res.push(item);
36 |         }
37 |     })
38 |     return res.sort(); //将全排列进行排序,返回需要的结果
39 | }


--------------------------------------------------------------------------------
/25-MoreThanHalfNum_Solution/MoreThanHalfNum_Solution.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/12.
 3 |  */
 4 | function MoreThanHalfNum_Solution(numbers){
 5 |     // write code here
 6 |     var temp = {};
 7 |     var targetCount = 0;
 8 |     if(numbers.length==0){
 9 |         return 0;
10 |     }
11 |     if(numbers.length==1){
12 |         return numbers[0];
13 |     }
14 |     //第一次使用的是targetCount = Math.ceil(numbers.length/2),这个情况如果恰好占一半也会通过
15 |     targetCount = Math.floor(numbers.length/2)+1; //此处是关键，如果是偶数，一半是不符合题意的
16 |     var result = 0;
17 |     numbers.forEach(function(item){
18 |         if(!temp[item]){
19 |             temp[item] = 1;
20 |         }else{
21 |             temp[item]++;
22 |             if(temp[item]>=targetCount){
23 |                 result = item;
24 |             }
25 |         }
26 |     })
27 |     return result;
28 | }
29 | var arr = [4,2,1,4,2,4];
30 | console.log(MoreThanHalfNum_Solution(arr));


--------------------------------------------------------------------------------
/26-GetLeastNumbers_Solution/GetLeastNumbers_Solution.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/13.
 3 |  */
 4 | function GetLeastNumbers_Solution(input, k){
 5 |     // write code here
 6 |     if(k>input.length){
 7 |         return [];
 8 |     }
 9 |     var arr = input.sort(function (a,b) { //调用数组的排序函数，高阶函数进行整数的排序
10 |         return a-b;
11 |     });
12 |     return arr.slice(0,k);
13 | }


--------------------------------------------------------------------------------
/27-FindGreatestSumOfSubArray/FindGreatestSumOfSubArray.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/13.
 3 |  */
 4 | function FindGreatestSumOfSubArray(array){
 5 |     // write code here
 6 |     if(array.length == 0){
 7 |         return 0;
 8 |     }
 9 |     var sum = array[0]; //总和
10 |     var tempSum = array[0]; //临时变量
11 |     for(var i=1;i<array.length;i++){
12 |         if(tempSum < 0){     //如果临时变量<0，那么与后面想加肯定变小，直接复制下一个
13 |             tempSum = array[i];
14 |         }else { //如果大于0,那么相加即可
15 |             tempSum+=array[i];
16 |         }
17 |         sum = (tempSum > sum) ? tempSum : sum;
18 |     }
19 |     return sum;
20 | }


--------------------------------------------------------------------------------
/29-PrintMinNumber/PrintMinNumber.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/13.
 3 |  */
 4 | /*
 5 | 思路：
 6 | ① 本题关键点是制定排序规则，设计比较器；
 7 | ② 排序规则如下：
 8 | 若ab > ba 则 a > b，
 9 | 若ab < ba 则 a < b，
10 | 若ab = ba 则 a = b；
11 | 1.例如：比较 3 和 31 时，'331' > '313'，所以返回结果是 '3' > '31'。
12 | 2.根据指定排序规则对数组进行排序，然后从小到大拼接即为所求结果。
13 | */
14 | 
15 | function Comparator(a, b) {
16 |     var s1 = a + "" + b;
17 |     var s2 = b + "" + a;
18 |     for (var i = 0; i < s1.length; i++) {
19 |         if (s1.charAt(i) > s2.charAt(i)) {
20 |             return 1;
21 |         }
22 |         if (s1.charAt(i) < s2.charAt(i)) {
23 |             return -1;
24 |         }
25 |     }
26 |     return 1;
27 | }
28 | function PrintMinNumber(numbers) {
29 |     numbers.sort(Comparator);
30 |     var result = "";
31 |     for (var i = 0; i < numbers.length; i++) {
32 |         result = result + numbers[i];
33 |     }
34 |     return result;
35 | }


--------------------------------------------------------------------------------
/30-GetUglyNumber_Solution/GetUglyNumber_Solution.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Created by Luffy on 2017/7/13.
 3 |  */
 4 | /*
 5 | 思路：
 6 | ① 按顺序将丑数保存在数组中，然后求下一个丑数；
 7 | ② 下一个丑数是由数组中某个丑数 A * 2，B * 3，C * 5 中的最小值得来的。
 8 | ③ 按照题目规定，第一个丑数是 1，存入数组中；
 9 | ④ 第二个丑数为 1 * 2，1 * 3，1 * 5 三个中的最小值；
10 | ⑤ 第三个丑数为 2 * 2，1 * 3，1 * 5 三个中的最小值，依次类推，求出第 N 个数组。
11 | */
12 | 
13 | function GetUglyNumber_Solution(index){
14 |     // write code here
15 |     if(index == 0){
16 |         return 0;
17 |     }
18 |     var uglyNum = [1];
19 |     var factor2 = 0,factor3 = 0,factor5 = 0;
20 |     for(var i=1;i<index;i++){
21 |         uglyNum[i] = Math.min(uglyNum[factor2]*2,uglyNum[factor3]*3,uglyNum[factor5]*5);
22 |         if(uglyNum[i] == uglyNum[factor2]*2){
23 |             factor2++;
24 |         }
25 |         if(uglyNum[i] == uglyNum[factor3]*3){
26 |             factor3++;
27 |         }
28 |         if(uglyNum[i] == uglyNum[factor5]*5){
29 |             factor5++;
30 |         }
31 |     }
32 |     return uglyNum[index-1];
33 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # offer-javascript
2 | 剑指offer编程题--JavaScript版本
3 | 
4 | 面试刷题必备，剑指offer中的编程题各大企业招聘过程中都会问到相关的内容有的公司甚至直接出原题，因此对于程序员来说是面试之前必刷的一本书。
5 | 
6 | 前端程序员相对算法工程师来说不用掌握太复杂的算法以及数据结构知识，但是基本的算法和数据结构知识也是面试之中的很大一部分，因此用JavaScript来刷剑指offer对前端程序员来说有很大的帮助。
7 | 


--------------------------------------------------------------------------------
/上传操作:
--------------------------------------------------------------------------------
1 | 需要先commit directory
2 | 再进行push操作
3 | 才会成功git到远程仓库


--------------------------------------------------------------------------------