威尼斯人线上娱乐

探究插入地方,一些算法题及答案

5 5月 , 2019  

给定四个排序数组和3个对象值,在数组中找到对象值,并回到其索引。借使目的值不存在于数组中,重返它将会被按梯次插入的任务。

给定三个排序数组和四个对象值,在数组中找到对象值,并赶回其索引。如果指标值不设有于数组中,重临它将会被按顺序插入的职责。

那是根源于leetcode的难题:

一. 两数之和

给定1个平头数组 nums 和三个对象值
target,请您在该数组中搜索和为目的值的那 两个
整数,并重临他们的数组下标。

你能够即便每个输入只会相应四个答案。不过,你不能够重复使用那些数组中同样的因素。

示例:

给定 nums = [2, 7, 11, 15], target = 9因为 nums[0] + nums[1] = 2 + 7 = 9所以返回 [0, 1]

/**

     * 暴力枚举法

     * @param nums

     * @param target

     * @return

     */

    public static int[] twoSum(int[] nums, int target) {

        int lgn = nums.length;

        for(int i = 0; i < lgn; i++){

            for(int j = i + 1; j < lgn; j++){

                if(nums[i] + nums[j] == target){

                    return new int[]{i, j};

                }

            }

        }

        return new int[0];

    }

    /**

     * MAP 处理

     * @param nums

     * @param target

     * @return

     */

    public static int[] twoSum1(int[] nums, int target) {

        Map<Integer, Integer> map = new HashMap<>();

        for (int i = 0; i < nums.length; i++) {

            int complement = target - nums[i];

            if (map.containsKey(complement)) {

                return new int[] { complement, nums[i] };

            }

            map.put(nums[i], i);

        }

        return new int[0];

    }

您能够即使数组中无重复成分。

您能够要是数组中无重复成分。

  给定三个平头数组 nums 和三个目的值
target,请你在该数组中寻找和为目的值的 三个 整数。
  你能够倘若每个输入只会相应一个答案。可是,你不能够重复使用那几个数组中一致的因素。

二. 两数相加

交由三个 非空
的链表用来表示五个非负的平头。当中,它们各自的位数是比照 逆序
的办法存储的,并且它们的种种节点只好存款和储蓄 一位 数字。

假如,大家将那四个数相加起来,则会回到贰个新的链表来代表它们的和。

你能够即使除了数字 0 之外,那四个数都不会以 0 先河。

示例:

输入:(2 -> 4 -> 3) + (5 -> 6 -> 4)输出:7 -> 0 -> 8原因:342 + 465 = 807

/**

     * 链表相应位置依次相加,最后处理进位

     * @param l1

     * @param l2

     * @return

     */

    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {

        ListNode head = null;

        ListNode curr = null;

        while (l1 != null || l2 != null){

            if(l1 != null && l2 != null){

                ListNode node = new ListNode(l1.val + l2.val);

                if(curr == null && head == null) head = node;

                curr = initNode(curr, node);

            }else{

                curr = initNode(curr, new ListNode(l1 != null?l1.val:l2.val));

            }

            l1 = l1 != null?l1.next:null;

            l2 = l2 != null?l2.next:null;

        }

        curr = head;

        while (curr != null){

            if(curr.val >= 10){

                curr.val -= 10;

                if(curr.next == null){

                    curr.next = new ListNode;

                }else {

                    curr.next.val += 1;

                }

            }

            curr = curr.next;

        }

        curr = null;

        return head;

    }

    public ListNode initNode(ListNode curr, ListNode newNode){

        if(curr != null){

            curr.next = newNode;

        }

        curr = newNode;

        return curr;

    }

示例 1:

示例 1:

那是出现说法:
  给定 nums = [2, 7, 11, 15], target = 9
  因为 nums[0] + nums[1] = 2 + 7 = 9
  所以重回 [0, 1]

三. 寻找四个有序数组的中位数

给定多少个大小为 m 和 n 的有序数组 nums1nums2

