【好書推薦】《劍指Offer》之硬技能（編程題1~6）

本文例子完整源碼地址：https://github.com/yu-linfeng/BlogRepositories/tree/master/repositories/sword

前一篇《【好書推薦】《劍指Offer》之軟技能》中提到了面試中的一些軟技能，簡歷的如何寫等。《劍指Offer》在后面的章節中主要是一些編程題並配以講解。就算不面試，這些題多做也無妨。可惜的是書中是C++實現，我又重新用Java實現了一遍，如果有錯誤或者更好的解法，歡迎提出交流。

1.賦值運算符函數

　　Java不支持賦值運算符重載，略。

2.實現Singleton模式

　　餓漢模式

/**
* 餓漢模式
* @author OKevin
* @date 2019/5/27
**/
public class Singleton {

   private static Singleton singleton = new Singleton();

   private Singleton() {

   }
   public static Singleton getInstance() {
       return singleton;
   }
}

　　優點：線程安全、不易出錯、性能較高。

　　缺點：在類初始化的時候就實例化了一個單例，占用了內存。

　　飽漢模式一

/**
* 飽漢模式一
* @author OKevin
* @date 2019/5/27
**/
public class Singleton {

   private static Singleton singleton ;

   private Singleton() {

   }
   public static synchronized Singleton getInstance() {
       if (singleton == null) {
           singleton = new Singleton();
       }
       return singleton;
   }
}

　　飽漢模式二

/**
* 飽漢模式二
* @author OKevin
* @date 2019/5/27
**/
public class Singleton {

   private static Singleton singleton ;

   private Singleton() {

   }
   public static Singleton getInstance() {
       if (singleton == null) {
           synchronized (Singleton.class) {
              if (singleton == null) {
                 singleton = new Singleton();
              }
           }
       }
       return singleton;
   }
}

　　優點：線程安全，節省內存，在需要時才實例化對象，比在方法上加鎖性能要好。

　　缺點：由於加鎖，性能仍然比不上餓漢模式。

　　枚舉模式

/**
* 枚舉模式
* @author OKevin
* @date 2019/5/27
**/
public enum Singleton {
   INSTANCE;

   Singleton() {

   }
}

　　在《Effective Java》書中，作者強烈建議通過枚舉來實現單例。另外枚舉從底層保證了線程安全，這點感興趣的讀者可以深入了解下。盡管枚舉方式實現單例看起來比較“另類”，但從多個方面來看，這是最好且最安全的方式。

3.數組中重復的數字

題目：給定一個數組，找出數組中重復的數字。

　　解法一：時間復雜度O(n),空間復雜度O(n)

/**
* 找出數組中重復的數字
* @author OKevin
* @date 2019/5/27
**/
public class Solution {

   public void findRepeat(Integer[] array) {
       Set<Integer> noRepeat = new HashSet<>();
       for (Integer number : array) {
           if (!noRepeat.contains(number)) {
               noRepeat.add(number);
           } else {
               System.out.println("重復數字：" + number);
           }
       }
   }
}

　　*Set底層實現也是一個Map

　　通過Map散列結構，可以找到數組中重復的數字，此算法時間復雜度為O(n)，空間復雜度為O(n)（需要額外定義一個Map）。

　　解法二：時間復雜度O(n^2),空間復雜度O(1)

/**
* 找出數組中重復的數字
* @author OKevin
* @date 2019/5/27
**/
public class Solution {

   public void findRepeat(Integer[] array) {
       for (int i = 0; i < array.length; i++) {
           Integer num = array[i];
           for (int j = i + 1; j < array.length; j++) {
               if (num.equals(array[j])) {
                   System.out.println("重復數字：" + array[j]);
               }
           }
       }
   }
}

　　解法二通過遍歷的方式找到重復的數組元素，解法一相比於解法二是典型的“以空間換取時間”的算法

變形：給定一個長度為n的數組，數組中的數字值大小范圍在0~n-1，找出數組中重復的數字。

　　變形后的題目也可采用上面兩種方法，數字值大小范圍在0~n-1的特點，不借助額外空間（空間復雜度O(1)），遍歷一次（時間復雜度為O(n)）的算法

/**
* 找出數組中重復的數字，數組中的數字值大小范圍在0~n-1
* @author OKevin
* @date 2019/5/27
**/
public class Solution {
   public void findRepeat(Integer[] array) {
       for (int i = 0; i < array.length; i++) {
           while (array[i] != i) {
               if (array[i].equals(array[array[i]])) {
                   System.out.println("重復數字：" + array[i]);
                   break;
               }
               Integer temp = array[i];
               array[i] = array[temp];
               array[temp] = temp;
           }
       }
   }
}

　　分析：變形后的題目中條件出現了，數組中的值范圍在數組長度n-1以內，且最小為0。也就是說，數組中的任意值在作為數組的下標都不會越界，這是一個潛在的條件。根據這個潛在的條件，我們可以把每個值放到對應的數組下標，使得數組下標=數組值。例如：4,2,1,4,3,3。遍歷第一個值4，此時下標為0，數組下標≠數組值，比較array[0]與array[4]不相等->交換，4放到了正確的位置上，得到3,2,1,4,4,3。此時第一個值為3，數組下標仍然≠數組值，比較array[0]與array[3]不想等->交換，3放到了正確的位置，得到4,2,1,3,4,3。此時數組下標仍然≠數組值，比較array[0]與array[4]相等，退出當前循環。依次類推，開始數組下標int=1的循環。

