剑指offer_java_30-40

最新推荐文章于 2024-07-21 13:38:21 发布

像欢欢一样棒

最新推荐文章于 2024-07-21 13:38:21 发布

阅读量88

点赞数

分类专栏：剑指offer 文章标签：算法

本文链接：https://blog.csdn.net/weixin_42358663/article/details/105016186

版权

剑指offer 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

在这里插入图片描述

连续子数组的最大和

/**
 * @author yangfan
 * @date 2020/3/21 13:20
 * @description 连续子数组的最大和
 */
public class A {
    private static void maxSonSum(int[] array) {
        if (array == null || array.length == 0)
            return;
        int[] dp = new int[array.length];
        dp[0] = array[0];
        int max = dp[0];
        for (int i = 1; i < array.length; i++) {
            dp[i] = Math.max(dp[i - 1] + array[i], array[i]);
            if (max < dp[i])
                max = dp[i];
        }
        System.out.println(max);
    }

    private static void maxSonSum2(int[] array) {
        if (array == null || array.length == 0)
            return;
        int sum = 0;
        int result = array[0];
        for (int num : array) {
            sum = sum > 0 ? sum + num : num;
            result = Math.max(result, sum);
        }
        System.out.println(result);
    }

    public static void main(String[] args) {
        int[] array = {1, -2, -3, -10, 4, -5};
        maxSonSum(array);
        maxSonSum2(array);
    }
}

从1到n整数中1出现的次数

/**
 * @author yangfan
 * @date 2020/3/21 13:32
 * @description 从1到n整数中1出现的次数
 */
public class B {

    private static int numberOf1(int n) {
        int count = 0;
        int i = 1;
        int current, after, before;
        while ((n / i) != 0) {
            before = n / (i * 10);
            current = (n / i) % 10;
            after = n - (n / i) * i;
            if (current == 0)
                count = count + before * i;
            else if (current == 1)
                count = count + before * i + after + 1;
            else if (current > 1)
                count = count + (before + 1) * i;

            i *= 10;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println(numberOf1(125));
    }
}

把数组排成最小的数

/**
 * @author yangfan
 * @date 2020/3/21 14:35
 * @description 把数组排成最小的数
 */
public class C {

    private static void printMinNumber(int[] array) {
        if (array == null || array.length == 0)
            return;

        int len = array.length;
        String[] strs = new String[len];
        for (int i = 0; i < len; i++) {
            strs[i] = String.valueOf(array[i]);
        }
        Arrays.sort(strs, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                String s1 = o1 + o2;
                String s2 = o2 + o1;
                return s1.compareTo(s2);
            }
        });
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < len; i++) {
            sb.append(strs[i]);
        }

        System.out.println(sb.toString());
    }

    public static void main(String[] args) {
        int[] array = {3,32,321};
        printMinNumber(array);
    }
}

丑数

/**
 * @author yangfan
 * @date 2020/3/21 15:01
 * @description 丑数
 */
public class D {

    private static int getKUgly(int k) {
        if (k <= 0)
            return 0;
        int[] arr = new int[k];
        arr[0] = 1;
        int m2 = 0, m3 = 0, m5 = 0;
        for (int i = 1; i < k; i++) {
            int min = Math.min(arr[m2] * 2, Math.min(arr[m3] * 3, arr[m5] * 5));
            arr[i] = min;
            if (arr[m2] * 2 == min)
                m2++;
            if (arr[m3] * 3 == min)
                m3++;
            if (arr[m5] * 5 == min)
                m5++;
        }
        return arr[k - 1];
    }

    public static void main(String[] args) {
        System.out.println(getKUgly(10));
    }
}

第一个只出现一次的字符

/**
 * @author yangfan
 * @date 2020/3/21 15:25
 * @description 第一个只出现一次的字符
 */
public class E {

    private static void getFirstOnce(String str) {
        if (str == null || str.length() == 0)
            return;
        char[] chars = str.toCharArray();
        HashMap<Character, Integer> map = new HashMap<>();
        for (char c : chars) {
            if (map.containsKey(c))
                map.put(c, map.get(c) + 1);
            else
                map.put(c, 1);
        }
        for (char c : chars) {
            if (map.get(c) == 1) {
                System.out.println(c);
                break;
            }
        }
    }


    public static void main(String[] args) {
        getFirstOnce("abbabacsadiuh");
    }
}

数组中的逆序对

/**
 * @author yangfan
 * @date 2020/3/21 15:40
 * @description 数组中的逆序对
 */
public class A {
    private static int count = 0;

    private static void inversePairs(int[] array) {
        if (array == null || array.length == 0)
            return;
        mergeSort(array, 0, array.length - 1);
        System.out.println(count);
    }

    private static void mergeSort(int[] array, int start, int end) {
        int mid = (start + end) / 2;
        if (start < end) {
            mergeSort(array, start, mid);
            mergeSort(array, mid + 1, end);
            merge(array, start, mid, end);
        }
    }

    private static void merge(int[] data, int start, int mid, int end) {
        int[] arr = new int[end - start + 1];
        int c = 0;
        int s = start;
        int index = mid + 1;
        while (start <= mid && index <= end) {
            if (data[start] < data[index]) {
                arr[c++] = data[start++];
            } else {
                arr[c++] = data[index++];
                count += mid + 1 - start;
                count %= 1000000007;
            }
        }
        while (start <= mid)
            arr[c++] = data[start++];
        while (index <= end)
            arr[c++] = data[index++];
        for (int i : arr)
            data[s++] = i;
    }

