如果没有这些算法面试题，字节跳动面试不可能这么顺利

1、写一个字符串反转函数。

方法一：（利用递归实现）

1.  
   public static String reverse1(String s) {
2.  
   int length = s.length();
3.  
   if (length <= 1)
4.  
   return s;
5.  
   String left = s.substring( 0, length / 2);
6.  
   String right = s.substring(length / 2, length);
7.  
   return reverse1(right) + reverse1(left); //调用递归
8.  
   }

方法二：（拼接字符串）

1.  
   public static String reverse2(String s) {
2.  
   int length = s.length();
3.  
   String reverse = "";
4.  
   for ( int i = 0; i < length; i++)
5.  
   reverse = s.charAt(i) + reverse;
6.  
   return reverse;
7.  
   }

方法三：（利用数组，倒序输出）

1.  
   public static String reverse3(String s) {
2.  
   char[] array = s.toCharArray();
3.  
   String reverse = "";
4.  
   for ( int i = array.length - 1; i >= 0; i--)
5.  
   reverse += array[i];
6.  
   return reverse;
7.  
   }

方法四：（利用StringBuffer的内置reverse方法）

1.  
   public static String reverse4(String s) {
2.  
   return new StringBuffer(s).reverse().toString();
3.  
   }

方法五：（利用临时变量，交换两头数值）

1.  
   public static String reverse5(String orig) {
2.  
   char[] s = orig.toCharArray();
3.  
   int n = s.length - 1;
4.  
   int halfLength = n / 2;
5.  
   for ( int i = 0; i <= halfLength; i++) {
6.  
   char temp = s[i];
7.  
   s[i] = s[n - i];
8.  
   s[n - i] = temp;
9.  
   }
10.  
    return new String(s);
11.  
    }

方法六：（利用位异或操作，交换两头数据）

1.  
   public static String reverse6(String s) {
2.  
    
3.  
   char[] str = s.toCharArray();
4.  
    
5.  
   int begin = 0;
6.  
   int end = s.length() - 1;
7.  
   while (begin < end) {
8.  
   str[begin] = ( char) (str[begin] ^ str[end]);
9.  
   str[end] = ( char) (str[begin] ^ str[end]);
10.  
    str[begin] = ( char) (str[end] ^ str[begin]);
11.  
    begin++;
12.  
    end--;
13.  
    }
14.  
    return new String(str);
15.  
    }

方法七：（利用栈结构）

1.  
   public static String reverse7(String s) {
2.  
   char[] str = s.toCharArray();
3.  
   Stack<Character> stack = new Stack<Character>();
4.  
   for ( int i = 0; i < str.length; i++)
5.  
   stack.push(str[i]);
6.  
    
7.  
   String reversed = "";
8.  
   for ( int i = 0; i < str.length; i++)
9.  
   reversed += stack.pop();
10.  
     
11.  
    return reversed;
12.  
    }

2、冒泡排序，冒泡排序的优化方案。

原理：比较两个相邻的元素，将值大的元素交换至右端。

思路：设数组的长度为N： 

1. 比较前后相邻的二个数据，如果前面数据大于后面的数据，就将这二个数据交换。
2. 这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。
3. N=N-1，如果N不为0就重复前面二步，否则排序完成。

1.  
   /**
2.  
   * 冒泡排序的第一种实现, 没有任何优化
3.  
   * @param a
4.  
   * @param n
5.  
   */
6.  
   public static void bubbleSort1(int[] a, int n){
7.  
   int i, j;
8.  
    
9.  
   for(i= 0; i<n; i++){ //表示n次排序过程。
10.  
    for(j= 1; j<n-i; j++){
11.  
    if(a[j- 1] > a[j]){ //前面的数字大于后面的数字就交换
12.  
    //交换a[j-1]和a[j]
13.  
    int temp;
14.  
    temp = a[j- 1];
15.  
    a[j- 1] = a[j];
16.  
    a[j]=temp;
17.  
    }
18.  
    }
19.  
    }
20.  
    }

测试代码：

