Leetcode刷题工具类

我在leetcode刷题时，习惯在本地IDE上编码调试，经常需要自己生成输入的参数，如链表、二叉树，因此记录一下平时刷题常用到方法。

public class LeetCodeUtil {

    /**
     * 根据数组生成链表
     *
     * @param arr
     * @return
     */
    public static ListNode genListNode(int[] arr) {
        ListNode n = new ListNode(arr[0]);
        ListNode head = n;
        for (int i = 1; i < arr.length; i++) {
            ListNode node = new ListNode(arr[i]);
            n.next = node;
            n = node;
        }
        n.next = null;
        return head;
    }

    /**
     * 打印链表
     *
     * @param node
     */
    public static void printListNode(ListNode node) {
        while (node != null) {
            String result = node.next == null ? node.val + "" : node.val + ",";
            node = node.next;
            System.out.print(result);
        }
    }

    /**
     * 根据数组生成二叉树
     *
     * @param arr
     * @return
     */
    public static TreeNode genTreeNode(int[] arr) {
        return genTreeNode(arr, 0);
    }

    private static TreeNode genTreeNode(int[] arr, int index) {
        TreeNode node = null;
        if (index < arr.length) {
            node = new TreeNode(arr[index]);
            node.left = genTreeNode(arr, 2 * index + 1);
            node.right = genTreeNode(arr, 2 * index + 2);
        }
        return node;
    }

    /**
     * 按顺序打印二叉树
     *
     * @param root
     */
    public static void printTreeNode(TreeNode root) {
        List list = new ArrayList();
        preOrder(root, list);
        Collections.sort(list);
        System.out.println(list);
    }

    /**
     * 二叉树先序遍历(非递归)
     *
     * @param root
     */
    private static void preOrder(TreeNode root, List list) {
        Stack<TreeNode> stack = new Stack<>();
        while (true) {
            while (root != null) {
//                System.out.print(root.val + ",");
                list.add(root.val);
                stack.push(root);
                root = root.left;
            }
            if (stack.isEmpty()) break;
            root = stack.pop();
            root = root.right;
        }
    }

    /**
     * 打印数组
     *
     * @param arr
     */
    public static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + (i == arr.length - 1 ? "" : ","));
        }
    }

    /**
     * 快排
     *
     * @param arr
     * @param leftIndex
     * @param rightIndex
     */
    public static void quickSort(int[] arr, int leftIndex, int rightIndex) {
        if (leftIndex >= rightIndex) {
            return;
        }
        int left = leftIndex;
        int right = rightIndex;
        //待排序的第一个元素作为基准值
        int key = arr[left];
        //从左右两边交替扫描，直到left = right
        while (left < right) {
            while (right > left && arr[right] >= key) {
                //从右往左扫描，找到第一个比基准值小的元素
                right--;
            }
            //找到这种元素将arr[right]放入arr[left]中
            arr[left] = arr[right];
            while (left < right && arr[left] <= key) {
                //从左往右扫描，找到第一个比基准值大的元素
                left++;
            }
            //找到这种元素将arr[left]放入arr[right]中
            arr[right] = arr[left];
        }
        //基准值归位
        arr[left] = key;
        //对基准值左边的元素进行递归排序
        quickSort(arr, leftIndex, left - 1);
        //对基准值右边的元素进行递归排序。
        quickSort(arr, right + 1, rightIndex);
    }