gitweixin
  • 首页
  • 小程序代码
    • 资讯读书
    • 工具类
    • O2O
    • 地图定位
    • 社交
    • 行业软件
    • 电商类
    • 互联网类
    • 企业类
    • UI控件
  • 大数据开发
    • Hadoop
    • Spark
    • Hbase
    • Elasticsearch
    • Kafka
    • Flink
    • 数据仓库
    • 数据挖掘
    • flume
    • Kafka
    • Hive
    • shardingsphere
    • solr
  • 开发博客
    • Android
    • php
    • python
    • 运维
    • 技术架构
    • 数据库
  • 程序员网赚
  • bug清单
  • 量化投资
  • 在线查询工具
    • 去行号
    • 在线时间戳转换工具
    • 免费图片批量修改尺寸在线工具
    • SVG转JPG在线工具
    • SVG转PDF/Word
    • SVG转Draw.io可二次编辑格式
    • js代码混淆
    • json格式化及任意折叠展开
    • PDF常用工具

大厂面试手撕面试题:一个字符串中最长的没有重复字符的子串(亲测可用的java实现)

精品微信小程序开发门户,代码全部亲测可用

  • 首页   /  
  • 作者: east
  • ( 页面16 )
Java, 面试 12月 22,2024

大厂面试手撕面试题:一个字符串中最长的没有重复字符的子串(亲测可用的java实现)

要解决 “求解一个字符串中最长的没有重复字符的子串” 的问题,可以使用 滑动窗口(Sliding Window)算法。这个算法通过维护一个动态窗口来跟踪当前没有重复字符的子串,然后逐步扩展窗口来找到最长的子串。

思路:

  1. 使用两个指针,left 和 right,表示当前窗口的左右边界。
  2. 通过哈希集合(HashSet 或 HashMap)来存储窗口中的字符,确保每个字符在窗口内唯一。
  3. 从左到右遍历字符串,每次右指针right向右移动,检查字符是否已经在窗口中存在。如果存在,就将左指针left向右移动,直到窗口中没有重复字符。
  4. 更新最长子串的长度。

Java实现:

import java.util.HashSet;

public class LongestSubstring {
    public static int lengthOfLongestSubstring(String s) {
        // 哈希集合用于存储窗口中的字符
        HashSet<Character> set = new HashSet<>();
        
        // 定义左右指针和最大长度
        int left = 0;
        int maxLength = 0;
        
        // 右指针向右移动,遍历字符串
        for (int right = 0; right < s.length(); right++) {
            // 如果右指针指向的字符在集合中,说明有重复字符
            // 移动左指针直到去除重复字符
            while (set.contains(s.charAt(right))) {
                set.remove(s.charAt(left));
                left++;
            }
            
            // 将当前字符加入集合
            set.add(s.charAt(right));
            
            // 更新最大长度
            maxLength = Math.max(maxLength, right - left + 1);
        }
        
        return maxLength;
    }

    public static void main(String[] args) {
        String s = "abcabcbb";
        System.out.println("The length of the longest substring without repeating characters is: " + lengthOfLongestSubstring(s));
    }
}

解释:

  1. HashSet<Character> set = new HashSet<>();:
    • 用于存储当前窗口内的字符,确保窗口内的字符唯一。
  2. left 和 right 指针:
    • right指针用来遍历字符串。
    • left指针控制窗口的起始位置,确保窗口内没有重复字符。
  3. 滑动窗口的调整:
    • 当遇到重复字符时,移动left指针,直到窗口内不再有重复字符。
    • 每次移动时,都会更新maxLength,保持最大窗口的长度。
  4. 时间复杂度:
    • 最坏情况下,left 和 right 每个指针最多各走一次字符串,因此时间复杂度是 O(n),其中 n 是字符串的长度。

示例输出:

对于输入 "abcabcbb",输出结果是:

The length of the longest substring without repeating characters is: 3 

该子串是 "abc",其长度为 3。

作者 east
Java 12月 22,2024

大厂面试手撕面试题:冒泡排序(亲测可用的java实现)

冒泡排序(Bubble Sort)是一种简单的排序算法。它通过重复遍历待排序的列表,比较相邻元素并交换它们的位置,直到整个列表排序完成。每次遍历都会把当前未排序部分的最大值“冒泡”到数组的最后。

思路:

  1. 从数组的第一个元素开始,逐个比较相邻的元素。
  2. 如果当前元素大于下一个元素,交换它们的位置。
  3. 每一轮遍历后,最大的元素会被“冒泡”到数组的末尾。
  4. 每次遍历的长度逐渐减少,因为已经排序好的元素已经“浮到”数组的末尾。
  5. 直到没有需要交换的元素时,排序完成。

冒泡排序的优化:

  • 如果在某次遍历中没有进行交换,说明数组已经是有序的,可以提前结束排序,避免不必要的遍历。

Java 完整代码实现:

public class BubbleSort {
    public static void main(String[] args) {
        // 测试数组
        int[] arr = {5, 2, 9, 1, 5, 6};
        
        // 调用冒泡排序
        bubbleSort(arr);
        
        // 打印排序后的数组
        System.out.println("Sorted array:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
    
    // 冒泡排序方法
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        
        // 外层循环控制排序的轮数
        for (int i = 0; i < n - 1; i++) {
            boolean swapped = false;  // 标记是否发生了交换
            
            // 内层循环进行相邻元素比较和交换
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换 arr[j] 和 arr[j + 1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }
            
            // 如果没有发生交换,说明数组已经有序,提前结束
            if (!swapped) {
                break;
            }
        }
    }
}

代码解释:

  1. 主方法 (main):初始化一个整数数组并调用 bubbleSort 方法进行排序。排序后打印数组。
  2. 冒泡排序方法 (bubbleSort):
    • 外层循环控制排序的轮次,每一轮确保将最大的元素“冒泡”到末尾。
    • 内层循环执行相邻元素的比较和交换。如果当前元素比下一个元素大,则交换。
    • swapped 是一个标记,用来检查在某一轮遍历中是否发生了交换。如果某轮没有交换,说明数组已经是有序的,可以提前结束排序。

时间复杂度:

  • 最坏情况下,时间复杂度为 O(n^2),即当数组是逆序时。
  • 最好情况下(当数组已经是有序的),时间复杂度为 O(n),因为只会进行一次遍历且没有发生任何交换。

空间复杂度:

  • O(1),因为该算法是原地排序,不需要额外的空间。
作者 east
Java 12月 22,2024

大厂面试手撕面试题:快速排序(亲测可用的java实现)

快速排序(Quick Sort)是一种常用的排序算法,采用分治法(Divide and Conquer)进行排序。其基本思路是通过选择一个基准元素(pivot),将待排序的数组分成两部分,一部分所有元素都小于基准元素,另一部分所有元素都大于基准元素。然后递归地对这两部分继续进行排序,最终达到排序整个数组的效果。

快速排序的步骤:

  1. 选择基准元素:选择数组中的一个元素作为基准元素(常见的选择有第一个元素、最后一个元素、随机选择等)。
  2. 分区操作:将数组分成两部分,小于基准的放左边,大于基准的放右边。基准元素最终的位置已经确定。
  3. 递归排序:对基准元素左侧和右侧的子数组进行递归调用快速排序,直到子数组的大小为1或0,排序完成。

时间复杂度:

  • 最佳情况:O(n log n),发生在每次分割时都能平衡地分成两部分。
  • 最坏情况:O(n^2),当数组已经有序或反向有序时,每次选择的基准元素都可能是最小或最大的元素,从而导致不均匀的分割。
  • 平均情况:O(n log n),在大多数情况下,快速排序的时间复杂度表现良好。

空间复杂度:

  • 快速排序是原地排序,只需要 O(log n) 的栈空间来存储递归调用的状态。
  • 空间复杂度主要取决于递归的深度,最坏情况下是 O(n),但平均情况下是 O(log n)。

快速排序的Java实现代码:

public class QuickSort {

    // 主函数:调用快速排序
    public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        quickSortHelper(arr, 0, arr.length - 1);
    }

    // 快速排序的核心递归函数
    private static void quickSortHelper(int[] arr, int left, int right) {
        if (left < right) {
            // 分区操作,返回基准元素的正确位置
            int pivotIndex = partition(arr, left, right);
            // 递归对基准元素左侧和右侧的子数组排序
            quickSortHelper(arr, left, pivotIndex - 1);
            quickSortHelper(arr, pivotIndex + 1, right);
        }
    }

    // 分区操作,返回基准元素的最终位置
    private static int partition(int[] arr, int left, int right) {
        // 选择最右边的元素作为基准元素
        int pivot = arr[right];
        int i = left - 1; // i 指向比基准小的元素区域的最后一个元素
        for (int j = left; j < right; j++) {
            if (arr[j] < pivot) {
                // 交换 arr[i + 1] 和 arr[j]
                i++;
                swap(arr, i, j);
            }
        }
        // 将基准元素放到正确位置
        swap(arr, i + 1, right);
        return i + 1; // 返回基准元素的索引
    }

    // 交换数组中两个元素的位置
    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    // 主函数入口,打印排序后的结果
    public static void main(String[] args) {
        int[] arr = {3, 6, 8, 10, 1, 2, 1};
        System.out.println("Original array: ");
        printArray(arr);
        
        quickSort(arr);

        System.out.println("Sorted array: ");
        printArray(arr);
    }

    // 打印数组的辅助函数
    private static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

代码解析:

  • quickSort:是快速排序的入口方法,接收一个数组作为参数,检查数组是否为空或大小小于2,若满足条件则无需排序,直接返回。
  • quickSortHelper:是一个递归函数,通过分区操作将数组划分为左右两部分,然后递归地对这两部分继续排序。
  • partition:分区操作方法,它选择数组的最后一个元素作为基准元素,并通过两端的指针进行交换,将小于基准的元素放到左边,大于基准的元素放到右边。最终,基准元素被放到正确位置并返回其索引。
  • swap:交换数组中两个元素的辅助函数。
  • printArray:打印数组内容的辅助函数。

复杂度分析:

  • 时间复杂度:
    • 最佳情况:O(n log n),当每次分区都能将数组平衡地分成两部分。
    • 最坏情况:O(n^2),当每次分区都选到数组的极端元素(如最小或最大),导致每次只能减少一个元素的排序,递归的深度为 n。
    • 平均情况:O(n log n),是快速排序最常见的表现。
  • 空间复杂度:
    • 最好和平均情况下:O(log n),由于递归的深度受限于树的高度。
    • 最坏情况下:O(n),当数组已经是排序好的,或者每次选到的基准元素极端时,递归的深度为 n。
作者 east
Java 12月 22,2024

大厂面试手撕面试题:堆排序(亲测可用的java实现)

堆排序(Heap Sort)是一种基于比较的排序算法,利用堆这种数据结构来实现排序。堆是一种完全二叉树,通常用数组来表示。堆排序分为两个步骤:构建最大堆和不断将堆顶元素与末尾元素交换,再进行堆调整。

思路:

  1. 构建最大堆:首先要将数组转化为一个最大堆。最大堆的特点是父节点的值大于等于其左右子节点的值。通过调整从最后一个非叶子节点开始,向上调整整个堆。
  2. 堆排序过程:
    • 将堆顶元素(最大值)与堆的最后一个元素交换。
    • 然后将堆的大小减1,调用堆调整操作(heapify)恢复堆的性质,继续重复上述过程,直到堆的大小为1。

时间复杂度:

  • 构建堆:O(n)。
    • 从最后一个非叶子节点开始调整,每次调整的时间是 O(log n),一共进行 n/2 次调整,因此时间复杂度是 O(n)。
  • 堆排序过程:每次需要调整堆结构,进行 n 次交换,每次调整堆的时间复杂度是 O(log n),所以堆排序的时间复杂度是 O(n log n)。

空间复杂度:

  • 堆排序是原地排序算法,它不需要额外的空间来存储数据。时间复杂度是 O(1)。

Java代码实现:

public class HeapSort {

    // 堆化操作,维护堆的性质
    public static void heapify(int[] arr, int n, int i) {
        int largest = i; // 初始化父节点为最大值
        int left = 2 * i + 1; // 左子节点
        int right = 2 * i + 2; // 右子节点

        // 如果左子节点比父节点大
        if (left < n && arr[left] > arr[largest]) {
            largest = left;
        }

        // 如果右子节点比父节点大
        if (right < n && arr[right] > arr[largest]) {
            largest = right;
        }

        // 如果最大值不是父节点,交换并继续堆化
        if (largest != i) {
            int temp = arr[i];
            arr[i] = arr[largest];
            arr[largest] = temp;

            // 递归堆化
            heapify(arr, n, largest);
        }
    }

    // 堆排序
    public static void heapSort(int[] arr) {
        int n = arr.length;

        // 构建最大堆
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }

        // 一个个地把最大元素移动到数组末尾
        for (int i = n - 1; i >= 1; i--) {
            // 将当前堆的根节点与末尾元素交换
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            // 调整堆
            heapify(arr, i, 0);
        }
    }

    // 输出数组
    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }

    // 主函数
    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6, 7};

        System.out.println("Original array:");
        printArray(arr);

        heapSort(arr);

        System.out.println("Sorted array:");
        printArray(arr);
    }
}

代码解析:

  1. heapify:这是一个递归函数,用于调整堆。每次比较父节点与左右子节点的大小,确保父节点是最大值。如果不是,则交换并继续对调整后的子树进行堆化。
  2. heapSort:
    • 第一部分是构建最大堆。从数组的最后一个非叶子节点开始,逐个堆化直到根节点。
    • 第二部分是排序,将堆顶元素与最后一个元素交换,然后调整堆,重复此过程,直到数组完全排序。
  3. printArray:用来输出数组的内容,便于调试和查看结果。

示例输出:

Original array: 12 11 13 5 6 7  
Sorted array: 5 6 7 11 12 13

作者 east
Java 12月 22,2024

大厂面试手撕面试题:归并排序(亲测可用的java实现)

归并排序(Merge Sort)是一种典型的分治算法,它将一个大问题分解成多个小问题,逐步解决,再合并结果,最终得到排序后的序列。

归并排序的思路:

  1. 分解(Divide):将待排序的数组分成两半,递归地对这两半分别进行归并排序。
  2. 解决(Conquer):对分解出的子数组继续进行排序,直到每个子数组只有一个元素(因为一个元素自然是有序的)。
  3. 合并(Combine):将排序后的子数组合并成一个有序的大数组。合并是归并排序的核心步骤。

归并排序的时间复杂度与空间复杂度:

  1. 时间复杂度:
    • 归并排序的时间复杂度是 O(nlogn),无论是最坏情况、最佳情况还是平均情况。这里的 n 是待排序元素的数量,logn 是因为每次递归将数组分成两半,直到数组大小为1。
    • 每一层递归的合并操作是线性时间复杂度O(n),递归深度是logn,所以总的时间复杂度是 O(nlogn)。
  2. 空间复杂度:
    • 归并排序需要额外的空间来存储合并过程中的中间结果,空间复杂度为O(n)。
    • 在递归调用过程中,每次递归调用栈的深度是logn,但归并过程中需要额外的存储空间来存储中间的合并结果,所以总空间复杂度是O(n)。

归并排序的Java实现:

public class MergeSort {
    
    // 归并排序函数
    public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        // 调用辅助函数进行递归排序
        mergeSortHelper(arr, 0, arr.length - 1);
    }

    // 递归的归并排序方法
    private static void mergeSortHelper(int[] arr, int left, int right) {
        if (left < right) {
            int mid = left + (right - left) / 2;  // 防止溢出
            mergeSortHelper(arr, left, mid);       // 排序左半部分
            mergeSortHelper(arr, mid + 1, right);  // 排序右半部分
            merge(arr, left, mid, right);          // 合并两部分
        }
    }

    // 合并两个有序子数组
    private static void merge(int[] arr, int left, int mid, int right) {
        // 创建临时数组存储合并结果
        int[] temp = new int[right - left + 1];
        int i = left, j = mid + 1, k = 0;

        // 合并两个有序子数组
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }

        // 如果左半部分有剩余元素,直接复制到temp数组
        while (i <= mid) {
            temp[k++] = arr[i++];
        }

        // 如果右半部分有剩余元素,直接复制到temp数组
        while (j <= right) {
            temp[k++] = arr[j++];
        }

        // 将临时数组的内容拷贝回原数组
        System.arraycopy(temp, 0, arr, left, temp.length);
    }

    // 测试归并排序
    public static void main(String[] args) {
        int[] arr = {38, 27, 43, 3, 9, 82, 10};
        System.out.println("排序前: ");
        printArray(arr);

        mergeSort(arr);

        System.out.println("排序后: ");
        printArray(arr);
    }

    // 打印数组
    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}

