Whether doing machine learning, deep learning, natural language processing or other fields, the importance of algorithms is self-evident! It is very important to understand the underlying principle of the algorithm and master the mathematical derivation and code implementation of the algorithm to improve your hard core strength! Today I recommend a great open source algorithm note! Chinese version! And I have gained nearly 1k praise on GitHub!

First put the GitHub address of the note:

https://github.com/Dairongpeng/algorithm-note

brief introduction

The main contents of the open source project include: explanation and code implementation of related data structures and algorithms such as array, linked list, tree, graph, recursion, DP, ordered table, etc. The author is "Zuo Shen". Through the notes of algorithm class, sort out a note to restore the online class as much as possible, including the implementation of code, which can be used as a reference book for readers to query.

catalogue

The project contains a total of 24 sections, each of which is equipped with notes and code implementation.

At the same time, the author provides GitHub Page reading page to improve friendly interaction:

https://dairongpeng.github.io/algorithm-note/

For example, let's look at Section 1.

Section 1 introduces time complexity, space complexity, sorting and XOR operation. It mainly includes: time complexity, space complexity, constant term time complexity, algorithm optimal solution, common time complexity, algorithm and data structure context, cognitive logarithm, cognitive dichotomy, cognitive XOR operation.

The author has a concise summary and summary of each knowledge point.

In addition, there are corresponding example codes for sorting algorithms, such as our most common bubble sorting:

package cass01;


import java.util.Arrays;


public class Code02_BubbleSort {


  public static void bubbleSort(int[] arr) {
    if (arr == null || arr.length < 2) {
      return;
    }
    // 0 ~ N-1
    // 0 ~ N-2
    // 0 ~ N-3
    for (int e = arr.length - 1; e > 0; e--) { // 0 ~ e
      for (int i = 0; i < e; i++) {
        if (arr[i] > arr[i + 1]) {
          swap(arr, i, i + 1);
        }
      }
    }
  }


  // Exchange values at i and j positions of arr
  public static void swap(int[] arr, int i, int j) {
    arr[i] = arr[i] ^ arr[j];
    arr[j] = arr[i] ^ arr[j];
    arr[i] = arr[i] ^ arr[j];
  }


  // for test
  public static void comparator(int[] arr) {
    Arrays.sort(arr);
  }


  // for test
  public static int[] generateRandomArray(int maxSize, int maxValue) {
    int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
    for (int i = 0; i < arr.length; i++) {
      arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
    }
    return arr;
  }


  // for test
  public static int[] copyArray(int[] arr) {
    if (arr == null) {
      return null;
    }
    int[] res = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
      res[i] = arr[i];
    }
    return res;
  }


  // for test
  public static boolean isEqual(int[] arr1, int[] arr2) {
    if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
      return false;
    }
    if (arr1 == null && arr2 == null) {
      return true;
    }
    if (arr1.length != arr2.length) {
      return false;
    }
    for (int i = 0; i < arr1.length; i++) {
      if (arr1[i] != arr2[i]) {
        return false;
      }
    }
    return true;
  }


  // for test
  public static void printArray(int[] arr) {
    if (arr == null) {
      return;
    }
    for (int i = 0; i < arr.length; i++) {
      System.out.print(arr[i] + " ");
    }
    System.out.println();
  }


  // for test
  public static void main(String[] args) {    
    int testTime = 500000;
    int maxSize = 100;
    int maxValue = 100;
    boolean succeed = true;
    for (int i = 0; i < testTime; i++) {
      int[] arr1 = generateRandomArray(maxSize, maxValue);
      int[] arr2 = copyArray(arr1);
      bubbleSort(arr1);
      comparator(arr2);
      if (!isEqual(arr1, arr2)) {
        succeed = false;
        break;
      }
    }
    System.out.println(succeed ? "Nice!" : "Fucking fucked!");


    int[] arr = generateRandomArray(maxSize, maxValue);
    printArray(arr);
    bubbleSort(arr);
    printArray(arr);
  }


}

The overall reading experience is very good!

I hope the Chinese version of algorithm note will be helpful to you! Finally, put the GitHub address of the open source project:

https://github.com/Dairongpeng/algorithm-note