4.二維數組中的查找

題目：給定一個二維數組，每一行都按照從左到右依次遞增的順序排序，每一列都按照從上到下依次遞增的順序排序。輸入一個二維數組和一個整數，判斷該整數是否在二維數組中。

　　解法一：遍歷n*m大小的二維數組，時間復雜度O(n*m)，空間復雜度O(1)

/**
* 二維數組中查找
* @author OKevin
* @date 2019/5/27
**/
public class Solution {

   public boolean isExist(Integer[][] twoArray, Integer target) {
       for (int i = 0; i < twoArray.length; i++) {
           for (int j = 0; j < twoArray[i].length; j++) {
               if (twoArray[i][j].equals(target)) {
                   return true;
               }
           }
       }
       return false;
   }
}

　　優點：簡單暴力。

　　缺點：性能不是最優的，時間復雜度較高，沒有充分利用題目中“有序”的條件。

　　解法二：時間復雜度O(n+m)，空間復雜度O(1)

/**
* 二維數組中查找
* @author OKevin
* @date 2019/5/27
**/
public class Solution {

   public boolean isExist(Integer[][] twoArray, Integer target) {
       int x = 0;
       int y = twoArray[0].length - 1;
       for (int i = 0; i < twoArray.length-1 + twoArray[0].length-1; i++) {
           if (twoArray[x][y].equals(target)) {
               return true;
           }
           if (twoArray[x][y] > target) {
               y--;
               continue;
           }
           if (twoArray[x][y] < target) {
               x++;
           }
       }
       return false;
   }
}

　　分析：通過舉一個實例，找出規律，從右上角開始查找。

　　Integer[][] twoArray = new Integer[4][4];

　　twoArray[0] = new Integer[]{1, 2, 8, 9};

　　twoArray[1] = new Integer[]{2, 4, 9, 12};

　　twoArray[2] = new Integer[]{4, 7, 10, 13};

　　twoArray[3] = new Integer[]{6, 8, 11, 15};

5.替換空格

題目：將字符串中的空格替換為“20%”。

　　解法一：根據Java提供的replaceAll方法直接替換

/**
* 字符串空格替換
* @author OKevin
* @date 2019/5/28
**/
public class Solution {
   public String replaceSpace(String str) {
       return str.replaceAll(" ", "20%");
   }
}

　　這種解法沒什么可說。但可以了解一下replaceAll的JDK實現。replaceAll在JDK中的實現是根據正則表達式匹配要替換的字符串。

　　解法二：利用空間換時間的方式替換

/**
* 字符串空格替換
* @author OKevin
* @date 2019/5/28
**/
public class Solution {
   public String replaceSpace(String str, String target) {
       StringBuilder sb = new StringBuilder();
       for (char c : str.toCharArray()) {
           if (c == ' ') {
               sb.append(target);
               continue;
           }
           sb.append(c);
       }
       return sb.toString();
   }
}

6.從尾到頭打印鏈表

題目：輸入一個鏈表的頭節點，從尾到頭反過來打印出每個節點的值。

*由於《劍指Offer》采用C++編程語言，這題需要我們先構造出一個節點，模擬出鏈表的結構。

　　定義節點

/**
* 鏈表節點定義
* @author OKevin
* @date 2019/5/29
**/
public class Node {
   /**
    * 指向下一個節點
    */
   private Node next;
   /**
    * 表示節點的值域
    */
   private Integer data;

   public Node(){}

   public Node(Integer data) {
       this.data = data;
   }
   //省略getter/setter方法
}

　　解法一：利用棧先進后出的特點，遍歷鏈表放入棧中，再從棧推出數據

/**
* 逆向打印鏈表的值
* @author OKevin
* @date 2019/5/29
**/
public class Solution {
   public void tailPrint(Node head) {
       Stack<Node> stack = new Stack<>();
       while (head != null) {
           stack.push(head);
           head = head.getNext();
       }
       while (!stack.empty()) {
           System.out.println(stack.pop().getData());
       }
   }
}

　　這種解法“不幸”地借助了額外的空間。

　　解法二：既然使用棧的結構，實際上也就可以使用遞歸的方式逆向打印鏈表

/**
* 逆向打印鏈表的值
* @author OKevin
* @date 2019/5/29
**/
public class Solution {
   public void tailPrint(Node head) {
       if (head.getNext() != null) {
           tailPrint(head.getNext());
       }
       System.out.println(head.getData());
   }
}

　　使用遞歸雖然避免了借助額外的內存空間，但如果鏈表過長，遞歸過深易導致調用棧溢出。

　　測試程序：

/**
* @author OKevin
* @date 2019/5/29
**/
public class Main {
   /**
    * 1->2->3->4->5
    * @param args
    */
   public static void main(String[] args) {
       Node node1 = new Node(1);
       Node node2 = new Node(2);
       Node node3 = new Node(3);
       Node node4 = new Node(4);
       Node node5 = new Node(5);
       node1.setNext(node2);
       node2.setNext(node3);
       node3.setNext(node4);
       node4.setNext(node5);

       Node head = node1;

       Solution solution = new Solution();
       solution.tailPrint(head);
   }
}

　　 本文例子完整源碼地址：https://github.com/yu-linfeng/BlogRepositories/tree/master/repositories/sword

　　持續更新，敬請關注公眾號:coderbuff，回復關鍵字“sword”獲取相關電子書。

 

 

這是一個能給程序員加buff的公眾號 （CoderBuff）