简单算法2

二分查找

package com.sly.uploadfile.algorithm.pack1;

import java.util.Arrays;

/**
 * Created by fmgao on 2019/9/25.
 * <p>
 * Java语言二分查找代码实现
 */
public class ErFenChaZhao {

    /**
     * 二分查找key值对应的下标
     *
     * @param source 输入的源数组 ，请保证为一个有序数组
     * @param key    需要查找的值
     * @return 正数为查找到的坐标，-1表示没有查到
     */
    public static int binarySearch(int[] source, int key) {
        int low = 0;
        int high = source.length - 1;
        while (low <= high) {
            int mid = (low + high) >>> 1; //使用位移运算法高效地获取折中下标，这里不考虑符号，所以使用>>>
            int midVal = source[mid];
            if (midVal < key) {
                low = mid + 1;
            } else if (midVal > key) {
                high = mid - 1;
            } else
                return mid;
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] source = new int[]{12, 213, 232, 343, 123, -1, 123, 232424, 1253, 56, 456, 234, -2342};
        //保证数组为有序数组
        Arrays.sort(source);
        //打印排序后的数组元素
        System.out.print("Sorted Source : ");
        for (int i = 0; i < source.length; i++) {
            System.out.print(source[i] + " ");
        }
        System.out.println();
        System.out.println(binarySearch(source, 56));
    }

}

俩数相加

package com.sly.uploadfile.algorithm.twoadd;

/**
 * Created by fmgao on 2019/11/13.
 * <p>
 * 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，
 * 并且它们的每个节点只能存储 一位 数字。
 * <p>
 * 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
 * <p>
 * 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
 * <p>
 * 示例：
 * <p>
 * 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
 * 输出：7 -> 0 -> 8
 * 原因：342 + 465 = 807
 */
public class TwoAdd {

    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dumpHead = new ListNode(0);
        ListNode p = l1, q = l2, curr = dumpHead;
        int carry = 0;
        while (p != null || q != null) {
            int x = (p != null) ? p.data : 0;
            int y = (q != null) ? q.data : 0;
            int sum = x + y + carry;
            carry = sum / 10;

            curr.next = new ListNode(sum % 10);
            curr = curr.next;
            if (p != null) p = p.next;
            if (q != null) q = q.next;
        }
        if (carry != 0) {
            curr.next = new ListNode(carry);
        }
        return dumpHead.next;
    }


    public static void main(String[] args) {
        SingleLinkedList l1 = new SingleLinkedList();
        l1.addData(1);
        l1.addData(2);
        l1.addData(5);
        SingleLinkedList l2 = new SingleLinkedList();
        l2.addData(3);
        l2.addData(2);
        l2.addData(7);
        TwoAdd solution = new TwoAdd();
        ListNode l3 = solution.addTwoNumbers(l1.head, l2.head);
        while (l3 != null) {
            if (l3.next == null) {
                System.out.print(l3.data);
                l3 = l3.next;
            } else {
                System.out.print(l3.data + "->");
                l3 = l3.next;
            }
        }
        System.out.println();
        System.out.println("/:" + 25 / 10);
        System.out.println("%:" + 25 % 10);
    }
}

俩数相加

package com.sly.uploadfile.algorithm.twoadd;

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

/**
 * Created by fmgao on 2019/12/30.
 */
public class TwoNum {


    public static void main(String[] args) {
        int[] nums = {2, 7, 11, 15};
        int tar = 22;
        int[] ints = twoNum(nums, tar);
        for (int s : ints) {
            System.out.println(s);
        }
    }

    public static int[] twoNum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int com = target - nums[i];
            if (map.containsKey(com)) {
                return new int[]{map.get(com), i};
            } else {
                map.put(nums[i], i);
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }

}

是否有重复元素

package com.sly.uploadfile.algorithm;

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