代码解析:

  1. mergeSort 函数:是外部调用的接口,接收待排序的数组。首先检查数组的有效性(如果为空或长度小于2直接返回)。
  2. mergeSortHelper 函数:是递归的核心部分,负责将数组分成两部分,分别递归排序,直到分割到只有一个元素为止。
  3. merge 函数:这是合并的关键部分,它接受三个参数:left, mid, right,分别表示左部分的起始索引,右部分的结束索引。合并操作会创建一个临时数组,按顺序将两个已排序的子数组合并到这个临时数组中,然后再将其复制回原数组。
  4. printArray 函数:打印数组元素的辅助函数。

测试:

给定输入数组 {38, 27, 43, 3, 9, 82, 10},归并排序后的输出应为:

排序前:  38 27 43 3 9 82 10  
排序后: 3 9 10 27 38 43 82
作者 east
Java 12月 22,2024

大厂面试手撕面试题:二分查找(亲测可用的java实现)

二分查找是一种在有序数组中查找特定元素的高效算法。其基本思路是通过逐步缩小查找范围来找到目标元素。每次将查找范围的中间元素与目标元素进行比较,根据比较结果决定继续查找左半部分还是右半部分。

二分查找的实现思路:

  1. 输入:一个有序数组 arr 和一个目标值 target。
  2. 初始化:设置两个指针,left 和 right,分别指向数组的左右两端(即 left = 0,right = arr.length - 1)。
  3. 循环查找:
    • 计算中间位置 mid = left + (right - left) / 2。
    • 如果 arr[mid] == target,则找到了目标值,返回 mid(即元素的索引)。
    • 如果 arr[mid] < target,说明目标值可能在右半部分,将 left 移动到 mid + 1。
    • 如果 arr[mid] > target,说明目标值可能在左半部分,将 right 移动到 mid - 1。
  4. 退出条件:如果 left 超过了 right,说明数组中没有目标元素,返回 -1。

时间复杂度与空间复杂度分析:

  • 时间复杂度:O(log n),每次查找将问题的规模减少一半,因此时间复杂度为对数级别。
  • 空间复杂度:O(1),使用常数空间,只需要几个额外的变量(left、right 和 mid)来存储指针,没有使用额外的空间。

Java 完整代码实现:

public class BinarySearch {

    // 二分查找函数
    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;

        // 进行二分查找
        while (left <= right) {
            // 计算中间索引
            int mid = left + (right - left) / 2;

            // 检查中间元素是否为目标值
            if (arr[mid] == target) {
                return mid; // 找到目标,返回其索引
            }

            // 如果目标值大于中间元素,则调整搜索范围为右半部分
            if (arr[mid] < target) {
                left = mid + 1;
            }
            // 如果目标值小于中间元素,则调整搜索范围为左半部分
            else {
                right = mid - 1;
            }
        }

        // 目标值不存在于数组中,返回 -1
        return -1;
    }

    // 主函数,用于测试
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
        int target = 7;
        
        // 调用二分查找方法
        int result = binarySearch(arr, target);
        
        if (result != -1) {
            System.out.println("目标元素 " + target + " 在数组中的索引是: " + result);
        } else {
            System.out.println("目标元素 " + target + " 不在数组中");
        }
    }
}

代码解释:

  • binarySearch 方法:接收一个有序整数数组 arr 和一个目标值 target。通过不断调整左右指针,最终找到目标值并返回其索引。如果没有找到目标元素,则返回 -1。
  • main 方法:用于测试 binarySearch 方法。数组 arr 是已排序的,target 是我们要查找的目标值。

样例输出:

目标元素 7 在数组中的索引是: 3
作者 east
Java 12月 22,2024

大厂面试手撕面试题:数组的全排列(亲测可用的java实现)

在面试中,关于数组的全排列问题是一个经典的考察题目,能够检验候选人的递归思维、回溯算法的理解和实现能力。

思路:

要获取一个数组的全排列,我们可以利用回溯算法。具体来说,回溯算法通过递归的方式逐步生成排列,在每一步都将一个元素加入排列中,然后在下一步递归中排除已选元素,回溯的时候撤销选择,尝试其他可能。

步骤:

  1. 递归生成排列:
    • 使用一个辅助数组来记录当前的排列。
    • 对于每个位置,我们尝试填充每一个可能的元素,并递归地填充后续的位置。
    • 使用回溯的方式,在完成一个排列后,撤回当前选择,继续尝试其他可能性。
  2. 交换元素:
    • 通过交换数组中的元素来生成排列,而不是额外使用空间存储状态。这样可以减少空间复杂度。

时间复杂度:

  • 生成全排列的时间复杂度是 O(n!),因为每个元素都需要和其他元素交换一遍,排列的总数为 n!。

空间复杂度:

  • 空间复杂度是 O(n),因为递归调用栈的深度是 n(每次递归深度为数组的长度),且我们只需要常数空间来交换数组元素。

Java 代码实现:

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

public class Permutations {

    // 主函数,返回所有的全排列
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        backtrack(nums, new ArrayList<>(), result, new boolean[nums.length]);
        return result;
    }

    // 回溯函数,生成排列
    private void backtrack(int[] nums, List<Integer> current, List<List<Integer>> result, boolean[] used) {
        // 当当前排列的长度等于nums的长度时,说明找到了一个全排列
        if (current.size() == nums.length) {
            result.add(new ArrayList<>(current));
            return;
        }

        // 遍历nums数组中的每个元素
        for (int i = 0; i < nums.length; i++) {
            // 如果该元素已经被使用过,则跳过
            if (used[i]) continue;

            // 做选择,标记当前元素为已使用
            used[i] = true;
            current.add(nums[i]);

            // 递归生成剩余的排列
            backtrack(nums, current, result, used);

            // 撤销选择,回溯
            used[i] = false;
            current.remove(current.size() - 1);
        }
    }

    // 测试主函数
    public static void main(String[] args) {
        Permutations solution = new Permutations();
        int[] nums = {1, 2, 3};
        List<List<Integer>> result = solution.permute(nums);

        // 打印结果
        for (List<Integer> perm : result) {
            System.out.println(perm);
        }
    }
}

