DOCSEARCHbyAlgolia
Submit Docs

Taegyuhan's Technical Blog

website·Indexed 29 days ago

https://taegyuhan.github.io

A technical knowledge base covering coding standards, Spring Boot, JDK internals, operating system concepts, and software engineering practices. Topics include Swagger documentation, Spring Batch parallel processing, exception taxonomy, and data structure analysis.

Tokens
235K
Snippets
774
Records
1.4K
Agent score
74%

What's inside Taegyuhan Blog

  1. Overview of Backtracking Algorithms

    Common backtracking algorithms include:

    • N-Queen: Placing N queens on a chessboard so they do not attack each other.
    • Permutation/Combination Generation: Listing all possible permutations or combinations.
    • Subset Sum: Searching for a subset that sums to a given value.
    • Sudoku Solver: Solving the puzzle through constraint satisfaction.

  2. Overview of Insertion Sort Algorithm

    Insertion Sort is a sorting algorithm that builds a sorted section of a list one element at a time by inserting each new element into its correct position within the already sorted portion. It is conceptually similar to how a person sorts playing cards in their hand. This algorithm is particularly efficient for datasets that are already partially sorted.

  3. Overview of Divide and Conquer Algorithms

    Common divide and conquer algorithms include:

    • Merge Sort: Divides lists and then merges them to sort.
    • Quick Sort: Partitions based on a pivot and then sorts.
    • Binary Search: Searches by dividing the range in half.
    • Closest Pair: Calculates the minimum distance between a set of points on a plane.

  4. Overview of Sorting Algorithms

    Common sorting algorithms include:

    • Bubble Sort: The simplest sorting algorithm.
    • Selection Sort: Sorts by repeatedly selecting the minimum value.
    • Insertion Sort: Inserts elements into a sorted portion of the list.
    • Quick Sort: A divide-and-conquer based sorting algorithm.
    • Merge Sort: Combines two sorted arrays into one.
    • Heap Sort: Sorting based on the heap data structure.

  5. Overview of Graph Algorithms

    Common graph algorithms include:

    • Dijkstra: Finds the shortest path in graphs without negative edges.
    • Bellman-Ford: Finds the shortest path allowing negative edges and detects negative cycles.
    • Floyd-Warshall: Finds the shortest paths between all pairs of vertices.
    • Kruskal: Finds the Minimum Spanning Tree (MST) using Union-Find.
    • Prim: Finds the Minimum Spanning Tree (MST) using a priority queue.
    • Topological Sort: Sorts vertices in a Directed Acyclic Graph (DAG) based on precedence.

  6. Overview of Dynamic Programming (DP) Algorithms

    Common DP problems and algorithms include:

    • 0/1 Knapsack: Selecting items for maximum value within a weight capacity.
    • LIS (Longest Increasing Subsequence): Finding the maximum length of an increasing subsequence.
    • LCS (Longest Common Subsequence): Finding the maximum length of a common subsequence between two strings.
    • Coin Change: Calculating the minimum number of coins or the number of ways to make change.

  7. Overview of Java Backend Learning Path

    The backend learning path focuses on the lifecycle of a single request and response. It is divided into two primary areas: the Language/Runtime layer, which provides the foundation, and the Framework layer, which manages the execution of user code.

  8. Overview of the Hardware & OS Learning Roadmap

    The Hardware & OS roadmap is organized into five non-linear domains. While the domains themselves have no required order, the items within each domain are sequential. The roadmap is based on the Linux 7.3-rc4 source code and performance metrics measured on Ubuntu 24.04 (Kernel 6.6.87.2). Note that source code line numbers and measured values are from different kernel versions and should not be mixed.

  9. Overview of String Algorithms

    Common string algorithms include:

    • KMP: Linear time pattern matching using a prefix-suffix table.
    • Rabin-Karp: String search based on rolling hashes.
    • Z-Algorithm: Calculates the length of pattern matches in linear time.
    • Trie: Used for searching sets of strings and autocomplete.
    • Suffix Array & LCP: Queries substrings using sorted suffixes and Longest Common Prefix lengths.

  10. Overview of MariaDB Query Execution Flow

    A SELECT query in MariaDB follows a five-stage execution path from network reception to result transmission:

    1. Network Reception: do_command → dispatch_command (receives network packets and determines command type).
    2. Parsing: mysql_parse → parse_sql (uses Bison parser to convert SQL string into a structured LEX object).
    3. Execution Planning: JOIN::optimize (performs statistics analysis, cost calculation, and determines the best access path/index).
    4. Data Retrieval: handler layer → Storage Engine (abstracts the physical data read).
    5. Result Transmission: send_data_with_check (checks WHERE conditions and sends data back to the client).

  12. Overview of Greedy Algorithms

    Common greedy algorithms include:

    • Activity Selection: Selects maximum activities based on end times.
    • Interval Scheduling: Selects the maximum number of non-overlapping intervals.
    • Huffman Coding: Generates optimal prefix codes.
    • Greedy Coin: Finds the minimum number of coins for specific currency systems.