1.題型（找出陣列中重複的數字）

在一個長度為 n 的陣列 nums 裡的所有數字都在 0～n-1 的範圍內。陣列中某些數字是重複的，但不知道有幾個數字重複了，也不知道每個數字重複了幾次。請找出陣列中任意一個重複的數字。

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/shu-zu-zhong-zhong-fu-de-shu-zi-lcof
著作權歸領釦網路所有。商業轉載請聯絡官方授權，非商業轉載請註明出處。

解題思路：利用HashSet去重原理，遍歷新增陣列元素，新增失敗則返回重複元素

程式碼

class Solution {
    public
 
 int findRepeatNumber(int[] nums) {
        HashSet<Integer> set=new HashSet<>();
        for(int num:nums)
        {
            if(set.contains(num))return num;
            set.add(num);
        }
        return -1;
        

    }
}

2.題型（在二維陣列中找到指定的元素）

在一個 n * m 的二維陣列中，每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個高效的函式，輸入這樣的一個二維陣列和一個整數，判斷陣列中是否含有該整數。

示例:

現有矩陣 matrix 如下：

[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
給定 target=5，返回true。

給定target=20，返回false。

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof
著作權歸領釦網路所有。商業轉載請聯絡官方授權，非商業轉載請註明出處。

解題思路：通過找出規律從左下角或者右上角可以矩陣類似於二叉搜尋樹（左邊小於根節點右邊大於根節點）

程式碼

class Solution {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        int i=matrix.length-1;
        int j=0;
       while(i>=0&&j<matrix[0].length)
       {

           if(matrix[i][j]>target)
           {
               i--;
           }
           else if(matrix[i][j]<target)
           {
               j++;
           }
           else
           {
               return true;
           }



       }
       return false;

    }
}

3.替換空格（將字串中的空格替換為指定的字串）

請實現一個函式，把字串 s 中的每個空格替換成"%20"。

示例 1：

輸入：s = "We are happy."
輸出："We%20are%20happy."

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/ti-huan-kong-ge-lcof
著作權歸領釦網路所有。商業轉載請聯絡官方授權，非商業轉載請註明出處。

解題思路：可以用StringBuilder重新拼接字串

class Solution {
    public String replaceSpace(String s) {
      StringBuffer sb= new StringBuffer();
      int len=s.length();
      for(int i=0;i<len;i++)
      {
          if(s.charAt(i)==' ')
          {
            sb.append("%20");
          }
          else
          sb.append(s.charAt(i));
      }
      return sb.toString();
       
       

    }
}

4.從尾到頭列印連結串列

輸入一個連結串列的頭節點，從尾到頭反過來返回每個節點的值（用陣列返回）。

示例 1：

輸入：head = [1,3,2]
輸出：[2,3,1]

解題思路1：反向輸出可以考慮遞迴（藉助LinkedList存資料，最後加入陣列）

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
   LinkedList<Integer> dic=new LinkedList();
    public int[] reversePrint(ListNode head) {
        rec(head);
        int[] res=new int[dic.size()];

        for(int i=0;i<dic.size();i++)
        {
            res[i]=dic.get(i);
        }
        return res;

    }

    void rec(ListNode head){
        if(head==null)return;
        rec(head.next);
        dic.add(head.val);


        


    }
}

解題思路2.利用棧的先入後出特性

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
   LinkedList<Integer> dic=new LinkedList();
    public int[] reversePrint(ListNode head) {
     Stack<Integer> stack=new Stack();
     while(head!=null)
     {
         stack.push(head.val);
         head=head.next;
     }
     while(!stack.isEmpty())
     {
         dic.add(stack.pop());
     }

    int[] res= new int[dic.size()];
    for(int i=0;i<dic.size();i++)
    {


        res[i]=dic.get(i);
    }
return res;
    }

}

class Solution {
    HashMap<Integer,Integer> dic=new HashMap<>();//保留中序遍歷集，以便獲取到先序中根節點在中序中的範圍
    int[] preorder;//記錄先序序列，以便在中序序列中劃分範圍和建立根節點
        
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        this.preorder=preorder;
        for(int i=0;i<inorder.length;i++)
        {
            dic.put(inorder[i],i);
        }
        return rec(0,0,inorder.length-1);

        

    }

    TreeNode rec(int pre_root,int in_left,int in_right){//pre_root記錄先序序列中根節點的位置
        if(in_left>in_right)return null;//以左邊界為例，如果是最後一個節點，根節點下標為0，左邊界為0，右邊界為根節點位置-1，-1
       TreeNode node= new TreeNode(preorder[pre_root]);
       int i= dic.get(preorder[pre_root]);//找到根節點在中序中的位置
       node.left=rec(pre_root+1,in_left,i-1);
       node.right=rec(pre_root+i-in_left+1,i+1,in_right);//pre_root+i-in_left+1：表示先序中右子數根節點位置
       return node;






    }

}