学习资源推荐：

1.程序员面试、算法研究、编程艺术、红黑树、机器学习5大系列集锦

程序员面试、算法研究、编程艺术、红黑树、机器学习5大系列集锦_v_JULY_v的博客-CSDN博客

2.推荐！数据结构算法常见面试考题

数据结构算法常见面试考题_祚儿疯的博客-CSDN博客_数据结构面试题

3.数据结构与算法面试知识点汇总(超全)

数据结构与算法面试知识点汇总（超全）_csdn_dzh的博客

数据结构面试必问

1. （六）数据结构面试必问_zl_StepByStep的博客-CSDN博客_数据结构面试

2. 数据结构算法常见面试考题_祚儿疯的博客-CSDN博客_数据结构面试题

https://github.com/luxiangqiang/Data-Structure-Coding

数据结构与算法必会代码实现

复杂度背诵口诀：O(nlogN) 算法 ---- 快希以nlogn 速度 归堆

数组

1、数组实现增、删、改、查  (Java 实现)

2、实现一个支持动态扩容的数组  (Java 实现)

3、实现一个大小固定的有序数组，支持动态增删改操作 ( Java 实现)

4、两个有序数组的合并 ( Java 实现)

链表

1、单链表的插入、删除、查找 ( JavaScript 实现 |  Java 实现)

2、双链表的插入、删除 ( JavaScript 实现)

3、循环链表的插入、查找、删除 ( JavaScript 实现)

4、两个有序链表的合并 ( JavaScript 实现 |  Java 实现)

5、删除倒数第 K 个结点 ( JavaScript 实现 |  Java 实现)

6、反转链表  (JavaScript 实现 |  Java 实现)

7、链表环的检测 ( JavaScript 实现 |  Java 实现)

8、求链表的中间结点 ( JavaScript 实现 |  Java 实现)

栈

1、实现一个基于数组的顺序栈( Java 实现)

2、实现一个基于链表的链式栈 ( Java 实现)

队列

1、实现一个基于数组的顺序队列 ( Java 实现)

2、实现一个循环队列 ( Java 实现)

树

1、实现二叉树的增、删、查、(前|中|后)遍历 ( JavaScript 实现 |  Java 实现)

堆

1、堆的插入与删除 ( Java 实现)

2、堆排序 ( JavaScript 实现 |  Java 实现)

Trie(字典树)

1、实现一个字典树 ( JavaScript 实现 |  Java 实现)

排序

1、冒泡排序 ( JavaScript 实现 |  Java 实现)

2、插入排序 ( JavaScript 实现 |  Java 实现)

3、选择排序 ( JavaScript 实现 |  Java 实现)

4、希尔排序 ( JavaScript 实现)

5、归并排序 ( JavaScript 实现 |  Java 实现)

6、快速排序 ( JavaScript 实现 |  Java 实现)

7、求第 K 大元素 (JavaScript 实现).

查找

1、最简单的二分查找 ( JavaScript 实现 |  Java 实现)

2、二分查找的四个扩展 ( JavaScript 实现 |  Java 实现)

遍历

1、深度优先遍历 (JavaScript 实现|  Java 实现)

2、广度优先遍历 (JavaScript 实现 |  Java 实现)

输入：一个算法必须有零个或以上输入量。

输出：一个算法应有一个或以上输出量，输出量是算法计算的结果。

经典排序算法的空间复杂度

O(1)：插入排序、选择排序、冒泡排序、堆排序、希尔排序；

O(N)：归并排序；

O(M): 计数排序、基数排序(和选择桶的数量有关)。

找到一个二叉树的高度

找到一个二叉搜索树中第 k 个最大值

找到距离根部“k”个距离的节点

找到一个二叉树中给定节点的祖先(ancestors)

斐波那契数列

public class Solution {
    public int Fibonacci(int n) {
            if (n==0)
                 return 0; 
            else if(n==1)
                 return 1;
            int sum=0; 
            int a=0;
            int b=1;
            for(int i=2;i<=n;i++){
                sum=a+b; a=b; b=sum;
            }
            return sum; }
            }

第二章排序

2.1 O(n2) 算法

给定一数组，其大小为8个元素，数组内的数据无序。 6 3 5 7 0 4 1 2

冒泡排序：

两两比较，将两者较少的升上去，第一次比较空间为0-(N-1)直到最后一轮比较空间为0-1。

public class bubbleSort {
public static void main(String[] args) {
int[] test = { 6, 3, 5, 7, 0, 4, 1, 2 };
for (int i = 0; i < test.length - 1; i++) {
    for (int j = 0; j < test.length - i - 1; j++) {
              if (test[j] > test[j + 1]) {
                     int temp = test[j]; test[j] = test[j + 1]; test[j + 1] = temp; } } }
for (int k = 0; k < test.length; k++) {
       System.out.println(test[k]); } } }