/**
 * Created by fmgao on 2019/9/27.
 * <p>
 * [Leetcode] 220. 存在重复元素 II java
 * <p>
 * 给定一个整数数组，判断数组中是否有两个不同的索引 i 和 j，
 * 使得 nums [i] 和 nums [j] 的差的绝对值最大为 t，并且 i 和 j 之间的差的绝对值最大为 ķ。
 * <p>
 * Example 1:
 * <p>
 * Input: nums = [1,2,3,1], k = 3, t = 0
 * Output: true
 * <p>
 * Example 2:
 * <p>
 * Input: nums = [1,0,1,1], k = 1, t = 2
 * Output: true
 * <p>
 * Example 3:
 * <p>
 * Input: nums = [1,5,9,1,5,9], k = 2, t = 3
 * Output: false
 */
public class ContainsNearByDuplicate {
    public static void main(String[] args) {
        int[] nu = {1, 2, 3, 1};
        boolean b = containsNearByAlmostDuplicate(nu, 21, 1);
        System.out.println(b);
    }

    public static boolean containsNearByAlmostDuplicate(int[] a, int k, int t) {
//        if (k < 1 || t < 0 || nums == null || nums.length < 2) {
//            return false;
//        }
//        SortedSet<Long> set = new TreeSet<>();
//        for (int j = 0; j < nums.length; j++) {
//            SortedSet<Long> subset = set.subSet((long) nums[j] - t, (long) nums[j] + t + 1);
//            if (!subset.isEmpty()) {
//                return true;
//            }
//            if (j >= k) {
//                set.remove((long) nums[j - k]);
//            }
//            set.add((long) nums[j]);
//        }
//        for (Long ss : set) {
//            System.out.println(ss);
//        }

        /**
         * 给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的绝对值最大为 k。

         示例 1:

         输入: nums = [1,2,3,1], k = 3
         输出: true

         示例 2:

         输入: nums = [1,0,1,1], k = 1
         输出: true

         示例 3:

         输入: nums = [1,2,3,1,2,3], k = 2
         输出: false
         */

        // （双指针法,快慢指针加了一个限定（Math.abs ( i-j )<=k），相当于滑动窗口（有滑动限定））+map存储元素
        int j;
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < a.length; i++) {
            //   当map中存在数组元素时，证明两个元素相同
            if (map.containsKey(a[i])) {
                //   让j等于map中与数组元素相等的那个键对应值
                j = map.get(a[i]);
                //   判断新的这个（遍历后的）索引和Map中的索引的差是否小于k，小于则输出true。
                if (Math.abs(i - j) <= k) {
                    System.out.println("true");
                }
                //将新的索引值添加到map中
                map.put(a[i], i);
            } else {
                // 向map中添加元素
                map.put(a[i], i);
            }
        }
        System.out.println("false");
        return false;
    }

}

数字1的个数

package com.sly.uploadfile.algorithm;

/**
 * Created by fmgao on 2019/9/29.
 * <p>
 * [LeetCode] Number of Digit One 数字1的个数
 * Given an integer n, count the total number of digit 1 appearing in all non-negative integers less than or equal to n.
 * For example:
 * Given n = 13,
 * Return 6, because digit 1 occurred in the following numbers: 1, 10, 11, 12, 13.
 */

