text: module.exports = {
      docs: [
          {
              type: "category",
              label: "Introduction",
              items: [
                  "introduction/About-NeoAlgo",
                  "introduction/development-setup",
                  "introduction/contributor-handbook",
              ],
          },
          {
              type: "category",
              label: "Code Playgrounds",
              items: [
                  "code-playgrounds/python-playground",
                  "code-playgrounds/java-playground",
              ],
          },
          {
              type: "category",
              label: "Searching Algorithms",
              items: [
                  "searching-algorithms/searching-algorithms",
                  "searching-algorithms/linear-search",
                  "searching-algorithms/interpolation-search",
                  "searching-algorithms/two-pointer",
                  "searching-algorithms/jump-search",
                  "searching-algorithms/exponential-search",
  
              ],
          },
          {
              type: "category",
              label: "Sorting Algorithms",
              items: [
                  "sorting-algorithms/sorting-algorithms",
                  "sorting-algorithms/bubble-sort",
                  "sorting-algorithms/selection-sort",
                  "sorting-algorithms/heap-sort",
                  'sorting-algorithms/insertion-sort',
                  "sorting-algorithms/merge-sort",
                  "sorting-algorithms/quick-sort",
                  "sorting-algorithms/sleep-sort",
                  "sorting-algorithms/cocktail-sort",
                  "sorting-algorithms/bead-sort",
                  "sorting-algorithms/radix-sort",
                  "sorting-algorithms/counting-sort",
                  "sorting-algorithms/cocktail-sort",
                  "sorting-algorithms/wiggle-sort",
                  "sorting-algorithms/stooge-sort",
                  "sorting-algorithms/shell-sort",
              ],
          },
          {
              type: "category",
              label: "Data Structures",
              items: [
                  "data-structures/data-structures",
                  "data-structures/binary-tree",
                  "data-structures/Singly-Linked-list",
                  "data-structures/binary-search-tree",
                  "data-structures/preorder_traversal",
                  "data-structures/stack-data-structure",
                  "data-structures/queue",
                  "data-structures/Circular-Linked-list",
                  "data-structures/preorder_traversal",
  		        "data-structures/palindromic-linked-list",
                  "data-structures/circular-queue",
                  "data-structures/depth-of-tree",
                  "data-structures/size-of-binary-tree",
                  "data-structures/inorder_traversal",
                  "data-structures/tower-of-hanoi",
                  "data-structures/maximum-in-bst",
                  "data-structures/postorder_traversal",
                  "data-structures/double-ended-queue",
                  "data-structures/minimum-in-bst",
                   "data-structures/ceil_in_bst",
                    "data-structures/height_BST"
  
              ],
          },
          {
              type: "category",
              label: "Dynamic Programming",
              items: [
                  "dynamic-programming/dynamic-programming",
                  "dynamic-programming/egg-dropping-problem",
                  "dynamic-programming/golomb-sequence",
                  "dynamic-programming/kadane-algorithm",
                  "dynamic-programming/catalan-number",
                  "dynamic-programming/equal-sum-partition",
  		            "dynamic-programming/catalan-number",
  		            "dynamic-programming/golomb-sequence",
  		    "dynamic-programming/coin-change-problem",
              ],
          },
          {
              type: "category",
              label: "Computational Geometry",
              items: [
                  "computational-geometry/computational-geometry",
                  "computational-geometry/jarvis-algorithm",
              ],
          },
          {
              type: "category",
              label: "Mathematics",
              items: [
                  "mathematics/mathematics",
                  "mathematics/ackermann-function",
                  "mathematics/armstrong-number",
                  "mathematics/factorial-of-number",
                  "mathematics/magic-number",
                  "mathematics/happy-number",
                  "mathematics/prime-number",
                  "mathematics/krishnamurthy-number",
                  "mathematics/neon-number",
  		        "mathematics/number-power-of-2",
                  "mathematics/anagram-number",
                  "mathematics/sum-of-digits",
                  "mathematics/palindrome-number",
                  "mathematics/extended-euclidean-Algorithm",
                  "mathematics/mystery-number",
  		        "mathematics/perfect-number",
                  "mathematics/sum-of-divisors",
                  "mathematics/count-of-divisors",
                  "mathematics/count-of-digits",
  		        "mathematics/fibonacci-recursion",
  		        "mathematics/catalan-number",
                  "mathematics/reverse-a-number",
                  "mathematics/automorphic-number",
                  "mathematics/double-factorial",
                  "mathematics/gcd-of-two-numbers",
                  "mathematics/power-linear",
                  "mathematics/ugly-numbers",
                  "mathematics/noble-integer",
                  "mathematics/lucky-numbers",
                  "mathematics/hamming-distance",
                  "mathematics/lcm-of-two-numbers",
                  "mathematics/binary-exponentiation",
                  "mathematics/pascal-triangle",
                  "mathematics/triangular-numbers",
                  "mathematics/lucas-theorem",
                  "mathematics/euler-totient-function",
                  "mathematics/matrix-addition",
                  "mathematics/matrix-transpose",
                  "mathematics/matrix-multiplication",
                   "mathematics/hexagonal-number",
                  "mathematics/spiral-traversal-of-matrix",
                  "mathematics/tetrahedral-number",
                  "mathematics/rotate-matrix-by-90-degree",
                  "mathematics/product-of-count-of-bits-of-each-elements",
                  "mathematics/anti-diagonal-traversal-of-matrix",
                  "mathematics/product-of-count-of-bits-of-each-elements",
                  "mathematics/next-prime-number",
                  "mathematics/boolean-matrix",  
                  "mathematics/count-bits",
                  "mathematics/searching-in-matrix",
                  "mathematics/row-with-max-one",
                  "mathematics/snake-traversal-of-matrix",
                  "mathematics/occurrence-of-no.-in-array",
                  "mathematics/Kth-smallest"
              ],
          },
          {
              type: "category",
              label: "Bit Manipulation",
              items: [
                  "bit-manipulation/bit-manipulation",
                  "bit-manipulation/brian-kernighan-algorithm",
                  "bit-manipulation/reverse-bits",
              ],
          },
          {
              type: "category",
              label: "Graph Algorithms",
              items: [
                  "graph-algorithms/graph-algorithms",
                  "graph-algorithms/breadth-first-search",
                  "graph-algorithms/kruskals-algorithm",
  
  
  
                  "graph-algorithms/prims-algorithm", 
  
  		"graph-algorithms/topological-sorting",
  
  
  	             	"graph-algorithms/topological-sorting", 
  
  
                  "graph-algorithms/topological-sorting",
  
              ],
          },
          {
              type: "category",
              label: "Competitive Programming",
              items: [
                  "competitive-programming/competitive-programming",
                  "competitive-programming/anagram-numbers",
  		"competitive-programming/prefix-sum-algorithm",
                  "competitive-programming/max-number-from-array",
                  "competitive-programming/factorial-of-large-number",
                  "competitive-programming/max-number-from-array",
                  "competitive-programming/reverse-of-string",
                  "competitive-programming/diameter-of-BT",
  		"competitive-programming/bigmod-algorithm",
                  "competitive-programming/generate-subsequences",
                  "competitive-programming/generate-valid-parantheses",
                  "competitive-programming/left-view-of-BT",
                  "competitive-programming/top-view-of-BT",
                  "competitive-programming/right-view-of-BT",
                  "competitive-programming/identical-BT",
                  "competitive-programming/phone-keypad",
                  "competitive-programming/wave-sort",
              ],
          },
          {
              type: "category",
              label: "Machine Learning",
              items: [
                  "machine-learning/machine-learning",
                  "machine-learning/linear-regression",
              ],
          },
          {
              type: "category",
              label: "Cryptography",
              items: [
                  "cryptography/cryptography",
                  "cryptography/caesar-cipher",
                  "cryptography/keyword-cipher",
                  "cryptography/playfair-cipher",
                  "cryptography/railfence-cipher",
                  "cryptography/vernam-cipher",
                  "cryptography/homophonic-cipher",
                  "cryptography/hill-cipher",
                  "cryptography/columnar-transposition-cipher",
                  "cryptography/burrows-wheeler-transform",
                  "cryptography/affine-cipher",
                  "cryptography/vigenere-cipher",
              ],
          },
          {
              type: "category",
              label: "Backtracking",
              items: ["backtracking/backtracking", "backtracking/n-queens"],
          },
          {
              type: "category",
              label: "Operating Systems",
              items: [
                  "operating-systems/operating-systems",
                  "operating-systems/banker-algorithm",
              ],
          },
          {
              type: "category",
              label: "Miscellaneous",
              items: [
                  "miscellaneous/miscellaneous",
                  "miscellaneous/sudoku-solver",
              ],
          },
          {
              type: "category",
              label: "Docusaurus Tutorial",
              items: [
                  "getting-started",
                  "create-a-page",
                  "create-a-document",
                  "create-a-blog-post",
                  "markdown-features",
                  "thank-you",
              ],
          },
      ],
  };
  