当前位置:   article > 正文

排序/二分法/链表/栈/队列/前缀树/链表相关面试题_在一个有序的数组中,给一个变量a,判断其是否存在该数组中,如果在则输出下标,如果

在一个有序的数组中,给一个变量a,判断其是否存在该数组中,如果在则输出下标,如果

目录

排序

选择排序

冒泡排序

插入排序

常见的时间复杂度排名(由好到差):7种

认识二分法

在一个有序数组中,找某个数是否存在

在一个有序数组中,找>=某个数最左侧的位置

在一个有序数组中,找<=某个数最右侧的位置

局部最小值问题

 认识异或运算

如何不用额外变量交换俩个数

数组中,一个数出现奇数,一个数出现偶数。那么怎么找到这个奇数。

怎么把一个int类型的数,提取出最右侧的1来(二进制)

数组中有俩种数出现了奇数次,其他的数都是偶数次。找到并打印这俩个数。

链表

单链表反转

双链表反转

单链表把给定的值删除

栈和队列

双向链表实现栈和队列

数组实现栈和队列

数组实现栈

数组实现队列

设计一个栈,在基本功能的基础上,增加返回栈中最小元素的功能(使用现成的栈结构)

如何用栈实现队列

如何用队列实现栈

递归

哈希表

有序表

排序

归并排序

数组小和

快速排序

堆结构

大根堆实现

堆排序

堆结构动态该数据

​编辑

系统实现的小根堆

 一个几乎有序的数组,排序之后元素移动的距离一定不超过k

前缀树

固定数组实现方式(26字母)

哈希表实现

桶排序

计数排序

基数排序

排序算法的总结

 链表相关面试题

快慢指针

判断单链表是否回文结构

单链表按照某值划分

rand指针

链表相交问题


排序

选择排序

时间复杂度为O(N²)

选择排序过程: 一个arr数组,我从

arr[0~N-1]范围上,找到最小值所在的位置,然后把最小值交换到0位置上;

arr[1~N-1]范围上,找到最小值所在的位置,然后把最小值交换到1位置上;

arr[2~N-1]范围上,找到最小值所在的位置,然后把最小值交换到2位置上;

以此类推~~~~

arr[N-2~N-1]范围上,找到最小值所在的位置,然后把最小值交换到N-2位置上;

  1. public static void selectionSort(int[] arr) {
  2. if (arr == null || arr.length < 2) {
  3. return;
  4. }
  5. for (int i = 0; i < arr.length - 1; i++) {
  6. int minIndex = i; //记录最小值的位置
  7. for (int j = i + 1; j < arr.length; j++) {
  8. minIndex = arr[j] < arr[minIndex] ? j : minIndex;
  9. }
  10. swap(arr, i, minIndex);
  11. }
  12. }
  13. public static void swap(int[] arr, int i, int j) {
  14. int tmp = arr[i];
  15. arr[i] = arr[j];
  16. arr[j] = tmp;
  17. }

冒泡排序

时间复杂度是O(N²)

冒泡排序过程:一个arr数组,

arr[0]和arr[0~N-1]范围上进行:arr[0]和arr[1],谁大谁往后移,arr[1]和arr[2]谁大谁往后移~~~以此类推~~~arr[N-2]和arr[N-1],谁大谁往后移到N-1位置上。

arr[0]和arr[0~N-2]范围上进行;

arr[0]和arr[0~N-3]范围上进行;

  1. public static void bubbleSort(int[] arr) {
  2. if (arr == null || arr.length < 2) {
  3. return;
  4. }
  5. for (int e = arr.length - 1; e > 0; e--) {
  6. for (int i = 0; i < e; i++) {
  7. if (arr[i] > arr[i + 1]) {
  8. swap(arr, i, i + 1);
  9. }
  10. }
  11. }
  12. }
  13. public static void swap(int[] arr, int i, int j) {
  14. arr[i] = arr[i] ^ arr[j];
  15. arr[j] = arr[i] ^ arr[j];
  16. arr[i] = arr[i] ^ arr[j];
  17. }

插入排序

时间复杂度是O(N²)

插入排序过程:一个arr数组

arr[0~0]上有序,必然后续;

arr[0~1]上有序,让arr[1]往前看,如果arr[1]<arr[0],就交换。此时有序

以此类推~~~

想让arr[0~i]上有序,让i往前看,小于就交换,直到左边的数不比自己大。

  1. public static void insertionSort(int[] arr) {
  2. if (arr == null || arr.length < 2) {
  3. return;
  4. }
  5. for (int i = 1; i < arr.length; i++) {
  6. for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
  7. swap(arr, j, j + 1);
  8. }
  9. }
  10. }
  11. public static void swap(int[] arr, int i, int j) {
  12. arr[i] = arr[i] ^ arr[j];
  13. arr[j] = arr[i] ^ arr[j];
  14. arr[i] = arr[i] ^ arr[j];
  15. }

常见的时间复杂度排名(由好到差):7种

O(1)

O(LogN)

O(N)

O(N*LogN)

O(N²)    

O(2^N)

O(N!)

认识二分法

只要能正确构建左右俩侧的淘汰逻辑,你就可以二分

时间复杂度是O(LogN)

在一个有序数组中,找某个数是否存在


                
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小蓝xlanll/article/detail/642387
推荐阅读
相关标签
  

闽ICP备14008679号