中信卡笔试代码

LeetCode 69. x 的平方根

实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例 1:

输入: 4
输出: 2

示例 2:

输入: 8
输出: 2
说明: 8 的平方根是 2.82842..., 
由于返回类型是整数，小数部分将被舍去。

Coding：

public class Sqrt {

package com.leetcode.two;

import java.util.Scanner;

/**
 * @Auther: Jibny Zhan
 * @Date: 2019/12/3 20:56
 * @Description:
 */
public class Sqrt {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int input = sc.nextInt();
        System.out.println(mySqrt2(input));
    }

    //暴力
    private static int mySqrt(int x) {
        if (x <= 1) return x;
        for (int i = 2; i <= x; i++)
            if (i > x / i)
                return i - 1;
        return -1;
    }

    //二分法
    private static int mySqrt1(int x) {
        if (x <= 1) return x;
        int left = 0, right = x;
        while (left <= right) {
            int mid = (right + left) >>> 1;
            if (mid > x / mid)
                right = mid - 1;
            else
                left = mid + 1;
        }
        return right;
    }

    //牛顿迭代法
    public static int mySqrt2(int x) {
        int res = x;
        while (res > x / res) {
            res = (res + x / res) / 2;
        }
        return res;
    }

}

}

​

LeetCode 109. 有序链表转换二叉搜索树

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定的有序链表： [-10, -3, 0, 5, 9],

一个可能的答案是：[0, -3, 9, -10, null, 5], 
它可以表示下面这个高度平衡二叉搜索树：
     0
    / 
  -3   9
  /   /
-10  5

三种解法

• 二叉树中序遍历数组有序
• 链表快慢指针
• 数组二分递归

Coding：

package com.leetcode;


import java.util.ArrayList;
import java.util.List;

/**
 * @Auther: Jibny Zhan
 * @Date: 2019/12/3 21:18
 * @Description:
 */
public class SortedListToBST {

    private static ListNode pNode;

    public static void main(String[] args) {
        ListNode head = new ListNode(0);
        initListNode(head);
//      TreeNode treeNode = sortedArrayToBST(head);
//      TreeNode treeNode = sortedListToBST(head);
        TreeNode treeNode = sortedTreeToBST(head);
        prePrintTree(treeNode);
        System.out.println();
        midPrintTree(treeNode);
    }

    //中序遍历二叉树得到的就是从小到大的有序数组
    private static TreeNode sortedTreeToBST(ListNode head) {
        int size = findSize(head);
        pNode = head;
        return sortedTreeToBST(0, size - 1);
    }

    private static int findSize(ListNode head) {
        int size = 0;
        while (head != null) {
            head = head.next;
            size++;
        }
        return size;
    }

    private static TreeNode sortedTreeToBST(int start, int end) {
        if (start > end) return null;

        int mid = start + ((end - start) >> 1);
        //划分左右子树
        TreeNode left = sortedTreeToBST(start, mid - 1);

        TreeNode treeNode = new TreeNode(pNode.val);
        treeNode.left = left;

        pNode = pNode.next;

        TreeNode right = sortedTreeToBST(mid+1,end);
        treeNode.right = right;

        return treeNode;
    }



    //快慢指针
    private static TreeNode sortedListToBST(ListNode head) {
        return sortedListToBST(head, null);
    }


    private static TreeNode sortedListToBST(ListNode head, ListNode tail) {
        if (head == null || head == tail)
            return null;
        ListNode slow = head;
        ListNode fast = head;

        while (fast.next != tail && fast.next.next != tail) {
            fast = fast.next.next;
            slow = slow.next;
        }

        TreeNode treeNode = new TreeNode(slow.val);//根节点
        treeNode.left = sortedListToBST(head, slow);
        treeNode.right = sortedListToBST(slow.next, tail);

        return treeNode;
    }


    //转成数组，数组二分，递归构建中心节点
    private static TreeNode sortedArrayToBST(ListNode head) {
        List<Integer> arrayList = new ArrayList<>();
        ListNode p = head;
        while (p != null) {
            arrayList.add(p.val);
            p = p.next;
        }
        return sortedArrayToBST(arrayList, 0, arrayList.size());
    }

    private static TreeNode sortedArrayToBST(List<Integer> arr, int left, int right) {
        if (left == right) return null;
        int mid = (left + right) >>> 1;
        TreeNode treeNode = new TreeNode(arr.get(mid));
        treeNode.left = sortedArrayToBST(arr, left, mid);
        treeNode.right = sortedArrayToBST(arr, mid + 1, right);
        return treeNode;
    }


    //初始化

    public static class ListNode {
        int val;
        ListNode next;

        ListNode(int x) {
            val = x;
        }
    }

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }
    }

    //前序打印
    public static void prePrintTree(TreeNode binTree) {
        if (binTree != null) {
            System.out.println(binTree.val);
            prePrintTree(binTree.left);
            prePrintTree(binTree.right);
        }
    }

    //中序打印
    public static void midPrintTree(TreeNode binTree) {
        if (binTree != null) {
            prePrintTree(binTree.left);
            System.out.println(binTree.val);
            prePrintTree(binTree.right);
        }
    }

    public static ListNode initListNode(ListNode head) {
        ListNode p = head;
        p.val = -10;
        p.next = new ListNode(-3);
        p = p.next;
        p.next = new ListNode(0);
        p = p.next;
        p.next = new ListNode(5);
        p = p.next;
        p.next = new ListNode(9);
        p = p.next;
        p.next = null;
        return head;
    }

}