NC_40_MERGETWOLINKLIST NC_41_LONGEST_SUBARR NC_42_PERMUTATION

package org.example.interview.practice;

import java.util.ArrayDeque;
import java.util.Deque;

/**
 * @author xianzhe.ma
 * @date 2021/7/13
 */

public class NC_40_MERGETWOLINKLIST {

      public static class ListNode {
          int val;
          ListNode next = null;

          public ListNode(int val) {
              this.val = val;
          }
      }

    public static ListNode addInList (ListNode head1, ListNode head2) {
        // write code here
        Deque<Integer> queueA = new ArrayDeque<>();
        Deque<Integer> queueB = new ArrayDeque<>();

        for ( ; head1!= null; head1 = head1.next) {
            queueA.addLast(head1.val);
        }

        for ( ; head2!= null; head2 = head2.next) {
            queueB.addLast(head2.val);
        }
        int highValue = 0;//装进位的
        ListNode result = null;
        ListNode last = null;

        while (!queueA.isEmpty() && !queueB.isEmpty()) {
            int number1 = queueA.pollLast();
            int number2 = queueB.pollLast();
            int val = (number1 + number2 + highValue) % 10;
            highValue = (number1 + number2 + highValue) / 10;


            ListNode node = new ListNode(val);

            if (result == null) {
                result = node;
//                last = node;
            } else {
                node.next = result;
                result = node;
            }

        }

        while (!queueA.isEmpty()) {
            int number1 = queueA.pollLast();
            int val = (number1 + highValue) % 10;
            highValue = (number1 + highValue) / 10;

            ListNode node = new ListNode(val);

            if (result == null) {
                result = node;
//                last = node;
            } else {
                node.next = result;
                result = node;
            }
        }

        while (!queueB.isEmpty()) {
            int number1 = queueB.pollLast();
            int val = (number1 + highValue) % 10;
            highValue = (number1 + highValue) / 10;

            ListNode node = new ListNode(val);

            if (result == null) {
                result = node;
//                last = node;
            } else {
                node.next = result;
                result = node;
            }
        }
        if (highValue != 0) {
            ListNode node = new ListNode(highValue);
            node.next = result;
            result = node;
        }
        return result;
    }

    public static void main (String[] args) {
        int[] arrA = {9,3,7};
        int[] arrB = {6,3};
        ListNode listA = buildLinkList(arrA);
        ListNode listB = buildLinkList(arrB);

        ListNode result = addInList(listA, listB);

    }

    public static ListNode buildLinkList(int[] arr) {
        ListNode listA = null;
        ListNode last = null;
          for (int i : arr) {
              ListNode node = new ListNode(i);
              if (listA == null) {
                  listA = node;
                  last = node;
              }
              last.next = node;
              last = node;
          }
        return listA;
    }
}

package org.example.interview.practice;

import java.util.HashMap;
import java.util.Map;

/**
 * @author xianzhe.ma
 * @date 2021/7/7
 */

public class NC_41_LONGEST_SUBARR {

    public int maxLength(int[] arr) {
        // write code here
        if (arr.length == 0)
            return 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        int max = 0;
        for (int i = 0, j = 0; i < arr.length; ++i) {
            if (map.containsKey(arr[i])) {
                j = Math.max(j, map.get(arr[i]) + 1);
            }
            map.put(arr[i], i);
            max = Math.max(max, i - j + 1);
        }
        return max;
    }

    public static int maxLength2(int[] arr) {
        // write code here
        if (arr.length == 0)
            return 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        int max = 0;
        for (int i = 0, j = 0; i < arr.length; ++i) {
            if (map.containsKey(arr[i])) {
//                j = Math.max(j, map.get(arr[i]) + 1);
                j = map.get(arr[i]) + 1;
            }
            map.put(arr[i], i);
            max = Math.max(max, i - j + 1);
        }
        return max;
    }

    public static int maxLength3(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }

        int maxlength = 0;
        Map<Integer, Integer> positionMap = new HashMap<>();
        int i = 0, j = 0;
        for (; i < arr.length; i++) {
            if (positionMap.containsKey(Integer.valueOf(arr[i]))) {
                j = Math.max(j, positionMap.get(arr[i]) + 1);
            }
            positionMap.put(arr[i], i);
            maxlength = Math.max(maxlength, i - j + 1);
        }

        return maxlength;
    }

    public static void main(String[] args) {
        int[] arr = {3, 3, 2, 1, 3, 3, 3, 1};
        System.out.println(maxLength3(arr));
    }
}

package org.example.interview.practice;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

/**
 * @author xianzhe.ma
 * @date 2021/7/27
 */

public class NC_42_PERMUTATION {

    //用于标记是否访问过
    static boolean[] mark;
    public static ArrayList<ArrayList<Integer>> permuteUnique(int[] num) {
        //存储总的返回结果集
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        //存储一个合法全排列
        LinkedList<Integer> track = new LinkedList<>();

        mark = new boolean[num.length];
        //因为存在重复项，为了更好的处理，将数组先排序
        Arrays.sort(num);

        backtrack(num,res,track);

        return res;
    }

    public static void backtrack(int[] num, ArrayList<ArrayList<Integer>> res, LinkedList<Integer> track){
        //若 找到一个全排列，则将它加进结果集中，然后返回(回溯)
        if(track.size() == num.length){
            res.add(new ArrayList<Integer>(track));
            return;
        }
        for(int i = 0; i < num.length; i++){
            // 当此时的被访问过
            // 当i>0 &&此时的数等于它的上一个&&上一个没访问过(没访问过证明是回溯后将前面的置为false，所以此时避免重复得用 !mark[i-1] 满足要求然后跳过该数字)
            // arr[1,1,1,2,3]
            // 1,1,1  1,1,2 1,1,3  前面两次回溯得到三个结果
            // 接下来再进行回溯，此时mark[1]被置为false
            // 此时按道理应该遍历到arr[2]这个位置
            // 1,arr[2] 然后后面再加进去，但是我们发现arr[2]==arr[1]，并且此时mark[1]==false
            // 证明它的已经访问过然后回溯的，所以我们跳过arr[2],直接从1,arr[3]开始
            // 也就是说此时得到全排列的结果将会是 1,2,1 1,2,3 而不再是 1,1 ··· 这些重复的了
            if(mark[i] || i>0 && num[i] == num[i-1] && !mark[i-1]){
                continue;
            }
            //添加进全排列数组中
            track.add(num[i]);
            //标记为已经访问
            mark[i] = true;
            //继续寻找下一个数
            backtrack(num,res,track);
            //将上一次全排列的结果中，最后一个数移除掉
            track.removeLast();
            //移除掉的数置为 未访问
            mark[i] = false;
        }
    }

    public static void main (String[] args) {
        int[] num  = {1,2,1};
        ArrayList<ArrayList<Integer>> res = permuteUnique (num);

        for (ArrayList<Integer> item : res) {
            System.out.println(item.toString());
        }
    }
}