1.  
   public static void main(String[] args) {
2.  
   int[] arr = { 1, 1, 2, 0, 9, 3, 12, 7, 8, 3, 4, 65, 22};
3.  
    
4.  
   BubbleSort.bubbleSort1(arr, arr.length);
5.  
    
6.  
   for( int i:arr){
7.  
   System.out.print(i+ ",");
8.  
   }
9.  
   }

运行结果：

0,1,1,2,3,3,4,7,8,9,12,22,65,

优化一：如果对于一个本身有序的序列，或则序列后面一大部分都是有序的序列，上面的算法就会浪费很多的时间开销，这里设置一个标志flag，如果这一趟发生了交换，则为true，否则为false。明显如果有一趟没有发生交换，说明排序已经完成。

1.  
   /**
2.  
   * 设置一个标志，如果这一趟发生了交换，则为true，否则为false。明显如果有一趟没有发生交换，说明排序已经完成。
3.  
   * @param a
4.  
   * @param n
5.  
   */
6.  
   public static void bubbleSort2(int [] a, int n){
7.  
   int j, k = n;
8.  
   boolean flag = true; //发生了交换就为true, 没发生就为false，第一次判断时必须标志位true。
9.  
   while (flag){
10.  
    flag= false; //每次开始排序前，都设置flag为未排序过
11.  
    for(j= 1; j<k; j++){
12.  
    if(a[j- 1] > a[j]){ //前面的数字大于后面的数字就交换
13.  
    //交换a[j-1]和a[j]
14.  
    int temp;
15.  
    temp = a[j- 1];
16.  
    a[j- 1] = a[j];
17.  
    a[j]=temp;
18.  
     
19.  
    //表示交换过数据;
20.  
    flag = true;
21.  
    }
22.  
    }
23.  
    k--; //减小一次排序的尾边界
24.  
    }
25.  
    }

运行测试main函数结果：

0,1,1,2,3,3,4,7,8,9,12,22,65,

优化二：比如，现在有一个包含1000个数的数组，仅前面100个无序，后面900个都已排好序且都大于前面100个数字，那么在第一趟遍历后，最后发生交换的位置必定小于100，且这个位置之后的数据必定已经有序了，也就是这个位置以后的数据不需要再排序了，于是记录下这位置，第二次只要从数组头部遍历到这个位置就可以了。如果是对于上面的冒泡排序算法2来说，虽然也只排序100次，但是前面的100次排序每次都要对后面的900个数据进行比较，而对于现在的排序算法3，只需要有一次比较后面的900个数据，之后就会设置尾边界，保证后面的900个数据不再被排序。

1.  
   public static void bubbleSort3(int [] a, int n){
2.  
   int j , k;
3.  
   int flag = n ; //flag来记录最后交换的位置，也就是排序的尾边界
4.  
    
5.  
   while (flag > 0){ //排序未结束标志
6.  
   k = flag; //k 来记录遍历的尾边界
7.  
   flag = 0;
8.  
    
9.  
   for(j= 1; j<k; j++){
10.  
    if(a[j- 1] > a[j]){ //前面的数字大于后面的数字就交换
11.  
    //交换a[j-1]和a[j]
12.  
    int temp;
13.  
    temp = a[j- 1];
14.  
    a[j- 1] = a[j];
15.  
    a[j]=temp;
16.  
    //表示交换过数据;
17.  
    flag = j; //记录最新的尾边界.
18.  
    }
19.  
    }
20.  
    }
21.  
    }

运行测试例子结果：

0,1,1,2,3,3,4,7,8,9,12,22,65,