/**
 《编程之美》上这样说:

 设N = abcde ,其中abcde分别为十进制中各位上的数字。

 如果要计算百位上1出现的次数，它要受到3方面的影响：百位上的数字，百位以下（低位）的数字，百位以上（高位）的数字。

 如果百位上数字为0，百位上可能出现1的次数由更高位决定。比如：12013，
 则可以知道百位出现1的情况可能是：100~199，1100~1199,2100~2199，，...，11100~11199，一共1200个。
 可以看出是由更高位数字（12）决定，并且等于更高位数字（12）乘以 当前位数（100）。注意：高位数字不包括当前位

 如果百位上数字为1，百位上可能出现1的次数不仅受更高位影响还受低位影响。比如：12113，
 则可以知道百位受高位影响出现的情况是：100~199，1100~1199,2100~2199，，....，11100~11199，一共1200个。
 和上面情况一样，并且等于更高位数字（12）乘以 当前位数（100）。
 但同时它还受低位影响，百位出现1的情况是：12100~12113,一共14个，等于低位数字（13）+1。 注意：低位数字不包括当前数字

 如果百位上数字大于1（2~9），则百位上出现1的情况仅由更高位决定，比如12213，
 则百位出现1的情况是：100~199,1100~1199，2100~2199，...，11100~11199,12100~12199,一共有1300个，
 并且等于更高位数字+1（12+1）乘以当前位数（100）
 */
public class CountDigitOne {

    public static void main(String[] args) {
        int a = 27;
        int i = countDigitOne(a);
        System.out.println(i);
    }

    public static int countDigitOne(int n) {
        if (n < 1) {
            return 0;
        }
        int res = 0;
        long i = 1;
        while (n >= i) {
            res += (n / i + 8) / 10 * i + ((n / i) % 10 == 1 ? (n % i + 1) : 0);
            i *= 10;
        }
        return res;
    }
}

package com.sly.uploadfile.algorithm;

/**
 * Created by fmgao on 2019/9/29.
 */
public class CountDigitOne2 {
    public static void main(String[] args) {
        int a = 27;
        int i = countDigitOne(a);
        System.out.println(i);
    }

    public static int countDigitOne(int n) {
        if (n <= 0) {
            return 0;
        }
        String stringN = n + "";
        int ans = 0;
        while (!stringN.isEmpty()) {
            int tempLen = stringN.length();
            String firstChar = stringN.charAt(0) + "";
            if (Integer.parseInt(firstChar) >= 2) {
                ans += 1 * Math.pow(10, tempLen - 1);
            } else if (firstChar.equals("1")) {
                if ("".equals(stringN.substring(1, tempLen))) {
                    ans += 1;
                } else if (!"".equals(stringN.substring(1, tempLen))) {
                    ans += Integer.parseInt(stringN.substring(1, tempLen)) + 1;
                }
            }
            if (tempLen > 1) {
                ans += Integer.parseInt(firstChar) * (tempLen - 1) * Math.pow(10, tempLen - 2);
            }
            stringN = stringN.substring(1);
        }
        return ans;
    }
}

被除数与除数

package com.sly.uploadfile.algorithm;

/**
 * Created by fmgao on 2019/7/9.
 *
 * 给定两个整数，被除数 dividend和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。
 * 返回被除数 dividend除以除数 divisor得到的商。
 */
public class Divide01 {
    public static int divide(int dividend, int divisor) {
        if (divisor == 0 || (dividend == Integer.MIN_VALUE && divisor == -1)) {
            return Integer.MAX_VALUE;
        }
        int sign = ((dividend < 0) ^ (divisor < 0)) ? -1 : 1;// 异或运算
        long ms = (long) dividend;
        long ns = (long) divisor;
        ms = Math.abs(ms);
        ns = Math.abs(ns);
        int num = 0;
        while (ms >= ns) {
            long m = ns;
            long n = 1;
            while (ms >= (m << 1)) {
                m <<= 1;
                n <<= 1;

            }
            num += n;
            ms -= m;

        }
        return num * sign;
    }

    public static void main(String[] args) {
        int a = divide(46, 3);
        System.out.println(a);
    }
}

数字异或

package com.sly.uploadfile.algorithm;

import lombok.extern.slf4j.Slf4j;

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