    public static void main(String[] args) {
        int[] arr = {7,5,6,4};
        inversePairs(arr);
    }
}

两个链表的第一个公共结点

/**
 * @author yangfan
 * @date 2020/3/21 15:40
 * @description 两个链表的第一个公共结点
 * 用数组代替链表 思路相同
 */
public class B {

    private static void findFirstCommon(int[] a, int[] b) {
        if (a == null || b == null || a.length == 0 || b.length == 0)
            return;
        int len = Math.abs(a.length - b.length);
        if (a.length > b.length) {
            for (int value : b) {
                if (a[len++] == value) {
                    System.out.println(a[--len]);
                    break;
                }

            }
        } else {
            for (int value : a) {
                if (b[len++] == value) {
                    System.out.println(b[--len]);
                    break;
                }

            }
        }

    }

    private static void findFirstCommon1(int[] a, int[] b) {
        if (a == null || b == null || a.length == 0 || b.length == 0)
            return;
        Stack<Integer> stackA = new Stack<>();
        Stack<Integer> stackB = new Stack<>();
        for (int i : a) {
            stackA.push(i);
        }
        for (int i : b) {
            stackB.push(i);
        }
        Integer common = null;
        while (!stackA.empty() && !stackB.empty() && stackA.peek().equals(stackB.peek())) {
            common = stackA.pop();
            stackB.pop();
        }
        System.out.println(common);
    }

    public static void main(String[] args) {
        int[] b = {1, 2, 3, 6, 7};
        int[] a = {5, 4, 6, 7};
        findFirstCommon1(a, b);
    }
}

数字在排序数组中出现的次数

/**
 * @author yangfan
 * @date 2020/3/21 15:40
 * @description 数字在排序数组中出现的次数
 */
public class C {

    private static int getK(int[] arr, int start, int end, int k, int flag) {
        if (arr == null || arr.length == 0 || start >= end)
            return -1;

        int index = -1;
        int mid = (end + start) / 2;

        //得到第一个或最后一个k位置
        if (flag == 1) {
            if (k < arr[mid])
                index = getK(arr, start, mid, k, flag);
            else if (k > arr[mid])
                index = getK(arr, mid + 1, end, k, flag);
            else if (arr[mid] == k) {
                if (mid == 0 || arr[mid - 1] != k)
                    return mid;
                else
                    index = getK(arr, start, mid, k, flag);
            }
        } else {
            if (k < arr[mid])
                index = getK(arr, start, mid, k, flag);
            else if (k > arr[mid])
                index = getK(arr, mid + 1, end, k, flag);
            else if (arr[mid] == k) {
                if (mid + 1 == end || arr[mid + 1] != k)
                    return mid;
                else
                    index = getK(arr, mid + 1, end, k, flag);
            }
        }

        return index;
    }

    private static int kCount(int[] arr, int k) {

        int first = getK(arr, 0, arr.length, k, 1);
        System.out.println(first);
        int last = getK(arr, 0, arr.length, k, 0);
        System.out.println(last);

        return first == -1 ? 0 : last - first + 1;
    }

    public static void main(String[] args) {
        //int[] arr = {1, 2, 2, 3, 3, 3, 4, 5, 6, 6, 7, 9,9};
        int[] arr = {1};
        System.out.println(kCount(arr, 1));
    }
}

二叉树的深度/是否是平衡二叉树

/**
 * @author yangfan
 * @date 2020/3/21 15:40
 * @description 二叉树的深度/是否是平衡二叉树
 */
public class D {

    private static int getDepth(Tree root) {
        if (root == null)
            return 0;
        int left = getDepth(root.left);
        int right = getDepth(root.right);

        return left > right ? left + 1 : right + 1;
    }

    private static boolean isBalanced(Tree root) {
        if (root == null)
            return true;
        boolean condition = Math.abs(getDepth(root.left) - getDepth(root.right)) <= 1;

        return condition && isBalanced(root.left) && isBalanced(root.right);
    }

    public static void main(String[] args) {
        Tree root = Tree.creat(new Tree());
        System.out.println(isBalanced(root));
    }
}

数组中只出现一次的数字

/**
 * @author yangfan
 * @date 2020/3/21 15:40
 * @description 数组中只出现一次的数字
 */
public class E {
    private static void FindNumsAppearOnce(int[] array) {
        if (array == null || array.length < 2)
            return;
        int res = 0;
        for (int num : array) //数组中的元素先依次异或，相同为0，则得到的是两个只出现一次的数的异或结果
            res ^= num;

        int index = 0; //找到其第一个为1的位
        for (; index < 32; index++) {
            if (((res >> index) & 1) == 1)
                break;
        }
        int[] result = new int[2];
        for (int num : array) { //按照该位是0还是1将数组分成两部分,分别异或
            if (((num >> index) & 1) == 1)
                result[0] ^= num;
            else
                result[1] ^= num;
        }
        System.out.println(Arrays.toString(result));
    }

    public static void main(String[] args) {
        int[] arr = {2,4,3,6,3,2,5,5};
        FindNumsAppearOnce(arr);
    }
}

像欢欢一样棒

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
剑指offer_java_30-40

连续子数组的最大和/** * @author yangfan * @date 2020/3/21 13:20 * @description 连续子数组的最大和 */public class A { private static void maxSonSum(int[] array) { if (array == null || array.length =...
复制链接

扫一扫