选择排序：

在第一趟遍历N个数据，找出其中最小的数值与第一个元素交换，第二趟遍历剩下的N-1个数据，找出其中最小的数值与第二个元素交换……第N-1趟遍历剩下的2个数据，找出其中最小的数值与第N-1个元素交换，至此选择排序完成。

public class selectSort {
public static void main(String[] args) {
int[] test = { 6, 3, 5, 7, 0, 4, 1, 2 };
for (int i = 0; i < test.length; i++) {
        int min = i;
        for (int j = i + 1; j < test.length; j++) {
               if (test[min] > test[j]) { min = j; } }
                  if (min != i) { int temp = test[i]; test[i] = test[min]; test[min] = temp; } }
for (int k = 0; k < test.length; k++) {
    System.out.println(test[k]); } } }

插入排序：对于未排序数据，在已排序序列中从后向前扫描，找到相应的位置并插入。

public class insertSort {
public static void main(String[] args) {
int[] test = { 6, 3, 5, 7, 0, 4, 1, 2 };
for (int i = 0; i < test.length; i++) {
       for (int j = i; j > 0; j--) {
        if (test[j] < test[j - 1]) {
                int temp = test[j]; test[j] = test[j - 1]; test[j - 1] = temp; }
       else { break; } } }
for (int k = 0; k < test.length; k++) {
  System.out.println(test[k]); } } }

2.2 O(nlogN) 算法 ---- 快希以nlogn 速度 归堆

归并排序:

将两个(或两个以上)有序表合并成一个新的有序表，即把待排序序列分为若干个子序列(分治法)，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

快速排序：

任取一个分界值，大于划分值放在右边，小于划分值放在左边，然后分别递归处理划分值的左右两边。实现方法：将划分值放在数组最后的位置，然后初始化一个长度为0的小于等于空间放在最左边，接着从左到右遍历所有元素，如果当前元素大于划分值，继续遍历下一个元素，如果当前元素小于等于划分值，将当前数和小于等于空间的下一个数交换位置，小于等于空间向右扩一个位置，遍历完所有元素，直到最后一个数，将划分值与小于等于空间下一个元素交换。(一次完整划分过程)

堆排序：

堆是一种重要的数据结构，为一棵完全二叉树,底层如果用数组存储数据的话，假设某个元素为序号为i(Java数组从0开始,i为0到n-1),如果它有左子树，那么左子树的位置是2i+1，如果有右子树，右子树的位置是2i+2，如果有父节点，父节点的位置是(n-1)/2取整。分为最大堆和最小堆，最大堆的任意子树根节点不小于任意子结点，最小堆的根节点不大于任意子结点。所谓堆排序就是利用堆这种数据结构来对数组排序，我们使用的是最大堆。

堆排序的大概步骤如下:(1)构建最大堆；(2)选择顶，并与第0位置元素交换；(3)由于步骤2的的交换可能破环了最大堆的性质，第0不再是最大元素，需要调用maxHeap调整堆(沉降法)，如果需要重复步骤2。

希尔排序：

又称缩小增量排序”，其基本原理是，现将待排序的数组元素分成多个子序列，使得每个子序列的元素个数相对较少，然后对各个子序列分别进行直接插入排序，待整个待排序列“基本有序”后，最后在对所有元素进行一次直接插入排序，一般增量设置由大到小。

2.3 O(N) 算法

思想：不是基于比较，而是来自于桶排序，桶排序的基本思想则是把数则是arr划分为n个大小相同子区间(桶)，每个子区间各自排序，最后合并。

计数排序：

需要占用大量空间，它仅适用于数据比较集中的情况。比如[0~100]，[10000~19999]这样的数据，对每一个输入的元素arr[i]，确定小于 arr[i] 的元素个数，假设有5个数小于 arr[i]，所以 arr[i] 应该放在数组的第6个位置上。

基数排序：

实质为多关键字排序，思路是将待排数据里排序关键字拆分成多个排序关键字；第1个排序关键字，第2个排序关键字，第3个排序关键字等，然后，根据子关键字对待排序数据进行排序，如个位数，十位数，百位数等。

经典排序算法的空间复杂度

O(1)：插入排序、选择排序、冒泡排序、堆排序、希尔排序；

O(N)：归并排序；

O(M): 计数排序、基数排序(和选择桶的数量有关)。

经典排序算法的稳定性

稳定性：假定待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，称这种排序算法是稳定的，否则称为不稳定的。

稳定的排序算法：冒泡排序、插入排序、归并排序、计数排序、基数排序、桶排序

不稳定的排序算法：选择排序、快速排序、希尔排序、堆排序---希快简堆