/**
 * Created by fmgao on 2019/6/24.
 * <p>
 * 给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。
 * <p>
 * 字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。
 * <p>
 * Example 1:
 * <p>
 * Input:
 * s: "cbaebabacd" p: "abc"
 * <p>
 * Output:
 * [0, 6]
 * <p>
 * Explanation:
 * The substring with start index = 0 is "cba", which is an anagram of "abc".
 * The substring with start index = 6 is "bac", which is an anagram of "abc".
 * <p>
 * Example 2:
 * <p>
 * Input:
 * s: "abab" p: "ab"
 * <p>
 * Output:
 * [0, 1, 2]
 * <p>
 * Explanation:
 * The substring with start index = 0 is "ab", which is an anagram of "ab".
 * The substring with start index = 1 is "ba", which is an anagram of "ab".
 * The substring with start index = 2 is "ab", which is an anagram of "ab".
 */
@Slf4j
public class EctopicElementService {
    public static List<Integer> findAnagrams(String s, String p) {
        List<Integer> list = new ArrayList<>();
        int lens = s.length();
        int lenp = p.length();
        if (lens < lenp) {
            return list;
        }
        for (int i = 0; i <= lens - lenp; i++) {
            int[] t = new int[26];
            for (int j = 0; j < lenp; j++) {
                t[s.charAt(i + j) - 'a']++;
                t[p.charAt(j) - 'a']--;
            }
            boolean flag = true;
            for (int j = 0; j < t.length; j++) {
                if (t[j] != 0) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                list.add(i);
            }
        }
//        log.info("list====" + list);
        return list;
    }

    public static void main(String[] args) {
        List<Integer> anagrams = findAnagrams("cbaebabacd", "abc");
        System.out.println(anagrams);
    }
}

 

括号成对校验

package com.sly.uploadfile.algorithm;

import java.util.Stack;

/**
 * Created by fmgao on 2019/6/28.
 */
public class EffectiveParentheses {
    public static boolean isValid(String s) {
        if (s == "" || s.length() == 0) {
            return true;
        }
        Stack stack = new Stack();
        stack.push(s.charAt(0));
        for (int i = 1; i < s.length(); i++) {
            if (!stack.isEmpty()) {
                if (stack.peek().equals((char) (s.charAt(i) - 1)) || stack.peek().equals((char) (s.charAt(i) - 2))) {
                    stack.pop();
                } else {
                    stack.push(s.charAt(i));
                }
            } else {
                stack.push(s.charAt(i));
            }
        }
        if (stack.isEmpty()) {
            return true;
        }
        return false;
    }