时间复杂度：

      若记录序列的初始状态为"正序"，则冒泡排序过程只需进行一趟排序，在排序过程中只需进行n-1次比较，且不移动记录；反之，若记录序列的初始状态为"逆序"，则需进行n(n-1）/2次比较和记录移动。因此冒泡排序总的时间复杂度为O(n*n)。

3.快速排序。 快排的最优时间复杂度，最差复杂度。

        快排的基本思想： 通过选择的参考值将待排序记录分割成独立的两部分，一部分全小于选取的参考值，另一部分全大于选取的参考值。对分割之后的部分再进行同样的操作直到无法再进行该操作位置(可以使用递归)。

选择数组的第一个元素为参考值。

1.  
   import java.util.Arrays;
2.  
    
3.  
   public class QuickSort {
4.  
    
5.  
   public static void main(String[] args) {
6.  
   int[] num = { 1, 3, 4, 8, 5, 10, 22, 15, 16 };
7.  
   QuickSort.quickSort(num, 0, num.length - 1);
8.  
   System.out.println(Arrays.toString(num));
9.  
   }
10.  
     
11.  
    public static void quickSort(int[] a, int start, int end) {
12.  
    // 该值定义了从哪个位置开始分割数组
13.  
    int ref;
14.  
    if (start < end) {
15.  
    // 调用partition方法对数组进行排序
16.  
    ref = partition(a, start, end);
17.  
    // 对分割之后的两个数组继续进行排序
18.  
    quickSort(a, start, ref - 1);
19.  
    quickSort(a, ref + 1, end);
20.  
    }
21.  
    }
22.  
     
23.  
    /**
24.  
    * 选定参考值对给定数组进行一趟快速排序
25.  
    *
26.  
    * @param a 数组
27.  
    * @param start （切分）每个数组的第一个的元素的位置
28.  
    * @param end （切分）每个数组的最后一个的元素位置
29.  
    * @return 下一次要切割数组的位置
30.  
    */
31.  
     
32.  
    public static int partition(int[] a, int start, int end) {
33.  
    // 取数组的第一个值作为参考值（关键数据）
34.  
    int refvalue = a[start];
35.  
    // 从数组的右边开始往左遍历，直到找到小于参考值的元素
36.  
    while (start < end) {
37.  
    while (end > start && a[end] >= refvalue) {
38.  
    end--;
39.  
    }
40.  
    // 将元素直接赋予给左边第一个元素，即pivotkey所在的位置
41.  
    a[start] = a[end];
42.  
    // 从序列的左边边开始往右遍历，直到找到大于基准值的元素
43.  
    while (end > start && a[start] <= refvalue) {
44.  
    start++;
45.  
    }
46.  
    a[end] = a[start];
47.  
    return end;
48.  
    }
49.  
    // 最后的start是基准值所在的位置
50.  
    a[start] = refvalue;
51.  
    return start;
52.  
    }
53.  
    }

时间复杂度分析：

• 在最优的情况下，Partition每次都划分得很均匀，快速排序算法的时间复杂度为O(nlogn)。
• 最糟糕情况下的快排，当待排序的序列为正序或逆序排列时，时间复杂度为O(n^2)。

空间复杂度分析：

• 最好情况，递归树的深度为log2n，其空间复杂度也就为O(logn)
• 最坏情况，需要进行n‐1递归调用，其空间复杂度为O(n)，平均情况，空间复杂度也为O(logn)。

一种简单优化的方式：

三向切分快速排序 ：核心思想就是将待排序的数据分为三部分,左边都小于比较值,右边都大于比较值,中间的数和比较值相等.三向切分快速排序的特性就是遇到和比较值相同时,不进行数据交换, 这样对于有大量重复数据的排序时,三向切分快速排序算法就会优于普通快速排序算法,但由于它整体判断代码比普通快速排序多一点,所以对于常见的大量非重复数据,它并不能比普通快速排序多大多的优势 。

4、归并排序

两路归并排序算法思路

分而治之(divide - conquer);每个递归过程涉及三个步骤
第一, 分解: 把待排序的 n 个元素的序列分解成两个子序列, 每个子序列包括 n/2 个元素.
第二, 治理: 对每个子序列分别调用归并排序MergeSort, 进行递归操作
第三, 合并: 合并两个排好序的子序列,生成排序结果.

算法实现

此算法的实现不像图示那样简单，现分三步来讨论。首先从宏观上分析，首先让子表表长 L=1 进行处理；不断地使 L=2*L ，进行子表处理，直到 L>=n 为止，把这一过程写成一个主体框架函数 mergesort 。然后对于某确定的子表表长 L ，将 n 个记录分成若干组子表，两两归并，这里显然要循环若干次，把这一步写成一个函数 mergepass ，可由 mergesort 调用。最后再看每一组（一对）子表的归并，其原理是相同的，只是子表表长不同，换句话说，是子表的首记录号与尾记录号不同，把这个归并操作作为核心算法写成函数 merge ，由 mergepass 来调用。假设我们有一个没有排好序的序列，那么首先我们使用分割的办法将这个序列分割成一个一个已经排好序的子序列，然后再利用归并的方法将一个个的子序列合并成排序好的序列。分割和归并的过程可以看下面的图例。

代码实现：

1.  
   public static int[] sort( int[] a, int low, int high){
2.  
   int mid = (low+high)/ 2;
3.  
   if(low<high){
4.  
   sort(a,low,mid);
5.  
   sort(a,mid+ 1,high);
6.  
   //左右归并
7.  
   merge(a,low,mid,high);
8.  
   }
9.  
   return a;
10.  
    }
11.  
     
12.  
    public static void merge(int[] a, int low, int mid, int high) {
13.  
    int[] temp = new int[high-low+ 1];
14.  
    int i= low;
15.  
    int j = mid+ 1;
16.  
    int k= 0;
17.  
    // 把较小的数先移到新数组中
18.  
    while(i<=mid && j<=high){
19.  
    if(a[i]<a[j]){
20.  
    temp[k++] = a[i++];
21.  
    } else{
22.  
    temp[k++] = a[j++];
23.  
    }
24.  
    }
25.  
    // 把左边剩余的数移入数组
26.  
    while(i<=mid){
27.  
    temp[k++] = a[i++];
28.  
    }
29.  
    // 把右边边剩余的数移入数组
30.  
    while(j<=high){
31.  
    temp[k++] = a[j++];
32.  
    }
33.  
    // 把新数组中的数覆盖nums数组
34.  
    for( int x= 0;x<temp.length;x++){
35.  
    a[x+low] = temp[x];
36.  
    }
37.  
    }

算法分析：

（1）稳定性
     　归并排序是一种稳定的排序。
（2）存储结构要求
    　可用顺序存储结构。也易于在链表上实现。
（3）时间复杂度
    　对长度为n的文件，需进行趟二路归并，每趟归并的时间为O(n)，故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlgn)。