代码解析:

  1. 主函数 permute(int[] nums):
    • 该函数会返回所有的全排列。我们初始化一个空的 result 列表,并调用 backtrack 函数来生成排列。
  2. 回溯函数 backtrack(int[] nums, List<Integer> current, List<List<Integer>> result, boolean[] used):
    • current 存储当前的排列结果。
    • used 数组记录每个元素是否已经被选择过。
    • 每次递归,我们将一个没有被使用的元素添加到 current 中,并在递归完成后回溯,撤销当前选择。
  3. 时间复杂度和空间复杂度:
    • 时间复杂度:O(n!),因为要生成n个元素的所有排列,总共有n!个排列,每个排列需要O(n)的时间来生成。
    • 空间复杂度:O(n),递归调用栈深度最大为n。

测试示例:

对于输入 nums = [1, 2, 3],输出应为:

[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]
作者 east
Java 12月 22,2024

大厂面试手撕面试题:合并两个有序数组(亲测可用的java实现)

在面试中,如果遇到要求合并两个有序数组的问题,可以通过以下步骤来实现:

思路:

  1. 双指针法:我们使用两个指针分别指向两个数组的起始位置。
  2. 比较大小:每次比较两个数组当前指针指向的元素,将较小的元素加入到结果数组中,并移动对应的指针。
  3. 处理剩余元素:当其中一个数组的所有元素都被合并到结果数组中时,另一个数组剩余的元素直接追加到结果数组中。

关键点:

  • 如果两个数组的长度分别为 n 和 m,那么合并的时间复杂度是 O(n + m),因为每个元素只会被处理一次。
  • 空间复杂度是 O(n + m),因为我们需要一个新的数组来存储结果。

时间复杂度:

  • 时间复杂度:O(n + m),其中 n 和 m 分别是两个数组的长度。我们需要遍历两个数组的每个元素一次。

空间复杂度:

  • 空间复杂度:O(n + m),因为我们需要一个新的数组来存储合并后的结果。

Java代码实现:

public class MergeSortedArrays {
    
    // 合并两个有序数组
    public static int[] merge(int[] arr1, int[] arr2) {
        // 创建一个新数组,大小为两个数组之和
        int n = arr1.length;
        int m = arr2.length;
        int[] result = new int[n + m];
        
        int i = 0, j = 0, k = 0;
        
        // 合并两个数组,直到有一个数组遍历完
        while (i < n && j < m) {
            if (arr1[i] <= arr2[j]) {
                result[k++] = arr1[i++];
            } else {
                result[k++] = arr2[j++];
            }
        }
        
        // 将剩余元素添加到结果数组中
        while (i < n) {
            result[k++] = arr1[i++];
        }
        while (j < m) {
            result[k++] = arr2[j++];
        }
        
        return result;
    }

    public static void main(String[] args) {
        int[] arr1 = {1, 3, 5, 7};
        int[] arr2 = {2, 4, 6, 8};
        
        int[] mergedArray = merge(arr1, arr2);
        
        // 打印合并后的数组
        System.out.print("Merged array: ");
        for (int num : mergedArray) {
            System.out.print(num + " ");
        }
    }
}

解释:

  • 我们通过 merge 方法来合并两个有序数组 arr1 和 arr2。
  • 使用三个指针 i, j, k:
    • i 用来遍历 arr1。
    • j 用来遍历 arr2。
    • k 用来填充合并结果数组 result。
  • 每次比较 arr1[i] 和 arr2[j],将较小的元素放入 result[k] 中,移动对应的指针。直到其中一个数组遍历完。
  • 剩余未遍历完的数组直接复制到结果数组的末尾。

输出:

Merged array: 1 2 3 4 5 6 7 8
作者 east
Java 12月 22,2024

大厂面试手撕面试题:求一个字符串中最长不重复子串的长度(亲测可用的java实现)

这是一个常见的面试题,要求找到字符串中最长的不重复子串的长度。我们可以使用 滑动窗口 和 哈希集合 的方法来有效地解决这个问题。

思路:

  1. 滑动窗口:我们通过维护一个窗口来追踪当前不重复的子串。窗口的左边和右边分别由两个指针表示,我们通过右指针来扩展窗口,左指针则会根据需要收缩窗口。
  2. 哈希集合:为了高效检查一个字符是否已经在当前窗口中,我们可以使用哈希集合来存储窗口中的字符。
  3. 当我们遇到重复字符时,左指针会移动到重复字符之后的位置,确保窗口内的字符不重复。

具体步骤:

  • 初始化一个空的哈希集合,用于存储当前窗口内的字符。
  • 使用两个指针:left 和 right。right 用于扩展窗口,left 用于收缩窗口。
  • 如果当前字符(s[right])不在哈希集合中,表示没有重复字符,将其加入集合,并更新最大长度。
  • 如果当前字符已经在集合中,移动 left 指针,直到窗口中的字符没有重复。
  • 每次移动 right 指针时,更新当前窗口的最大长度。

时间复杂度:

  • 时间复杂度是 O(n),其中 n 是字符串的长度。因为每个字符最多只会被访问两次(一次通过右指针,另一次通过左指针)。

空间复杂度:

  • 空间复杂度是 O(min(n, m)),其中 n 是字符串的长度,m 是字符集的大小(对于英语字符集而言,m 通常是常数 256)。

Java 代码实现:

import java.util.HashSet;

