仅以这几篇博文记录我的秋招之路
数据结构面试题
- 排序
- 归并
- 1、面试高频问题：排序（O(1) 复杂度的归并）
- 快排
- 快速排序的递归实现
- 数组中的K最大
- 最小的数及其之前的数
- 寻找两个有序数组的中位数
- 堆排序
- 堆排序的手写实现
- 堆排序实现优先队列
- 优先队列实现TopK
- 优先队列实现中位数
- 优先队列实现出现频率最大
- 冒泡排序 （空天院一面）
- 单调栈
- 单调栈应用
- 1、 环状数组求下一个最大
- 2、 接雨水
- 3、最大柱状矩形
- 4、最大连续1的面积 ---> 力扣85
- 5、每日温度
- 单调队列
- 单调队列的应用
- 解决窗口内最优的问题 （网易一面）经典应用
排序
归并
1、面试高频问题：排序（O(1) 复杂度的归并）
//空间复杂度O(1),时间复杂度o（nlogn）
public static void main(String[] args) {
int[] arr = new int[]{14,12,15,13,11,16};
//找到数组的最大值，并计算出maxval,然后调用递归的归并排序
int maxval = Arrays.stream(arr).max().getAsInt() + 1;
mergeSortDigui(arr, 0, arr.length - 1, maxval);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
// 递归归并排序 算法优化
public static void mergeSortDigui(int[] nums, int l, int r,int max){
if(l < r){
int mid = l + (r - l)/2;
mergeSortDigui(nums,l, mid,max);
mergeSortDigui(nums, mid + 1, r,max);
mergeSortO1(nums, l, mid, r, max);
}
}
//O(1)复杂度实现
//用两个数来存储一个数
public static void mergeSortO1(int[] arr, int l, int mid, int r, int max) {
int start0 = l, start1 = mid+1, i = l;
while(start0 <= mid && start1 <= r){
if(arr[start0] % max <= arr[start1] % max){
arr[i] = arr[i] + (arr[start0] % max) *max;
i++;
start0++;
}
else {
arr[i] = arr[i] + (arr[start1] % max ) *max;
i++;
start1++;
}
}
while (start0 <= mid){
arr[i] = arr[i] + (arr[start0] % max) *max;
i++;
start0++;
}
while (start1 <= r){
arr[i] = arr[i] + (arr[start1] % max ) *max;
i++;
start1++;
}
for(start0 = l; start0 <= r; start0++)
arr[start0] = arr[start0] /max;
}快排
快速排序的递归实现
public static void main(String[] args) {
int[] nums = new int[]{5,3,8,6,4};
quickSort(nums, 0, nums.length-1);
}
public static void quickSort(int[] nums, int l, int r){
if(l >= r) return;
int base = nums[l], i = l, j = r;
while (i < j){
while (i < j && nums[j] > base)
j--;
if(i < j)
nums[i++] = nums[j];
while (i < r && nums[i] < base)
i++;
if(i < r)
nums[j--] = nums[i];
}
nums[i] = base;
quickSort(nums, l, i-1);
quickSort(nums, i+1, r);
}数组中的K最大
public static int Knumber(int[] nums, int k){
int n = nums.length;
return quickSort(nums, 0, n-1, n-k);
}
public static int quickSort(int[] nums,int l, int r,int k){
if(l >= r) return nums[l];
int base = nums[l], i = l, j = r;
while (i < j){
while(i < j && nums[j] > base)
j--;
if(i < j)
nums[i++] = nums[j];
while (i < j && nums[i] < base)
i++;
if(i < r)
nums[j--] = nums[i];
}
nums[i] = base;
if(i == k)
return nums[i];
return i > k? quickSort(nums, l, i-1, k):quickSort(nums, i+1, r, k);
}最小的数及其之前的数
public static int[] KsmallerNumber(int[] nums, int k){
int n = nums.length;
quickSort(nums, 0, n - 1, k);//此时quickSort无返回值，只实现排序功能。
int[] num = new int[k];
for(int i = 0; i< k;i++){
num[i] = nums[i];
}
}寻找两个有序数组的中位数
public double findMedianSortedArrays(int[] nums1, int[] nums2) {
int[] nums = new int[nums1.length + nums2.length];
for(int i = 0; i< nums1.length;i++){
nums[i] = nums1[i];
}
int j = 0;
for(int i = nums1.length; i < nums.length;i++){
nums[i] = nums2[j];
j++;
}
int n = nums.length;
if(n%2 == 0)
return (double)(quickSort(nums, 0, n-1, n/2-1) + quickSort(nums,n/2, n-1,n/2))/2;
else
return quickSort(nums, 0, n-1, n/2);
}堆排序
堆排序的手写实现
public static void main(String[] args) {
int[] nums = new int[]{14,12,15,13,11,16};
heapSort(nums);
}
//堆排序空间复杂度O(1),时间复杂度o（nlogn）
public static void heapSort(int[] arr) {
for(int i = arr.length / 2 - 1; i >= 0; i--) {
adjustHeap(arr, i, arr.length);
}
for(int j = arr.length - 1; j > 0; j--) {
swap(arr, 0, j);
adjustHeap(arr, 0, j);
}
}
public static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
public static void adjustHeap(int[] arr, int i, int length) {
int temp = arr[i];//先取出当前元素i
for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {//从i结点的左子结点开始，也就是2i+1处开始
if (k + 1 < length && arr[k] < arr[k + 1]) {//如果左子结点小于右子结点，k指向右子结点
k++;
}
if (arr[k] > temp) {//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
arr[i] = arr[k];
i = k;
} else {
break;
}
}
arr[i] = temp;//将temp值放到最终的位置
}堆排序实现优先队列
优先队列实现TopK
优先队列实现中位数
优先队列实现出现频率最大
冒泡排序 （空天院一面）
//时间复杂度O(N2),空间复杂度O1
public static void bubblesort(int[] nums){
int n = nums.length;
boolean didswap; //设置标志位进行优化
for (int j = 0; j < n; j++) {
didswap = false;
for (int i = 0; i < n-1; i++) {
if(nums[i] > nums[i+1]){
swap(nums, i, i+1);
didswap = true;//减少在有序时的循环次数
}
}
if (didswap == false)
return;
}
}
public static void swap(int[] nums, int a, int b){ // 此处注意函数传递，应把nums，i， j，同时传入才可更改
int c;
c = nums[a];
nums[a] = nums[b];
nums[b] = c;
}单调栈
单调栈应用
//单调栈问题，解决下一个更大，上一个比它大的问题。(由于是下一个更大，倒着入栈更易理解)
//更大问题，采用单调递减栈,此时栈顶元素为最大元素，若栈为空，则返回-1
public static int[] NextGreaterNumberIndex(int[] nums){
Stack<Integer> stack1 = new Stack<>();
int n = nums.length, max = 0;
int[] right = new int[n];
for (int i = n-1; i >= 0; i--) {
while (!stack1.isEmpty() && nums[i] >= nums[stack1.peek()]) //易错
stack1.pop();
right[i] = stack1.isEmpty() ? -1 : stack1.peek(); //下一个比它大的数，或下标
stack1.push(i);
}
return right;
}
public static int[] PreviousGreaterNumber(int[] nums){
int n = nums.length;
Stack<Integer> stack1 = new Stack<>();
int[] left = new int[n];
for (int i = 0; i < n; i++) {
while (!stack1.isEmpty() && nums[i] >= nums[stack1.peek()])
stack1.pop();
left[i] = stack1.isEmpty() ? -1 : stack1.peek();
stack1.push(i);
}
return left;
}拓展应用+延伸：
1、 环状数组求下一个最大
public static int[] CircleNextGreaterNumberIndex(int[] nums){
int n = nums.length;
Stack<Integer> stack1 = new Stack<>();
int[] right = new int[n];
for (int i = 2*n - 1; i >= 0; i--) {
while (!stack1.isEmpty() && nums[i % n] >= nums[stack1.peek()])
stack1.pop();
right[i % n] = stack1.isEmpty() ? -1 : stack1.peek();
stack1.push(i % n);
}
return right;
}2、 接雨水
未做。3、最大柱状矩形
//边界问题，采用单调递增栈
//此时栈顶元素为最小边界，若为空，则返回数组两边边界值。
public static int[] largestRectangleArea(int[] nums){
int n = heights.length;
int res = Integer.MIN_VALUE;
int[] left = new int[n];
int[] right = new int[n];
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < n ; i++) {
while (!stack.isEmpty() && heights[i] <= heights[stack.peek()])
stack.pop();
left[i] = stack.isEmpty()? -1 : stack.peek();
stack.push(i);
}
for (int i = 0; i < stack.size(); i++) {
System.out.println(stack.pop());
}
stack.clear();
for (int i = n-1; i >= 0 ; i--) {
while (!stack.isEmpty() && heights[i] <= heights[stack.peek()])
stack.pop();
right[i] = stack.isEmpty()? n : stack.peek();
stack.push(i);
}
for (int i = 0; i < n ; i++) {
res = Math.max(res, (right[i]-left[i] - 1) * heights[i]);
}
return res;
}4、最大连续1的面积 —> 力扣85
public static int MaximalRectangle(int[][] matrix){
int rows = matrix.length;
if(rows == 0) System.out.println(0);
int cols = matrix[0].length;
int[][] ans = new int[rows][cols];
int[][] left = new int[rows][cols];
int[][] right = new int[rows][cols];
int area = Integer.MIN_VALUE;
for (int i = 0; i < cols; i++) { //计算每列中连续1的个数
int nums_1 = 0;
for (int j = 0; j < rows; j++) {
nums_1 = matrix[j][i] * nums_1 + matrix[j][i];
ans[j][i] = nums_1;
}
}
for (int i = 0; i < rows; i++) { //计算矩阵中每个值的左边与右边的边界
Stack<Integer> stack = new Stack<>();
for (int j = 0; j < cols; j++) { //计算边界值
while (!stack.isEmpty() && ans[i][j] <= ans[i][stack.peek()])
stack.pop();
left[i][j] = stack.isEmpty()? -1 : stack.peek();
stack.push(j);
}
stack.clear();
for (int j = cols-1; j >= 0; j--) {
while (!stack.isEmpty() && ans[i][j] <= ans[i][stack.peek()])
stack.pop();
right[i][j] = stack.isEmpty()? cols : stack.peek();
stack.push(j);
}
}
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
area = Math.max((right[i][j] - left[i][j] - 1) * ans[i][j] , area);
}
}
return area;
}5、每日温度
求下一个更大数离当前索引的距离，若无下一个最大数，返回0。维护单调递增栈。
public int[] dailyTemperatures(int[] temperatures) {
int n = temperatures.length;
Stack<Integer> stack = new Stack<>();
int[] res = new int[n];
for(int i = 0; i < n;i++){
while(!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]){
int index = stack.pop();
res[index] = i - index;
}
stack.push(i);
}
return res;
}单调队列
单调队列的应用
解决窗口内最优的问题 （网易一面）经典应用
public static int MaxSub(int[] nums, int k){
int n = nums.length;
int max = Integer.MIN_VALUE, min = Integer.MAX_VALUE; //窗口内当前最大值与最小值
int sub = 0;
int left = 0, right = 0; //双指针控制窗口大小
LinkedList<Integer> greater_queue = new LinkedList<>(); //维护一个单调递减队列，队头元素极为最大值
LinkedList<Integer> lower_queue = new LinkedList<>(); //维护一个单调递增队列，队头元素极为最小值
while (left <= n - k){ //限定循环结束条件，按最后一次计算sub后的变量值为准
if(right - left < k){ // 窗口内执行
while (greater_queue.size() != 0 && nums[right] > greater_queue.getLast())
greater_queue.removeLast();
greater_queue.add(nums[right]);
max = greater_queue.getFirst();
while (lower_queue.size() != 0 && nums[right] < lower_queue.getLast())
lower_queue.removeLast();
lower_queue.add(nums[right]);
min = lower_queue.getFirst();
right++;
}
else { // 缩小窗口
sub = Math.max(max - min, sub); // 计算sub
if(nums[left] == greater_queue.getFirst()) //判断队首元素与出队元素之间的关系
greater_queue.removeFirst();
if(nums[left] == lower_queue.getFirst())
lower_queue.removeFirst();
left++;
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