（4）空间复杂度
   　 需要一个辅助向量来暂存两有序子文件归并的结果，故其辅助空间复杂度为O(n)，显然它不是就地排序。
  注意：
    　若用单链表做存储结构，很容易给出就地的归并排序

5、单向链表，查找中间的那个元素。

设置两个指针，一个快指针，每次走两步，一个慢指针，每次走一步。

1.  
   public class searchMid {
2.  
   public Node method(Node head) {
3.  
   Node p=head;
4.  
   Node q=head;
5.  
   while(q!= null&&q.next!= null&&q.next.next!= null) {
6.  
   p=p.next;
7.  
   q=q.next.next;
8.  
   }
9.  
   return p;
10.  
    }
11.  
    }

6、⼆分查找的时间复杂度，优势。

二分查找又称折半查找，它是一种效率较高的查找方法。

折半查找的算法思想是将数列按有序化(递增或递减)排列，查找过程中采用跳跃式方式查找，即先以有序数列的中点位置为比较对象，如果要找的元素值小 于该中点元素，则将待查序列缩小为左半部分，否则为右半部分。通过一次比较，将查找区间缩小一半。 折半查找是一种高效的查找方法。它可以明显减少比较次数，提高查找效率。但是，折半查找的先决条件是查找表中的数据元素必须有序。

折半查找法的优点是比较次数少，查找速度快，平均性能好;其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

二分算法步骤描述

① 首先确定整个查找区间的中间位置 mid = （ left + right ）/ 2

② 用待查关键字值与中间位置的关键字值进行比较；

若相等，则查找成功

若大于，则在后（右）半个区域继续进行折半查找

若小于，则在前（左）半个区域继续进行折半查找

③ 对确定的缩小区域再按折半公式，重复上述步骤。