public class LongestUniqueSubstring {
    public static int lengthOfLongestSubstring(String s) {
        // 用一个哈希集合来记录当前窗口内的字符
        HashSet<Character> set = new HashSet<>();
        
        int left = 0;  // 滑动窗口的左指针
        int maxLength = 0;  // 记录最长子串的长度
        
        // 遍历字符串
        for (int right = 0; right < s.length(); right++) {
            // 当右指针指向的字符已经在集合中,收缩窗口
            while (set.contains(s.charAt(right))) {
                set.remove(s.charAt(left));
                left++;
            }
            // 将当前字符加入集合
            set.add(s.charAt(right));
            // 更新最大长度
            maxLength = Math.max(maxLength, right - left + 1);
        }
        
        return maxLength;
    }

    public static void main(String[] args) {
        String s = "abcabcbb";
        System.out.println("The length of the longest substring without repeating characters is: " 
                            + lengthOfLongestSubstring(s));  // Output: 3 ("abc")
    }
}

代码解释:

  1. set 是一个哈希集合,用来存储当前窗口中的字符。
  2. left 是滑动窗口的左指针,right 是滑动窗口的右指针。
  3. 遍历字符串时,检查当前字符 s.charAt(right) 是否已经在窗口中。如果在,就不断移动 left 指针,直到窗口内没有重复字符。
  4. 每次更新 right 指针时,计算当前窗口的长度,更新最大长度 maxLength。

示例:

对于输入 "abcabcbb":

  • 经过滑动窗口的计算,最长的不重复子串为 "abc",长度为 3。
作者 east
Java 12月 22,2024

大厂面试手撕面试题:输出 2 到 N 之间的全部素数(亲测可用的java实现)

在面试时,要求输出 2 到 N 之间的所有素数是一个经典的问题,通常会考察应聘者对算法和时间空间复杂度的理解。下面是思路的详细解释,以及 Java 代码实现。

思路

  1. 素数定义:素数是大于1的自然数,且仅能被1和自身整除。
  2. 方法选择:
    • 最直接的解法是对于每个数字 i,判断它是否为素数。这个判断过程是通过检查 i 是否能被小于等于 i 的所有整数整除来完成。显然,时间复杂度较高。
    • 更高效的方法是 埃拉托斯特尼筛法(Sieve of Eratosthenes)。该方法的思想是:从2开始,将所有2的倍数标记为非素数,然后依次处理3、4、5等,直到处理到 √N 为止。这个方法能够有效减少判断素数的次数。

时间复杂度和空间复杂度分析

  1. 埃拉托斯特尼筛法的时间复杂度:
    • 时间复杂度是 O(N log log N),这个复杂度是通过逐步标记每个合数来实现的,比暴力方法要高效得多。
  2. 空间复杂度:
    • 空间复杂度是 O(N),因为我们需要一个大小为 N 的布尔数组来存储每个数是否是素数。

Java 实现(埃拉托斯特尼筛法)

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

public class PrimeNumbers {

    // 埃拉托斯特尼筛法:输出2到N之间的素数
    public static List<Integer> sieveOfEratosthenes(int N) {
        // 布尔数组,true表示该数是素数,false表示该数不是素数
        boolean[] isPrime = new boolean[N + 1];
        
        // 初始时,所有数字都假设为素数
        for (int i = 2; i <= N; i++) {
            isPrime[i] = true;
        }
        
        // 从2开始,标记所有合数
        for (int i = 2; i * i <= N; i++) {
            if (isPrime[i]) {
                // 如果i是素数,将i的所有倍数标记为非素数
                for (int j = i * i; j <= N; j += i) {
                    isPrime[j] = false;
                }
            }
        }
        
        // 收集所有素数
        List<Integer> primes = new ArrayList<>();
        for (int i = 2; i <= N; i++) {
            if (isPrime[i]) {
                primes.add(i);
            }
        }
        
        return primes;
    }

    public static void main(String[] args) {
        int N = 50; // 可以根据需要修改N的值
        List<Integer> primes = sieveOfEratosthenes(N);
        
        // 输出素数
        System.out.println("2到" + N + "之间的素数:");
        for (int prime : primes) {
            System.out.print(prime + " ");
        }
    }
}

代码解释

  1. 布尔数组 isPrime[]:用于记录每个数字是否为素数,初始化时假设所有数字都为素数,之后逐步筛选。
  2. 筛法核心:
    • 从 i = 2 开始,如果 i 是素数,则将 i 的所有倍数标记为非素数。注意,i 的倍数可以从 i*i 开始,因为 i 的更小的倍数(例如 2*i)已经在之前的步骤中被处理过。
  3. 收集素数:遍历 isPrime[] 数组,所有值为 true 的位置对应的数字是素数,将它们加入结果列表 primes。

输出结果

如果 N = 50,输出的素数会是:

Copy Code2到50之间的素数:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47
作者 east
Java 12月 22,2024

大厂面试手撕面试题:合并两个有序链表(亲测可用的java实现)

在面试中,合并两个有序链表的题目是非常常见的。这个问题的关键是利用两个链表的有序性来高效地合并它们。

思路:

  1. 初始化两个指针:
    • 一个指针指向链表A的头节点,另一个指针指向链表B的头节点。
  2. 比较两个指针所指向的节点值:
    • 比较当前两个节点的值,将较小的节点添加到新的链表中。
    • 然后,移动对应指针到下一个节点,继续比较。
  3. 处理剩余的部分:
    • 当其中一个链表的节点全部合并到新链表后,直接将另一个链表的剩余部分连接到新链表上。
  4. 返回结果:
    • 合并完成后返回新链表的头节点。

时间复杂度:

  • 每个链表的节点都需要访问一次,时间复杂度为 �(�+�)O(n+m),其中 �n 和 �m 分别是两个链表的长度。