    public static boolean isValid2(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (ch == '(' || ch == '[' || ch == '{') {
                stack.push(ch);
            } else {
                if (stack.isEmpty()) {
                    return false;
                }
                char topChar = stack.pop();
                if (ch == ')' && topChar != '(') {
                    return false;
                } else if (ch == ']' && topChar != '[') {
                    return false;
                } else if (ch == '}' && topChar != '{') {
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }

    public static void main(String[] args) {
        long startTime = System.nanoTime();
        boolean res = isValid("()(){}{}(){}()[][]{}");
        long endTime = System.nanoTime();
        System.out.println(res);
        System.out.println("程序运行时间： " + (endTime - startTime) + "ms");

        long startTime2 = System.nanoTime();
        boolean res2 = isValid2("()(){}{}(){}()[][]{}");
        long endTime2 = System.nanoTime();
        System.out.println(res2);
        System.out.println("程序运行时间： " + (endTime2 - startTime2) + "ms");
    }
}

找俩个子串拼接位置

package com.sly.uploadfile.algorithm;

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

/**
 * Created by fmgao on 2019/7/3.
 */
public class FindSonChars {

    public static void main(String[] args) {
        String s = "barfoothefoobarman";
        String[] words = {"foo", "bar"};
        FindSonChars findSonChars = new FindSonChars();
        List<Integer> list = findSonChars.findSubstring(s, words);
        for (Integer a : list) {
            System.out.println(a);
        }

    }

    /**
     * 1、 字符串和数组都是空  就return 空数组
     * 2、
     *
     * @param s
     * @param words
     * @return
     */
    public List<Integer> findSubstring(String s, String[] words) {
        List<Integer> result = new ArrayList<Integer>();
        // 如果s，或者是words为空，那么也返回一个空的列表
        if (s.length() == 0 || s == null || words.length == 0 || words == null) {
            return result;

        }
        int size = words[0].length(), length = words.length;
        // 把字符串数组中的的字符串全部插入HashMap中
        HashMap<String, Integer> map = generate(words);
        // 窗口的不同的起点，有size个不同的起点
        for (int i = 0; i < size; i++) {
            HashMap<String, Integer> window = new HashMap<>();  // 一个滑动的窗口
            int left, right;
            left = right = i;
            while (right <= s.length() - size && left <= s.length() - length * size) {
                String word = s.substring(right, right + size);
                incr(window, word);
                if (!map.containsKey(word)) {
                    window.clear();
                    right += size;
                    left = right;
                    continue;
                }
                while (window.get(word) > map.get(word)) {
                    String w = s.substring(left, left + size);
                    decr(window, w);
                    left += size;
                }
                right += size;
                if (right - left == size * length) {
                    result.add(left);
                }
            }
        }
        return result;

    }

    private HashMap<String, Integer> generate(String[] strs) {
        HashMap<String, Integer> map = new HashMap<>();
        for (String str : strs) {
            incr(map, str);
        }
        return map;
    }

    private void incr(HashMap<String, Integer> map, String str) {
        map.put(str, map.getOrDefault(str, 0) + 1);
    }

    private void decr(HashMap<String, Integer> map, String str) {
        Integer num = map.get(str);
        if (num <= 1) {
            map.remove(str);
        } else {
            map.put(str, num - 1);
        }
    }
}

二分查找升级版

package com.sly.uploadfile.algorithm;

/**
 * Created by fmgao on 2019/11/19.
 * <p>
 * 力扣算法】34-在排序数组中查找元素的第一个和最后一个位置
 * 给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
 * <p>
 * 你的算法时间复杂度必须是 O(log n) 级别。
 * <p>
 * 如果数组中不存在目标值，返回 [-1, -1]。
 * <p>
 * 示例 1:
 * 输入: nums = [5,7,7,8,8,10], target = 8
 * 输出: [3,4]
 * 示例 2:
 * 输入: nums = [5,7,7,8,8,10], target = 6
 * 输出: [-1,-1]
 */
public class FirstLastSortArray {

    public static void main(String[] args) {
        int[] nums = {5, 7, 8, 8, 8, 10};
        int target = 8;
        int[] ints = searchSort2(nums, target);
        for (int i : ints) {
            System.out.println(i);
        }
    }

    /**
     * 二分查找的升级版。以searchBegin为例，
     * <p>
     * 当nums[mid]>target时，向左查找，
     * 当nums[mid]=targe时，向左查找。
     * 这样所有情况下，范围都会缩小，直到 l == r 为止，这时如果 该位置里的数 == target，则返回该位置，否则返回-1。
     * <p>
     * searchEnd同理
     *
     * @param nums
     * @param target
     * @return
     */
    public static int[] searchSort2(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return new int[]{-1, -1};
        }
        int l = 0, r = nums.length;
        int mid = (l + r) / 2;
        int p = -1;
        while (l < r) {
            // 中间
            if (nums[mid] == target) {
                p = mid;
                break;
            }
            // target 在左边
            if (nums[mid] > target) {
                if (r == mid) break;
                r = mid;
                mid = (l + r) / 2;
            } else {
                // 在右边
                if (l == mid) break;
                l = mid;
                mid = (l + r) / 2;
            }
        }
        if (p == -1) {
            return new int[]{-1, -1};
        } else {
            int a = p, b = p;
            while (a > 0 && nums[a - 1] == target) a--;
            while (b < nums.length - 1 && nums[b + 1] == target) b++;
            return new int[]{a, b};
        }
    }
}