最后，得到结果：要么查找成功， 要么查找失败。折半查找的存储结构采用一维数组存放。 折半查找算法举例

对给定数列（有序）{ 3,5,11,17,21,23,28,30,32,50,64,78,81,95,101}，按折半查找算法，查找关键字值为81的数据元素。

二分查找算法讨论：

优点：ASL≤log2n，即每经过一次比较,查找范围就缩小一半。经log2n 次计较就可以完成查找过程。

缺点：因要求有序，所以要求查找数列必须有序，而对所有数据元素按大小排序是非常费时的操作。另外，顺序存储结构的插入、删除操作不便利。

考虑：能否通过一次比较抛弃更多的部分（即经过一次比较，使查找范围缩得更小），以达到提高效率的目的。……？

可以考虑把两种方法（顺序查找和折半查找）结合起来，即取顺序查找简单和折半查找高效之所长，来达到提高效率的目的？实际上这就是分块查找的算法思想。

1.  
   public class BinarySearch {
2.  
   /**
3.  
   * 二分查找算法
4.  
   *
5.  
   * @param srcArray 有序数组
6.  
   * @param key 查找元素
7.  
   * @return key的数组下标，没找到返回-1
8.  
   */
9.  
   public static void main(String[] args) {
10.  
    int srcArray[] = { 3, 5, 11, 17, 21, 23, 28, 30, 32, 50, 64, 78, 81, 95, 101};
11.  
    System.out.println(binSearch(srcArray, 0, srcArray.length - 1, 81));
12.  
    }
13.  
     
14.  
    // 二分查找递归实现
15.  
    public static int binSearch(int srcArray[], int start, int end, int key) {
16.  
    int mid = (end - start) / 2 + start;
17.  
    if (srcArray[mid] == key) {
18.  
    return mid;
19.  
    }
20.  
    if (start >= end) {
21.  
    return - 1;
22.  
    } else if (key > srcArray[mid]) {
23.  
    return binSearch(srcArray, mid + 1, end, key);
24.  
    } else if (key < srcArray[mid]) {
25.  
    return binSearch(srcArray, start, mid - 1, key);
26.  
    }
27.  
    return - 1;
28.  
    }
29.  
     
30.  
    // 二分查找普通循环实现
31.  
    public static int binSearch(int srcArray[], int key) {
32.  
    int mid = srcArray.length / 2;
33.  
    if (key == srcArray[mid]) {
34.  
    return mid;
35.  
    }
36.  
     
37.  
    int start = 0;
38.  
    int end = srcArray.length - 1;
39.  
    while (start <= end) {
40.  
    mid = (end - start) / 2 + start;
41.  
    if (key < srcArray[mid]) {
42.  
    end = mid - 1;
43.  
    } else if (key > srcArray[mid]) {
44.  
    start = mid + 1;
45.  
    } else {
46.  
    return mid;
47.  
    }
48.  
    }
49.  
    return - 1;
50.  
    }
51.  
    }

7、一个单向链表，删除倒数第N个数据。

1.  
   public ListNode removeNthFromEnd(ListNode head, int n)
2.  
   {
3.  
   //求出链表长度
4.  
   int len = 0; //链表长度
5.  
   ListNode p,q;
6.  
   p = head;
7.  
   while(p!= null)
8.  
   {
9.  
   len++;
10.  
    p = p.next;
11.  
    }
12.  
    if(n>len)
13.  
    return null;
14.  
     
15.  
    p = head;
16.  
    q = head;
17.  
    for( int i = 0;i<len-n;i++)
18.  
    {
19.  
    p = q;
20.  
    q = q.next;
21.  
    }
22.  
    //当删除的是第一个节点的时候
23.  
    if(p==q)
24.  
    head = p.next;
25.  
    if(q!= null)
26.  
    {
27.  
    p.next = q.next;
28.  
    q.next = null;
29.  
    }
30.  
     
31.  
    return head;
32.  
    }

8、遍历二叉树