空间复杂度:

  • 空间复杂度为 �(1)O(1),因为我们是在原地合并链表,没有使用额外的空间(除了新链表的头节点指针)。

Java代码实现:

// Definition for singly-linked list.
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

public class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        // 创建一个虚拟头节点,简化处理
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;
        
        // 遍历两个链表
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                current.next = l1;
                l1 = l1.next;
            } else {
                current.next = l2;
                l2 = l2.next;
            }
            current = current.next;
        }
        
        // 如果有一个链表还剩余节点,直接连接到合并链表的尾部
        if (l1 != null) {
            current.next = l1;
        } else if (l2 != null) {
            current.next = l2;
        }
        
        // 返回合并后的链表,跳过虚拟头节点
        return dummy.next;
    }
}

代码解析:

  1. ListNode类: 这是链表节点的定义,每个节点包含一个整数值和一个指向下一个节点的指针。
  2. mergeTwoLists方法:
    • dummy 是一个虚拟的头节点,它用于简化处理过程,最终返回合并后的链表。
    • current 用来追踪合并链表的最后一个节点。
    • 在 while 循环中,比较 l1 和 l2 的当前节点,选择较小的节点并将其加入到合并链表中。然后,继续移动指针。
    • 当一个链表结束时,直接将另一个链表剩余的部分连接到合并链表。
  3. 返回结果: 最后返回 dummy.next,这是合并后的链表的头节点。
作者 east
Java 12月 22,2024

大厂面试手撕面试题:字符串的全排列(要求去重)(java实现)

在面试中,字符串的全排列问题是一个经典的面试题,要求生成一个字符串的所有全排列,且去重。这个问题可以通过回溯法(Backtracking)来实现,同时利用一个 HashSet 来避免重复的排列。下面我会详细说明思路、时间复杂度和空间复杂度,并给出完整的 Java 代码。

1. 问题理解

给定一个字符串,要求输出该字符串的所有可能的排列(排列需要去重),并且考虑到字符串可能包含重复字符,结果中的排列也应该去重。

2. 思路分析

使用回溯法生成所有可能的排列。回溯法的核心思想是递归地交换字符,在每一层递归中交换一个字符到当前位置,并继续处理剩下的部分。为了避免重复的排列,可以在递归过程中使用一个 HashSet 来记录已经生成的排列。

步骤:

  1. 排序:首先对字符串进行排序,可以帮助我们提前跳过重复字符。例如,如果字符串是 “AAB”,排序后是 “AAB”,这样我们可以确保在递归过程中只处理一遍相同的字符。
  2. 回溯法生成排列:在递归中,每次交换一个字符到当前位置,然后递归处理剩余部分。
    • 在交换字符时,检查该字符是否已经在当前位置的前面出现过,如果出现过则跳过。
  3. 去重:为了避免重复的排列结果,我们可以使用一个 HashSet 来记录所有已生成的排列(字符串形式)。

3. 时间复杂度和空间复杂度

  • 时间复杂度:生成排列的总数是 n!,其中 n 是字符串的长度。每次递归交换的时间复杂度是 O(n),因此总体时间复杂度为 O(n * n!)。
  • 空间复杂度:空间复杂度主要由递归栈和存储结果的集合组成。递归栈的深度最大为 n,存储结果的集合最多保存 n! 个排列,因此空间复杂度为 O(n * n!)。

4. Java代码实现

import java.util.*;

public class Solution {
    public List<String> permuteUnique(String s) {
        // 用一个列表保存结果
        List<String> result = new ArrayList<>();
        // 将字符串转换为字符数组并排序,排序后有助于去重
        char[] chars = s.toCharArray();
        Arrays.sort(chars);
        
        // 结果集合,用来存储去重后的排列
        Set<String> set = new HashSet<>();
        
        // 通过回溯法生成排列
        backtrack(chars, 0, result, set);
        
        // 将集合转换为列表返回
        return new ArrayList<>(set);
    }

    private void backtrack(char[] chars, int index, List<String> result, Set<String> set) {
        // 当到达字符数组的最后一位时,生成一个排列
        if (index == chars.length) {
            String permutation = new String(chars);
            set.add(permutation);  // 将当前排列加入结果集合
            return;
        }

        // 遍历每个字符
        for (int i = index; i < chars.length; i++) {
            // 如果当前字符和前一个字符相同,跳过(避免重复排列)
            if (i > index && chars[i] == chars[i - 1]) {
                continue;
            }
            // 交换字符
            swap(chars, i, index);
            // 递归处理
            backtrack(chars, index + 1, result, set);
            // 回溯,恢复交换前的状态
            swap(chars, i, index);
        }
    }

    // 辅助函数:交换字符数组中的两个字符
    private void swap(char[] chars, int i, int j) {
        char temp = chars[i];
        chars[i] = chars[j];
        chars[j] = temp;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        String s = "AAB";
        List<String> result = solution.permuteUnique(s);
        for (String str : result) {
            System.out.println(str);
        }
    }
}

5. 解释代码

  • permuteUnique 方法:首先将输入字符串转换为字符数组,并对字符数组进行排序。然后调用回溯方法 backtrack 来生成所有的排列。
  • backtrack 方法:这是回溯法的核心部分。在每一层递归中,遍历当前位置后面的所有字符,交换并递归处理。
  • swap 方法:用于交换字符数组中的两个字符。
  • 去重:通过 Set 来存储所有排列,确保没有重复的排列结果。

6. 举例说明

对于输入字符串 "AAB":

  1. 排序后得到 ['A', 'A', 'B']。
  2. 通过回溯法生成所有排列并使用 HashSet 去重,最终得到 [ "AAB", "ABA", "BAA" ]。

7. 测试

在 main 方法中,我们测试了输入 "AAB",并打印了结果。你可以替换 s 的值来测试其他输入。