请你搜索那多少个有序数组的中位数,并且供给算法的时刻复杂度为 O(log。

您能够借使 nums1nums2 不会同时为空。

示例 1:

nums1 = [1, 3]nums2 = [2]则中位数是 2.0

示例 2:

nums1 = [1, 2]nums2 = [3, 4]则中位数是 /2 = 2.5

/**

     * 使用两个排序数据组的归并过程

     * 分别定义两个数组的遍历索引,每次对比提取相应数组的元素

     * 不实际存储归并后的数据,

     * 处理前半数元素即可

     * @param nums1

     * @param nums2

     * @return

     */

    public static double findMedianSortedArrays(int[] nums1, int[] nums2) {

        int lgn1 = nums1.length;

        int lgn2 = nums2.length;

        int allLgn = lgn1 + lgn2;

        int middleIndex = allLgn/2;

        int middleLeft = 0,middleRight = 0;

        int index1 = 0;

        int index2 = 0;

        int curr = 0;

        for (int i = 0; i < middleIndex + 1; i++) {

            if(index1 < lgn1 && index2 < lgn2) {

                if (nums1[index1] > nums2[index2]) {

                    curr = nums2[index2];

                    index2++;

                } else {

                    curr = nums1[index1];

                    index1++;

                }

            }else if(index1 < lgn1){

                curr = nums1[index1];

                index1++;

            }else if(index2 < lgn2){

                curr = nums2[index2];

                index2++;

            }

            if(i == middleIndex - 1){

                middleLeft = curr;

            }

            if(i == middleIndex){

                middleRight = curr;

            }

        }

        if(allLgn%2 == 0){

            return (middleLeft + middleRight)/2.0;

        }else {

            return middleRight;

        }

    }
输入: [1,3,5,6], 5
输出: 2

输入: [1,3,5,6], 5
输出: 2
示例 2:

重中之重记录的是使用哈希表来缓和难题:

4. Z 字形调换

将二个给定字符串依照给定的行数,以从上往下、从左到右进行 Z 字形排列。

诸如输入字符串为 "LEETCODEISHIRING" 行数为 三 时,排列如下:

L   C   I   RE T O E S I I GE   D   H   N

以后,你的输出必要从左往右逐行读取,产生出贰个新的字符串,比如:"LCIRETOESIIGEDHN"

请您兑现那个将字符串举行点名行数调换的函数:

string convert(string s, int numRows);

示例 1:

输入: s = "LEETCODEISHIRING", numRows = 3输出: "LCIRETOESIIGEDHN"

示例 2:

输入: s = "LEETCODEISHIRING", numRows = 4输出: "LDREOEIIECIHNTSG"解释:L     D     RE   O E   I IE C   I H   NT     S     G

/**

     * 定义目标行数个链表,如示例,每次中间间隔的 numRows - 2 个列表逐个填充一个值

     * 便利给定的字符串,依次处理,直到末尾

     * @param s

     * @param numRows

     * @return

     */

    public static String convert(String s, int numRows) {

        if(numRows == 1){

            return s;

        }

        String result = "";

        if(numRows == 2){

            result = "";

            for (int i = 0; i < s.length(); i = i + 2) {

                result += s.charAt;

            }

            for (int i = 1; i < s.length(); i = i + 2) {

                result += s.charAt;

            }

            return result;

        }

        int middleCount = numRows - 2;

        List[] all = new LinkedList[numRows];

        for (int i = 0; i < numRows; i++) {

            all[i] = new LinkedList<>();

        }

        int sIndex = 0;

        int step = 0;

        while (sIndex < s.length{

            for (int i = 0; i < numRows; i++) {

                if(sIndex == s.length break;

                all[i].add(s.charAt;

                sIndex++;

            }

            for (int j = numRows - 2; j > 0 ; j--) {

                if(sIndex == s.length break;

                all[j].add(s.charAt;

                sIndex++;

            }

            step = step + middleCount;

        }

        for (int i = 0; i < numRows; i++) {

            for (int j = 0; j < all[i].size {

                result += all[i].get;

            }

        }

        return result;

    }

示例 2:

输入: [1,3,5,6], 2
输出: 1
示例 3:

  因为要出口的是列表的目录,所以接纳列表内容作为键,以索引作为值,方便寻找,创建二个字典。

伍. 平头五花大绑

交由二个 3二 位的有号子整数,你须要将以此平头中每人上的数字举办反转。

示例 1:

输入: 123输出: 321

示例 2:

输入: -123输出: -321

示例 3:

输入: 120输出: 21

注意:

一旦大家的条件只可以存款和储蓄得下 3二 位的有号子整数,则其数值范围为 [−231, 231
− 1]。请依据那个只要,假设反转后整数溢出那么就回到 0。

/**

     * 数据范围判断

     * @param x

     * @return

     */

    public static int reverse(int x) {

        double result = 0;

        while {

            result = result * 10 + x%10;

            if (result > Integer.MAX_VALUE) return 0;

            if (result < Integer.MIN_VALUE) return 0;

            x = x/10;

        }

        return (int) result;

    }
输入: [1,3,5,6], 2
输出: 1

输入: [1,3,5,6], 7
输出: 4
示例 4:

# 使用内置函数 zip() 打包hash_ = dict(zip(nums, range)))

6. 回文数

判定贰个平头是或不是是回文数。回文数是指正序和倒序读都以同等的整数。

/**

     * 转化为字符串,一次便利,首末对称位置对比

     * @param x

     * @return

     */

    public static boolean isPalindrome(int x) {

        String s = String.valueOf;

        int lgn = s.length();

        for (int i = 0,j = lgn -1; i <= j; i++,j--){

            if(s.charAt == s.charAt{

                continue;

            }else {

                return false;

            }

        }

        return true;

    }

示例 3:

输入: [1,3,5,6], 0
输出: 0

以示范为例,得到的将是:{二: 0, 7: 一, 1一: 二, 壹伍: 3}

7. 盛最多水的器皿

给定 n 个非负整数 a1,a2,…,a探究插入地方,一些算法题及答案。n,各个数代表坐标中的三个点
(i, ai) 。在坐标内画 n 条垂直线,垂直线 i 的七个端点分别为 (i,
ai) 和 (i, 0)。搜索当中的两条线,使得它们与 x
轴共同构成的容器能够包容最多的水。

说明:您不能够倾斜容器,且 n 的值至少为 贰。

/**

     * 枚举

     * @param height

     * @return

     */

    public static int maxArea(int[] height) {

        int area = 0, lgn = height.length;

        if(lgn < 2) return 0;

        for (int i = 0; i < lgn; i++) {

            for (int i1 = i + 1; i1 < lgn; i1++) {

                int tmpArea = (height[i]>height[i1]?height[i1]:height[i]) * ;

                if(tmpArea > area){

                    area = tmpArea;

                }

            }

        }

        return area;

    }

    /**

     * 双指针

     * @param height

     * @return

     */

    public static int maxArea2(int[] height) {

        int area = 0, lgn = height.length;

        if(lgn < 2) return 0;

        for (int i = 0, j = lgn - 1; i < j; ) {

            int tmpArea = (height[i]>height[j]?height[j]:height[i]) * Math.abs;

            if(tmpArea > area){

                area = tmpArea;

                i++;//正方向前进一步,避免反方向遍历时,重复比较

            }else {

                j--;//反方向前进一步,避免正方向遍历时,重复比较

            }

        }

        return area;

    }
输入: [1,3,5,6], 7
输出: 4

  接着将对象值与各样值相减后收获的叁个值,查找哈希表中是还是不是留存这一个值:

八. 平头转埃及开罗数字

布加勒斯特数字带有以下多样字符: IVXL威尼斯人线上娱乐 ,,CDM

字符          数值I             1V             5X             10L             50C             100D             500M             1000

比方, 秘Luli马数字 二 写做 II ,即为三个并列的 壹。1二 写做 XII ,即为 X

  • II 。 27 写做 XXVII, 即为 XX + V + II

普通意况下,休斯敦数字中型小型的数字在大的数字的右边手。但也存在特例,比如 4不写做 IIII,而是 IV。数字 一 在数字 伍 的左边,所代表的数等于大数 5减小数 一 获得的数值 四 。一样地,数字 九 表示为
IX。这些特殊的条条框框只适用于以下多样情况:

  • I 能够放在 VX 的左边,来表示 4 和 9。
  • X 能够放在 LC 的左边,来表示 40 和 90。
  • C 能够放在 DM 的左边,来表示 400 和 900。

给定2个平头,将其转为杜塞尔多夫数字。输入确定保证在 一 到 399玖 的限制内。

public static String intToRoman(int num) {

        if(num > 3999) return "";

        if(num/1000 > 0){

            return dealQianWei;

        }else if(num/100 > 0){

            return dealBaiWei;

        }else if(num/10 > 0){

            return dealShiWei;

        }else {

            return dealGeWei;

        }

    }

    /**

     * 千位

     * @param num

     * @return

     */

    public static String dealQianWei(int num){

        return countStr(num/1000, "M") + dealBaiWei;

    }

    /**

     * 百位

     * @param num

     * @return

     */

    public static String dealBaiWei(int num){

        int bc = num/100;

        if return "CM" + dealShiWei(num % 100);

        if return "CD" + dealShiWei(num % 100);

        int fbc = num/500;

        num = num%500;

        return countStr(fbc, "D") + countStr(num/100, "C") + dealShiWei;

    }

    /**

     * 十位

     * @param num

     * @return

     */

    public static String dealShiWei(int num){

        int tens = num/10;

        if(tens == 9) return "XC" + dealGeWei;

        if(tens == 4) return "XL" + dealGeWei;

        int ftens = num/50;

        num = num%50;

        return countStr(ftens, "L") + countStr(num/10, "X") + dealGeWei;

    }

    /**

     * 个位

     * @param num

     * @return

     */

    public static String dealGeWei(int num){

        if return "IX";

        if return "IV";

        if(num >= 5) return "V" + dealGeWei;

        return countStr(num, "I");

    }

    public static String countStr(int count, String num){

        if(count == 0) return "";

        String result = "";

        for (int i = 0; i < count; i++) {

            result += num;

        }

        return result;

    }

示例 4:

“””
已排序这一个原则下,首要侦察二分查找,当未找到时间接再次来到最终一遍决断的数组地方就可以
“””

for i in range):             num=target-nums[i]             if hash_.get:                 # 判定相同索引不作为结果输出:                if i != hash_[num]:                    return [i,hash_[num]]

九. 三数之和

给定一个含有 n 个整数的数组 nums,判断 nums 中是不是存在八个因素
a,b,c ,使得 a + b + c = 0 ?寻找装有知足条件且不另行的安慕希组。

注意:答案中不得以分包重复的长富组。

注意:使用方面包车型大巴两数值和

public static List<List<Integer>> threeSum(int[] nums) {

        if(nums == null || nums.length < 3) return new ArrayList();

        Set<List<Integer>> result = new HashSet<>();

        List<Integer> numList = new ArrayList();

        for (int num : nums) {

            numList.add;

        }

        for (Integer num : numList) {

            List<Integer> copy = new ArrayList();

            copy.addAll;

            copy.remove;

            List<int[]> tmp = twoSum(copy, -num);

            if(tmp.size{

                for (int[] ints : tmp) {

                    List<Integer> list = new ArrayList(){{add;add;add;}};

                    Collections.sort;

                    result.add;

                }

            }

        }

        return new ArrayList;

    }

    public static List<int[]> twoSum(List<Integer> nums, int target) {

        List<int[]> result = new ArrayList();

        Map<Integer, Integer> map = new HashMap<>();

        for (int i = 0; i < nums.size {

            int complement = target - nums.get;

            if (map.containsKey(complement)) {

                result.add(new int[] { complement, nums.get;

            }

            map.put(nums.get;

        }

        return result;

    }
输入: [1,3,5,6], 0
输出: 0

class Solution:
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """

        index=-1
        last=0
        try:
            return nums.index(target)
        except:
            for i in range(len(nums)):
                if target > nums[i]:
                    last+=1
        nums.insert(last,target)
        return index if index > 1 else last
class Solution:
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        low, high = 0, len(nums)
        while low < high:
            mid = (low + high) // 2
            guess = nums[mid]
            if target > guess:
                low = mid + 1
            elif target < guess:
                high = mid
            else:
                return mid
        return low #未找到target最后一次判断的位置就是插入位置

收获结果:[0, 1]

10. 最接近的3数之和

给定一个囊括 n 个整数的数组 nums和 三个目的值 target。找出
nums中的四个整数,使得它们的和与 target
最相仿。再次来到那多少个数的和。假定每组输入只设有唯壹答案。

例如,给定数组 nums = [-1,2,1,-4], 和 target = 1.与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).

public static int threeSumClosest(int[] nums, int target) {

        int min = Integer.MAX_VALUE;

        int ele1 = 0, ele2 = 0, ele3 = 0;

        for (int i = 0; i < nums.length; i++) {

            for (int i1 = 0; i1 < nums.length; i1++) {

                if  continue;

                for (int i2 = 0; i2 < nums.length; i2++) {

                    if (i2 == i1 || i2 == i) continue;

                    int sum = Math.abs(nums[i] + nums[i1] + nums[i2] - target);

                    if (sum < min) {

                        min = sum;

                        ele1 = nums[i];

                        ele2 = nums[i1];

                        ele3 = nums[i2];

                    }

                }

            }

        }

        return ele1 + ele2 + ele3;

    }

 

11. 缺点和失误的首先个正数

给定3个未排序的整数数组,寻找个中未有出现的细小的正整数。

示例 1:

输入: [1,2,0]输出: 3

示例 2:

输入: [3,4,-1,1]输出: 2

示例 3:

输入: [7,8,9,11,12]输出: 1

/**

     * 数组操作

     * @param nums

     * @return

     */

    public static int firstMissingPositive(int[] nums) {

        int max = 0;

        for (int i = 0; i < nums.length; i++) {

            if(nums[i] < 0) continue;

            if(nums[i] > max){

                max = nums[i];

            }

        }

        max = max == Integer.MAX_VALUE?max:max + 2;

        for (int i = 1; i < max; i++) {

            if(contains continue;

            return i;

        }

        return max + 1;

    }

    public static boolean contains(int[] nums, int ele){

        for (int i = 0; i < nums.length; i++) {

            if(nums[i] == ele) return true;

        }

        return false;

    }

    /**

     * map操作

     * @param nums

     * @return

     */

    public static int firstMissingPositive1(int[] nums) {

        Map<Integer, Integer> vs = new HashMap<>();

        int max = 0;

        for (int i = 0; i < nums.length; i++) {

            if(nums[i] < 0) continue;

            if(nums[i] > max){

                max = nums[i];

            }

            vs.put(nums[i], i);

        }

        max = max == Integer.MAX_VALUE?max:max + 2;

        for (int i = 1; i < max; i++) {

            if(vs.get != null) continue;

            return i;

        }

        return max + 1;

    }

12. 接雨水

给定 n 个非负整数表示各类宽度为 1的柱子的万丈图,总结按此排列的柱子,降水之后能接多少冬至。

威尼斯人线上娱乐 1

上边是由数组 [0,1,0,2,1,0,1,3,2,1,2,1]
表示的万丈图,在那种景色下,能够接 陆 个单位的大寒。 感谢 Marcos
进献此图。

示例:

输入: [0,1,0,2,1,0,1,3,2,1,2,1]输出: 6

/**

     * 分割

     * @param height

     * @return

     */

    public static int trap(int[] height) {

        //最大索引位置

        int maxIndex = findMax;



        int lsubMaxindex = maxIndex, rsubMaxIndex = maxIndex;

        int area = 0;

        //左边处理

        while (lsubMaxindex > 0){

            int tmpMax = lsubMaxindex;

            lsubMaxindex = findMax(Arrays.copyOfRange(height, 0, tmpMax));

            area += height[lsubMaxindex] * (tmpMax - lsubMaxindex - 1);

            for (int i = lsubMaxindex + 1; i < tmpMax; i++) {

                area -= height[i] * 1;

            }

        }

        //右边处理

        while (rsubMaxIndex < height.length - 1){

            int tmpMax = rsubMaxIndex;

            rsubMaxIndex = tmpMax + findMax(Arrays.copyOfRange(height, tmpMax + 1, height.length)) + 1;

            area += height[rsubMaxIndex] * (rsubMaxIndex - tmpMax - 1);

            for (int i = tmpMax + 1; i < rsubMaxIndex; i++) {

                area -= height[i] * 1;

            }

        }

        return area;

    }

    public static int findMax(int[] nums){

        int max = 0, maxIndex = 0;

        for (int i = 0; i < nums.length; i++) {

            if(nums[i] > max){

                max = nums[i];

                maxIndex = i;

            }

        }

        return maxIndex;

    }

壹三. 字符串相乘

给定五个以字符串情势表示的非负整数 num1num2,返回 num1
num2 的乘积,它们的乘积也意味为字符串情势。

示例 1:

输入: num1 = "2", num2 = "3"输出: "6"

示例 2:

输入: num1 = "123", num2 = "456"输出: "56088"

说明:

  1. num1num2 的尺寸小于110。
  2. num1num2 只包蕴数字 0-9
  3. num1num2 均不以零开头,除非是数字 0 本人。
  4. 不可能利用别的规范库的天命类型(比方BigInteger)一贯将输入转变为整数来拍卖

public static String multiply(String num1, String num2) {

        if(num1 == null || num2 == null || "".equals || "".equals || "0".equals || "0".equals return String.valueOf;

        int lgn1 = num1.length(), lgn2 = num2.length();

        int[] result = new int[lgn1 + lgn2];

        int resultIndex = result.length - 1;

        for (int i = lgn1 - 1; i > -1 ; i--) {

            int first = Integer.parseInt(String.valueOf(num1.charAt;

            int innerIndex = 0;

            for (int j = lgn2 - 1; j > -1 ; j--) {

                int second = Integer.parseInt(String.valueOf(num2.charAt;

                int plus = first * second;

                result[resultIndex - innerIndex] += plus%10;

                if(plus >= 10) {

                    result[resultIndex - innerIndex - 1] += plus / 10;

                }

                innerIndex++;

            }

            resultIndex--;

        }

        //处理进位

        StringBuilder sb = new StringBuilder();

        for (int i = result.length - 1; i >= 0; i--) {

            if(result[i]>=10) {

                result[i - 1] += result[i]/10;

                result[i] %= 10;

            }

        }

        //提取有效位

        boolean start = false;

        for (int i = 0; i < lgn1 + lgn2 ; i++) {

            if(!start && result[i] != 0){

                start = true;

            }

            if{

                sb.append(result[i]);

            }

        }

        return sb.toString();

    }

14. 踊跃游戏 II

给定二个非负整数数组,你最初位于数组的率先个地点。

数组中的每个成分代表你在该职位能够跳跃的最大尺寸。

您的目的是接纳最少的跳跃次数达到数组的末尾二个职位。

示例:

输入: [2,3,1,1,4]输出: 2解释: 跳到最后一个位置的最小跳跃数是 2。 从下标为 0 跳到下标为 1 的位置,跳 1 步,然后跳 3 步到达数组的最后一个位置。

说明:

要是你总是能够到达数组的最后一个职位。

/**

     * 枚举遍历

     * @param nums

     * @return

     */

    public static int jump(int[] nums) {

        if(nums == null || nums.length == 1) return 0;

        if(nums.length == 2) return 1;

        int steps = Integer.MAX_VALUE/2;

        int initStep = 1;

        if(nums[0] >= nums.length - 1) return 1;

        if(nums[0] == 0) return steps;

        while (initStep <= nums[0]){

            int subNeedStep = jump(Arrays.copyOfRange(nums, initStep, nums.length));

            if(subNeedStep + 1 < steps){

                steps = subNeedStep + 1;

            }

            initStep++;

        }

        return steps;

    }

    /**

     * 每次选择 和下一跳之和最远的=》递归处理

     * @param nums

     * @return

     */

    public static int jump2(int[] nums) {

        if(nums == null || nums.length == 1) return 0;

        if(nums.length == 2) return 1;

        int steps = Integer.MAX_VALUE/2;

        int initStep = nums[0];

        if(nums[0] >= nums.length - 1) return 1;

        if(nums[0] == 0) return steps;

        int maxSum = 0;

        int fromStep = 1;

        while (initStep > 0){

            if(initStep + nums[initStep] > maxSum){

                fromStep = initStep;

                maxSum = initStep + nums[initStep];

            }

            initStep--;

        }

        steps = 1 + jump2(Arrays.copyOfRange(nums, fromStep, nums.length));

        return steps;

    }

15. 全排列

给定二个从不重新数字的体系,再次来到其持有异常的大希望的全排列。

示例:

输入: [1,2,3]输出:[  [1,2,3],  [1,3,2],  [2,1,3],  [2,3,1],  [3,1,2],  [3,2,1]]

/**

     * 递归处理

     * @param nums

     * @return

     */

    public static List<List<Integer>> permute(int[] nums) {

        List<List<Integer>> result = new ArrayList();

        if(nums.length == 1) {

            result.add(new ArrayList(){{add;}});

            return result;

        }

        for (int num : nums) {

            int[] tmp = new int[nums.length - 1];

            int index = 0;

            for (int i = 0; i < nums.length; i++) {

                if(num == nums[i]) continue;

                tmp[index] = nums[i];

                index++;

            }

            List<List<Integer>> sub = permute;

            sub.stream().forEach(item->item.add;

            result.addAll(sub);

        }

        return result;

    }

给定三个可含蓄重复数字的行列,重返全数不另行的全排列。

示例:

输入: [1,1,2]输出:[  [1,1,2],  [1,2,1],  [2,1,1]]

/**

     * 递归处理

     * Set 处理重复

     * @param nums

     * @return

     */

    public static List<List<Integer>> permuteUnique(int[] nums) {

        List<List<Integer>> result = new ArrayList();

        if(nums.length == 1) {

            result.add(new ArrayList(){{add;}});

            return result;

        }

        for (int num : nums) {

            int[] tmp = new int[nums.length - 1];

            int index = 0;

            for (int i = 0; i < nums.length; i++) {

                if(num == nums[i] && index == i) continue;

                tmp[index] = nums[i];

                index++;

            }

            List<List<Integer>> sub = permuteUnique;

            sub.stream().forEach(item->item.add;

            result.addAll(sub);

        }

        Set<List<Integer>> sets = new HashSet();

        result.stream().forEach(item->sets.add;

        return new ArrayList;

    }

16. 筋斗图像

给定三个 n × n 的2维矩阵表示3个图像。

将图像顺时针旋转 90 度。

说明:

你必须在原地旋转图像,那意味着你必要一向改变输入的二维矩阵。请不要运用另1个矩阵来旋转图像。

示例 1:

给定 matrix = [  [1,2,3],  [4,5,6],  [7,8,9]],原地旋转输入矩阵,使其变为:[  [7,4,1],  [8,5,2],  [9,6,3]]

public static void rotate(int[][] matrix) {

        int step = matrix.length;

        int[][] tmp = new int[step][step];

        for (int i = 0; i < step; i++) {

            for (int j = 0; j < step; j++) {

                tmp[i][j] = matrix[step - j - 1][i];

            }

        }

        for (int i = 0; i < step; i++) {

            for (int j = 0; j < step; j++) {

                matrix[i][j] = tmp[i][j];

            }

        }

    }

17. 字母异位词分组

给定三个字符串数组,将字母异位词组合在同步。字母异位词指字母一样,但排列差异的字符串。

示例:

输入: ["eat", "tea", "tan", "ate", "nat", "bat"],输出:[  ["ate","eat","tea"],  ["nat","tan"],  ["bat"]]

说明:

  • 不无输入均为小写字母。
  • 不思索答案输出的逐条。

public static List<List<String>> groupAnagrams(String[] strs) {

        List<List<String>> result = new ArrayList();

        if(strs == null ||strs.length == 0) return result;

        if(strs.length == 1){

            result.add(Arrays.asList;

            return result;

        }

        Map<String, List<String>> maps = new HashMap();

        for (String str : strs) {

            char[] arr = str.toCharArray();

            Arrays.sort;

            String sorted = Arrays.toString;

            if(maps.get != null){

                maps.get.add;

            }else {

                maps.put(sorted, new ArrayList(){{add;

            }

        }

        maps.remove;

        return maps.values().stream().collect(Collectors.toList;

    }

18. Pow

实现 pow(x, n) ,即总括 x 的 n 次幂函数。

示例 1:

输入: 2.00000, 10输出: 1024.00000

示例 2:

输入: 2.10000, 3输出: 9.26100

示例 3:

输入: 2.00000, -2输出: 0.25000解释: 2

-2

 = 1/2

2

 = 1/4 = 0.25

说明:

  • -100.0 < x < 100.0
  • n 是 3二 位有暗号整数,其数值范围是 [−231, 231 − 1] 。

/**

     * 快速降幂 避免递归过深造成栈溢出

     * @param x

     * @param n

     * @return

     */

    public static double power(double x, int n) {

        if(!(x > -100 && x < 100)) return 0;

        if(!(n <= Integer.MAX_VALUE && n >= Integer.MIN_VALUE)) return 0;

        if return 0;

        if return 1;

        if return 1;

        if return x;

        if return 1/x;

        if(n > 1 || n < -1){

            double nextValue = power;

            return (n % 2 == 0 ? 1 : (n > 0 ? x : 1/x)) * nextValue * nextValue;

        }

        return x;

    }

1玖. 进制调换

进制转换 十进制 =》 62进制
这里所谓62进制是指采用0~9A~Za~z等62个字符进行编码(按ASCII顺序由小到大)。

public static String BASE = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

    public static String transfer(int num) {

        int scale = 62;

        StringBuilder sb = new StringBuilder();

        while (num > 0) {

            //余数对照进制基本位 BASE 放到相应位置

            sb.append(BASE.charAt(num % scale));

            //除处理下一进位

            num = num / scale;

        }

        sb.reverse();

        return sb.toString();

    }

20. 报数

报数种类是1个整数种类,遵照内部的平头的次第举行报数,获得下二个数。其前伍项如下:

1.     12.     113.     214.     12115.     111221

1 被读作 "one 1" ("一个一") , 即 11
11 被读作 "two 1s" ("两个一"), 即 21
21 被读作 "one 2", “one 1""一个二" , "一个一") , 即
1211

给定八个正整数 n(1 ≤ n ≤ 30),输出报数连串的第 n 项。

注意:整数逐项将意味为一个字符串。

public static String countAndSay(int n) {

        if(n < 1 || n > 30) return "";

        int start = 1;

        String report = "1";

        String result = "";

        while (start < n ){

            result = "";

            for (int i = 0; i < report.length {

                int c = i;

                int count = 1;

                while (c + 1 < report.length{

                    if(report.charAt != report.charAt{

                        break;

                    }

                    count++;

                    c++;

                }

                result += String.valueOf + String.valueOf(report.charAt;

                i = i + count;

            }

            report = result;

            start++;

        }

        return report;

    }

二一. 最长回文子串

给定二个字符串 s,找到 s 中最长的回文子串。你能够假如 s
的最大尺寸为 一千。

示例 1:

输入: "babad"输出: "bab"注意: "aba" 也是一个有效答案。

示例 2:

输入: "cbbd"输出: "bb"

public static String longestPalindrome(String s) {

        if(s == null || s.length() == 1 || s.length return s;

        if(s.length return s.charAt == s.charAt?s:String.valueOf(s.charAt;

        String maxP = "";

        //中间索引

        int middle = (s.length/2;

        //字符串长度奇偶 判别

        boolean dmiddle = s.length()%2 == 0 && s.charAt == s.charAt(middle + 1);

        //遍历使用临时中间字符索引

        int tmpMiddle = middle;

        //紧邻元素接次判断

        int initJudge = 1;

        //每次判断中间最长回文字符

        String tp = "";

        //最开始 判断是否偶长度

        boolean first = true;

        //中间字符逐次左移判断

        while (tmpMiddle > 0) {

            initJudge = 1;

            //左右指针

            int lindex = tmpMiddle - 1, rindex = tmpMiddle + (first && dmiddle?2:1);

            while (lindex > -1 && rindex < s.length {

                if(initJudge == 1) {

                    //左边紧邻接次判断

                    if (s.charAt == s.charAt(tmpMiddle)) {

                        lindex--;

                        initJudge++;

                    }

                    //右边紧邻接次判断

                    if (s.charAt == s.charAt(tmpMiddle + (first && dmiddle?1:0))) {

                        rindex++;

                        initJudge++;

                    }

                    initJudge = initJudge>1?1:0;

                    first = false;

                    tp = s.substring(lindex + 1, rindex);

                    continue;

                }

                //对称位置判断

                if (s.charAt == s.charAt {

                    lindex--;

                    rindex++;

                    tp = s.substring(lindex + 1, rindex);

                    continue;

                }

                tp = s.substring(lindex + 1, rindex);

                break;

            }

            if(tp.length() > maxP.length{

                maxP = tp;

            }

            tmpMiddle--;

        }

        tmpMiddle = middle;

        tp = "";

        first = false;

        //中间字符逐次右移判断

        while (tmpMiddle < s.length {

            initJudge = 1;

            //左右指针

            int lindex = tmpMiddle - 1, rindex = tmpMiddle + (first && dmiddle?2:1);

            while (lindex > -1 && rindex < s.length {

                if(initJudge == 1) {

                    //左边紧邻接次判断

                    if (s.charAt == s.charAt(tmpMiddle)) {

                        lindex--;

                        initJudge++;

                    }

                    //右边紧邻接次判断

                    if (s.charAt == s.charAt(tmpMiddle + (first && dmiddle?1:0))) {

                        rindex++;

                        initJudge++;

                    }

                    initJudge = initJudge>1?1:0;

                    tp = s.substring(lindex + 1, rindex);

                    continue;

                }

                //对称位置判断

                if (s.charAt == s.charAt {

                    lindex--;

                    rindex++;

                    tp = s.substring(lindex + 1, rindex);

                    continue;

                }

                tp = s.substring(lindex + 1, rindex);

                break;

            }

            if(tp.length() > maxP.length{

                maxP = tp;

            }

            tmpMiddle++;

        }

        return maxP;

    }

2②. 电话号码的字母组合

给定二个仅包括数字 2-9 的字符串,再次回到全体它能代表的字母组合。

付出数字到字母的映照如下。注意 1 不对应任何字母。

威尼斯人线上娱乐 2

示例:

输入:"23"输出:["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

输入:“234”

输出:

[aeg, ceg, beh, aei, beg, aeh, cei, ceh, bei, bfg, afh, afg, cfh, bdg,
bfi, adh, cfg, bfh, adg, afi, cdh, bdi, cdg, cfi, bdh, adi, cdi].

说明:
就算地点的答案是按字典序排列的,但是你可以随便选取答案输出的逐条。

public static Map<Integer, String> maps = new HashMap(){{

        put(2, "abc"); put(3, "def"); put(4, "ghi"); put(5, "jkl"); put(6, "mno"); put(7, "pqrs"); put(8, "tuv"); put(9, "wxyz");

    }};

    public static List<String> letterCombinations(String digits) {

        int size = digits.length();

        if(digits == null || digits.length return new ArrayList<>();

        Set<String> coms = new HashSet();

        if(size == 1){

            String ele = maps.get(Integer.parseInt;

            for (int i = 0; i < ele.length {

                coms.add(String.valueOf(ele.charAt;

            }

        }else if(size == 2){

            String left = maps.get(Integer.parseInt(String.valueOf(digits.charAt;

            String right = maps.get(Integer.parseInt(String.valueOf(digits.charAt;

            for (int k = 0; k < left.length {

                for (int l = 0; l < right.length {

                    coms.add(String.valueOf(left.charAt + String.valueOf(right.charAt;

                }

            }

        }else {

            String left = maps.get(Integer.parseInt(String.valueOf(digits.charAt;

            List<String> subs = letterCombinations(digits.substring(1, digits.length;

            subs.stream().forEach(item->{

                for (int l = 0; l < left.length {

                    coms.add(String.valueOf(left.charAt + item);

                }

            });

        }

        return new ArrayList<>;

    }

二三. 去除链表的尾数第N个节点

给定3个链表,删除链表的倒数第 n 个节点,并且重返链表的头结点。

示例:

给定一个链表: 1->2->3->4->5, 和 n = 2.当删除了倒数第二个节点后,链表变为 1->2->3->5.

说明:

给定的 n 保障是行得通的。

进阶:

您能尝尝选拔一趟扫描落成啊?

public static ListNode removeNthFromEnd(ListNode head, int n) {

        ListNode first = head;

        //subIndex 第n个元素的索引

        int index = 0, subIndex = 0;

        List<ListNode> list = new ArrayList();

        while (first != null){

            list.add;

            if(index - subIndex > n){

                subIndex++;

            }

            index++;

            first = first.next;

        }

        if(list.size return null;

        if(list.size return null;

        if(list.size return list.get;

        //处理移除

        list.get.next = list.get.next.next;

        return list.get;

    }

二四. 管用的括号

给定2个只包蕴 '('')''{''}''['']'
的字符串,判别字符串是不是管用。

实惠字符串需满意:

  1. 左括号必须用同样类其余右括号闭合。
  2. 左括号必须以准确的逐条闭合。

注意空字符串可被感到是实惠字符串。

//括号映射

    public static Map<String, String> maps = new HashMap(){{

        put("}", "{");

        put("]", "[");

        put(")", ";

        put("{", "}");

        put("[", "]");

        put("(", ")");

    }};

    public static boolean isValid {

        if(s == null || s.length return false;

        if(s.length return true;

        int index = 1;

        //当前字符

        char focus = s.charAt;

        //存储非相邻匹配的符号

        List<String> unmap = new LinkedList();

        while (index < s.length

            //相邻对比

            if(String.valueOf(s.charAt.equals(maps.get(String.valueOf{

                //处理存储的非相邻匹配的符号匹配

                int lIndex = unmap.size() - 1;

                if(lIndex > 0) {

                    unmap.remove;

                }

                while (lIndex > 0){

                    index++;

                    lIndex--;

                    //倒序遍历匹配

                    if(unmap.get.equals(maps.get(String.valueOf(s.charAt){

                        //匹配上则删除list中元素

                        unmap.remove;

                        continue;

                    }else {

                        //匹配不上则加入到list中

                        unmap.add(String.valueOf(s.charAt;

                        index--;

                        break;

                    }

                }

                index++;

                if(index >= s.length return true;

                focus = s.charAt;

                index++;

            }else {

                //相邻不匹配则加入到 list中以供后续使用

                if(s.substring.contains(String.valueOf(maps.get(String.valueOf && (index + 1 < s.length &&s.substring(index + 1).contains(String.valueOf(maps.get(String.valueOf(s.charAt)){

                    //第一次非相邻的时候添加头一个元素

                    if(unmap.size {

                        unmap.add(String.valueOf;

                    }

                    unmap.add(String.valueOf(s.charAt;

                    focus = s.charAt;

                    index++;

                }else{

                    return false;

                }

            }

        return false;

    }

2五. 四数之和

给定二个富含 n 个整数的数组 nums 和多少个对象值 target,判断 nums
中是还是不是存在多少个元素 a,b,cd ,使得 a + b + c + d 的值与
target 相等?搜索全体满意条件且不另行的四元组。

注意:

答案中不得以分包重复的肆元组。

示例:

给定数组 nums = [1, 0, -1, 0, -2, 2],和 target = 0。满足要求的四元组集合为:[  [-1,  0, 0, 1],  [-2, -1, 1, 2],  [-2,  0, 0, 2]]

/**

     * 四数之和

     * @param nums

     * @param target

     * @return

     */

    public static List<List<Integer>> fourSum(int[] nums, int target) {

        Set<List<Integer>> sets = new HashSet();

        List<Integer> numList = new ArrayList();

        for (int num : nums) {

            numList.add;

        }

        for (int i = 0; i < numList.size {

            List<Integer> copy = new ArrayList();

            copy.addAll;

            copy.remove(numList.get;

            List<List<Integer>> threes = threeSum(copy, target - numList.get;

            final int finalI = i;

            threes.forEach(item -> {

                item.add(nums[finalI]);

                Collections.sort;

                sets.add;

            });

        }

        return new ArrayList;

    }

    /**

     * 三数之和

     * @param nums

     * @param target

     * @return

     */

    public static List<List<Integer>> threeSum(List<Integer> nums, int target) {

        if(nums == null || nums.size return new ArrayList();

        Set<List<Integer>> result = new HashSet<>();

        List<Integer> numList = new ArrayList();

        for (int num : nums) {

            numList.add;

        }

        for (Integer num : numList) {

            List<Integer> copy = new ArrayList();

            copy.addAll;

            copy.remove;

            List<int[]> tmp = twoSum(copy, target - num);

            if(tmp.size{

                for (int[] ints : tmp) {

                    List<Integer> list = new ArrayList(){{add;add;add;}};

                    Collections.sort;

                    result.add;

                }

            }

        }

        return new ArrayList;

    }

    /**

     * 两数之和

     * @param nums

     * @param target

     * @return

     */

    public static List<int[]> twoSum(List<Integer> nums, int target) {

        List<int[]> result = new ArrayList();

        Map<Integer, Integer> map = new HashMap<>();

        for (int i = 0; i < nums.size {

            int complement = target - nums.get;

            if (map.containsKey(complement)) {

                result.add(new int[] { complement, nums.get;

            }

            map.put(nums.get;

        }

        return result;

    }

待续 。。。 。。。

项目地址:


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图