1.  
   public class BinaryTree {
2.  
    
3.  
   int data; //根节点数据
4.  
   BinaryTree left; //左子树
5.  
   BinaryTree right; //右子树
6.  
    
7.  
   public BinaryTree(int data) //实例化二叉树类
8.  
   {
9.  
   this.data = data;
10.  
    left = null;
11.  
    right = null;
12.  
    }
13.  
     
14.  
    public void insert(BinaryTree root,int data){ //向二叉树中插入子节点
15.  
    if(data>root.data) //二叉树的左节点都比根节点小
16.  
    {
17.  
    if(root.right== null){
18.  
    root.right = new BinaryTree(data);
19.  
    } else{
20.  
    this.insert(root.right, data);
21.  
    }
22.  
    } else{ //二叉树的右节点都比根节点大
23.  
    if(root.left== null){
24.  
    root.left = new BinaryTree(data);
25.  
    } else{
26.  
    this.insert(root.left, data);
27.  
    }
28.  
    }
29.  
    }
30.  
    }

当建立好二叉树类后可以创建二叉树实例，并实现二叉树的先根遍历，中根遍历，后根遍历，代码如下：

1.  
   public class BinaryTreePreorder {
2.  
    
3.  
     public static void preOrder(BinaryTree root){   //先根遍历
4.  
     if(root!= null){
5.  
      System.out.print(root.data+ "-");
6.  
      preOrder(root.left);
7.  
      preOrder(root.right);
8.  
     }
9.  
    }
10.  
     
11.  
      public static void inOrder(BinaryTree root){     //中根遍历
12.  
     
13.  
      if(root!= null){
14.  
       inOrder(root.left);
15.  
       System.out.print(root.data+ "--");
16.  
       inOrder(root.right);
17.  
      }
18.  
     }
19.  
     
20.  
      public static void postOrder(BinaryTree root){     //后根遍历
21.  
     
22.  
      if(root!= null){
23.  
       postOrder(root.left);
24.  
       postOrder(root.right);
25.  
       System.out.print(root.data+ "---");
26.  
      }
27.  
     }
28.  
     
29.  
      public static void main(String[] str){
30.  
      int[] array = { 12, 76, 35, 22, 16, 48, 90, 46, 9, 40};
31.  
      BinaryTree root = new BinaryTree(array[ 0]);   //创建二叉树
32.  
      for( int i= 1;i<array.length;i++){
33.  
       root.insert(root, array[i]);       //向二叉树中插入数据
34.  
      }
35.  
      System.out.println( "先根遍历：");
36.  
      preOrder(root);
37.  
      System.out.println();
38.  
      System.out.println( "中根遍历：");
39.  
      inOrder(root);
40.  
      System.out.println();
41.  
      System.out.println( "后根遍历：");
42.  
      postOrder(root);
43.  
    }

  创建好的二叉树图形如下:

当运行上面的程序后结果如下：

先根遍历：
12-9-76-35-22-16-48-46-40-90-
中根遍历：
9--12--16--22--35--40--46--48--76--90--
后根遍历：
9---16---22---40---46---48---35---90---76---12---

9、在10亿个数字里找最小的10个。

10、有1亿个数字，其中有2个是重复的，快速找到它，时间和空间要最优。

11、2亿个随机生成的无序整数,找出中间大小的值。

12、给⼀个不知道长度的（可能很⼤）输⼊字符串，设计⼀种⽅案，将重复的字符排重。

13、有3n+1个数字，其中3n个中是重复的，只有1个是不重复的，怎么找出来。

14、⼀个已经构建好的TreeSet，怎么完成倒排序。

15、什么是B+树，B-树，列出实际的使用场景。

16、200个有序的数组，每个数组⾥⾯100个元素，找出top20的元素。

除此之外还有百G面试资料分享：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合。

资料都整理在百度网盘里面，粉丝专有福利，还有各种电子书随便下载；

1，一线互联网初级，中级，高级Java面试题

 

2，Java电子书锦集

 

 

 

3、面试教程+230个简历模板

 

 

 

 

资料免费领取方式，添加\/杏：wwee19947；备注：开源，无备注不分享

云析学院
 

 

来源：oschina

链接：https://my.oschina.net/u/3728792/blog/4463657