8. 总结

这道题通过回溯法可以有效生成所有排列,并且通过排序和 Set 来保证去重。时间复杂度是 O(n * n!),空间复杂度是 O(n * n!),适合用来处理字符串全排列的相关问题。

作者 east

上一 1 … 15 16 17 … 93 下一个

关注公众号“大模型全栈程序员”回复“小程序”获取1000个小程序打包源码。回复”chatgpt”获取免注册可用chatgpt。回复“大数据”获取多本大数据电子书

标签

AIGC AI创作 bert chatgpt github GPT-3 gpt3 GTP-3 hive mysql O2O tensorflow UI控件 不含后台 交流 共享经济 出行 图像 地图定位 外卖 多媒体 娱乐 小程序 布局 带后台完整项目 开源项目 搜索 支付 效率 教育 日历 机器学习 深度学习 物流 用户系统 电商 画图 画布(canvas) 社交 签到 联网 读书 资讯 阅读 预订

官方QQ群

小程序开发群:74052405

大数据开发群: 952493060

近期文章

  • 解决gitlab配置Webhooks,提示 Invalid url given的问题
  • 如何在Chrome中设置启动时自动打开多个默认网页
  • spark内存溢出怎样区分是软件还是代码原因
  • MQTT完全解析和实践
  • 解决运行Selenium报错:self.driver = webdriver.Chrome(service=service) TypeError: __init__() got an unexpected keyword argument ‘service’
  • python 3.6使用mysql-connector-python报错:SyntaxError: future feature annotations is not defined
  • 详解Python当中的pip常用命令
  • AUTOSAR如何在多个供应商交付的配置中避免ARXML不兼容?
  • C++thread pool(线程池)设计应关注哪些扩展性问题?
  • 各类MCAL(Microcontroller Abstraction Layer)如何与AUTOSAR工具链解耦?

文章归档

  • 2025年12月
  • 2025年10月
  • 2025年8月
  • 2025年7月
  • 2025年6月
  • 2025年5月
  • 2025年4月
  • 2025年3月
  • 2025年2月
  • 2025年1月
  • 2024年12月
  • 2024年11月
  • 2024年10月
  • 2024年9月
  • 2024年8月
  • 2024年7月
  • 2024年6月
  • 2024年5月
  • 2024年4月
  • 2024年3月
  • 2023年11月
  • 2023年10月
  • 2023年9月
  • 2023年8月
  • 2023年7月
  • 2023年6月
  • 2023年5月
  • 2023年4月
  • 2023年3月
  • 2023年1月
  • 2022年11月
  • 2022年10月
  • 2022年9月
  • 2022年8月
  • 2022年7月
  • 2022年6月
  • 2022年5月
  • 2022年4月
  • 2022年3月
  • 2022年2月
  • 2022年1月
  • 2021年12月
  • 2021年11月
  • 2021年9月
  • 2021年8月
  • 2021年7月
  • 2021年6月
  • 2021年5月
  • 2021年4月
  • 2021年3月
  • 2021年2月
  • 2021年1月
  • 2020年12月
  • 2020年11月
  • 2020年10月
  • 2020年9月
  • 2020年8月
  • 2020年7月
  • 2020年6月
  • 2020年5月
  • 2020年4月
  • 2020年3月
  • 2020年2月
  • 2020年1月
  • 2019年7月
  • 2019年6月
  • 2019年5月
  • 2019年4月
  • 2019年3月
  • 2019年2月
  • 2019年1月
  • 2018年12月
  • 2018年7月
  • 2018年6月

分类目录

  • Android (73)
  • bug清单 (79)
  • C++ (34)
  • Fuchsia (15)
  • php (4)
  • python (45)
  • sklearn (1)
  • 云计算 (20)
  • 人工智能 (61)
    • chatgpt (21)
      • 提示词 (6)
    • Keras (1)
    • Tensorflow (3)
    • 大模型 (1)
    • 智能体 (4)
    • 深度学习 (14)
  • 储能 (44)
  • 前端 (5)
  • 大数据开发 (497)
    • CDH (6)
    • datax (4)
    • doris (31)
    • Elasticsearch (15)
    • Flink (79)
    • flume (7)
    • Hadoop (19)
    • Hbase (23)
    • Hive (41)
    • Impala (2)
    • Java (71)
    • Kafka (10)
    • neo4j (5)
    • shardingsphere (6)
    • solr (5)
    • Spark (100)
    • spring (11)
    • 数据仓库 (9)
    • 数据挖掘 (7)
    • 海豚调度器 (10)
    • 运维 (39)
      • Docker (3)
  • 小游戏代码 (1)
  • 小程序代码 (139)
    • O2O (16)
    • UI控件 (5)
    • 互联网类 (23)
    • 企业类 (6)
    • 地图定位 (9)
    • 多媒体 (6)
    • 工具类 (25)
    • 电商类 (22)
    • 社交 (7)
    • 行业软件 (7)
    • 资讯读书 (11)
  • 嵌入式 (71)
    • autosar (63)
    • RTOS (1)
    • 总线 (1)
  • 开发博客 (16)
    • Harmony (9)
  • 技术架构 (6)
  • 数据库 (32)
    • mongodb (1)
    • mysql (13)
    • pgsql (2)
    • redis (1)
    • tdengine (4)
  • 未分类 (8)
  • 程序员网赚 (20)
    • 广告联盟 (3)
    • 私域流量 (5)
    • 自媒体 (5)
  • 量化投资 (4)
  • 面试 (14)

功能

  • 登录
  • 文章RSS
  • 评论RSS
  • WordPress.org

All Rights Reserved by Gitweixin.本站收集网友上传代码, 如有侵犯版权,请发邮件联系yiyuyos@gmail.com删除.