diff --git a/app/visualizer/trees/binaryTree/properties/content.jsx b/app/visualizer/trees/binaryTree/properties/content.jsx index 5a9ebdc..649c710 100755 --- a/app/visualizer/trees/binaryTree/properties/content.jsx +++ b/app/visualizer/trees/binaryTree/properties/content.jsx @@ -57,17 +57,14 @@ const LabeledTreeDiagram = () => { ))} {edges.map(([from, to], i) => ( - ))} @@ -76,8 +73,7 @@ const LabeledTreeDiagram = () => { { - return ( -
-
- - { /* go back block here */} -
- -
- - { /* main logic here */} -

- Types of Binary Trees -

-
- -

- - -
-
- -
-
- ); -}; - -export default InfixToPostfixVisualizer; diff --git a/app/visualizer/trees/binaryTree/types/content.jsx b/app/visualizer/trees/binaryTree/types/content.jsx index d531744..aa735b8 100755 --- a/app/visualizer/trees/binaryTree/types/content.jsx +++ b/app/visualizer/trees/binaryTree/types/content.jsx @@ -1,101 +1,90 @@ "use client"; +import { useEffect, useRef } from "react"; +import { gsap } from "gsap"; +import { useTheme } from "@/app/contexts/ThemeContext"; import NewsletterEmbed from "@/app/components/ui/NewsletterEmbed"; - -/* content.jsx */ -import React, { useEffect, useRef, useState } from 'react'; -import { gsap } from 'gsap'; +import DailyDSAEmbed from "@/app/components/ui/DailyDSAEmbed"; import InContentAd from "@/app/components/ads/InContentAd"; -/* ------------- tiny helper to draw a tree ------------- */ -function drawTree( - svg, // element - nodes, // flat list [ {value, x, y}, ... ] - edges, // [ {from, to}, ... ] (indices) - radius = 18 -) { - // clear previous drawings - svg.innerHTML = ''; +const NODE_GRAD_ID = "bt-types-node-grad"; +const SHADOW_FILTER_ID = "bt-types-node-shadow"; + +function drawTree(svg, nodes, edges, radius = 16) { + svg.innerHTML = ""; - // edges (lines) edges.forEach(({ from, to }) => { - const line = document.createElementNS('http://www.w3.org/2000/svg', 'line'); - line.setAttribute('x1', nodes[from].x); - line.setAttribute('y1', nodes[from].y); - line.setAttribute('x2', nodes[to].x); - line.setAttribute('y2', nodes[to].y); - line.setAttribute('stroke', '#3b82f6'); // blue-500 - line.setAttribute('stroke-width', '2'); + const line = document.createElementNS("http://www.w3.org/2000/svg", "line"); + line.setAttribute("x1", nodes[from].x); + line.setAttribute("y1", nodes[from].y); + line.setAttribute("x2", nodes[to].x); + line.setAttribute("y2", nodes[to].y); + line.setAttribute("stroke", "#818cf8"); + line.setAttribute("stroke-width", "2"); + line.setAttribute("stroke-linecap", "round"); svg.appendChild(line); }); - // nodes (circles + text) nodes.forEach(({ value, x, y }, i) => { - const g = document.createElementNS('http://www.w3.org/2000/svg', 'g'); - const circle = document.createElementNS('http://www.w3.org/2000/svg', 'circle'); - const text = document.createElementNS('http://www.w3.org/2000/svg', 'text'); + const g = document.createElementNS("http://www.w3.org/2000/svg", "g"); + const circle = document.createElementNS("http://www.w3.org/2000/svg", "circle"); + const text = document.createElementNS("http://www.w3.org/2000/svg", "text"); - circle.setAttribute('cx', x); - circle.setAttribute('cy', y); - circle.setAttribute('r', radius); - circle.setAttribute('fill', '#3b82f6'); // blue-500 - circle.setAttribute('stroke', '#1e40af'); // blue-800 - circle.setAttribute('stroke-width', '2'); + circle.setAttribute("cx", x); + circle.setAttribute("cy", y); + circle.setAttribute("r", radius); + circle.setAttribute("fill", `url(#${NODE_GRAD_ID})`); + circle.setAttribute("stroke", "#1d4ed8"); + circle.setAttribute("stroke-width", "1.5"); + circle.setAttribute("filter", `url(#${SHADOW_FILTER_ID})`); - text.setAttribute('x', x); - text.setAttribute('y', y + 5); - text.setAttribute('text-anchor', 'middle'); - text.setAttribute('fill', '#fff'); - text.setAttribute('font-size', '14'); + text.setAttribute("x", x); + text.setAttribute("y", y + 5); + text.setAttribute("text-anchor", "middle"); + text.setAttribute("fill", "#fff"); + text.setAttribute("font-size", "13"); + text.setAttribute("font-weight", "700"); text.textContent = value; g.appendChild(circle); g.appendChild(text); svg.appendChild(g); - // animate in - gsap.from(g, { scale: 0, duration: 0.6, ease: 'back.out(1.7)', delay: i * 0.15 }); + gsap.from(g, { scale: 0, opacity: 0, duration: 0.5, ease: "back.out(1.7)", delay: i * 0.12 }); }); } -export default function content() { - - const [theme, setTheme] = useState("light"); - - useEffect(() => { - const updateTheme = () => { - const savedTheme = localStorage.getItem("theme") || "light"; - setTheme(savedTheme); - }; +const SvgDefs = () => ( + + + + + + + + + + + +); - updateTheme(); +const Content = () => { + const { theme } = useTheme(); - window.addEventListener("storage", updateTheme); - window.addEventListener("themeChange", updateTheme); - - return () => { - window.removeEventListener("storage", updateTheme); - window.removeEventListener("themeChange", updateTheme); - }; - }, []); - - /* refs for the three svgs */ - const fullSvg = useRef(null); - const degenSvg = useRef(null); + const fullSvg = useRef(null); + const degenSvg = useRef(null); const completeSvg = useRef(null); - /* ------------- GSAP trees ------------- */ useEffect(() => { - /* Full tree (height 2) */ drawTree( fullSvg.current, [ - { value: 'A', x: 60, y: 30 }, - { value: 'B', x: 30, y: 80 }, - { value: 'C', x: 90, y: 80 }, - { value: 'D', x: 15, y: 130 }, - { value: 'E', x: 45, y: 130 }, - { value: 'F', x: 75, y: 130 }, - { value: 'G', x: 105, y: 130 }, + { value: "A", x: 60, y: 30 }, + { value: "B", x: 30, y: 80 }, + { value: "C", x: 90, y: 80 }, + { value: "D", x: 15, y: 130 }, + { value: "E", x: 45, y: 130 }, + { value: "F", x: 75, y: 130 }, + { value: "G", x: 105, y: 130 }, ], [ { from: 0, to: 1 }, @@ -107,14 +96,13 @@ export default function content() { ] ); - /* Degenerate / right-skewed */ drawTree( degenSvg.current, [ - { value: '1', x: 30, y: 30 }, - { value: '2', x: 30, y: 80 }, - { value: '3', x: 30, y: 130 }, - { value: '4', x: 30, y: 180 }, + { value: "1", x: 30, y: 30 }, + { value: "2", x: 30, y: 80 }, + { value: "3", x: 30, y: 130 }, + { value: "4", x: 30, y: 180 }, ], [ { from: 0, to: 1 }, @@ -123,17 +111,16 @@ export default function content() { ] ); - /* Complete tree (7 nodes) */ drawTree( completeSvg.current, [ - { value: '1', x: 60, y: 30 }, - { value: '2', x: 30, y: 80 }, - { value: '3', x: 90, y: 80 }, - { value: '4', x: 15, y: 130 }, - { value: '5', x: 45, y: 130 }, - { value: '6', x: 75, y: 130 }, - { value: '7', x: 105, y: 130 }, + { value: "1", x: 60, y: 30 }, + { value: "2", x: 30, y: 80 }, + { value: "3", x: 90, y: 80 }, + { value: "4", x: 15, y: 130 }, + { value: "5", x: 45, y: 130 }, + { value: "6", x: 75, y: 130 }, + { value: "7", x: 105, y: 130 }, ], [ { from: 0, to: 1 }, @@ -146,35 +133,36 @@ export default function content() { ); }, []); - /* ------------- textual content ------------- */ const defFull = [ - { points: 'Every internal node has exactly two children' }, - { points: 'All leaves are on the same or adjacent levels' }, - { points: 'Maximum nodes for height h = 2^(h+1) – 1' }, + { points: "Every internal node has exactly two children" }, + { points: "All leaves are on the same or adjacent levels" }, + { points: "Maximum nodes for height h = 2^(h+1) – 1" }, ]; const defDegenerate = [ - { points: 'Each parent has only one child (left or right)' }, - { points: 'Effectively a linked list → Θ(n) height' }, - { points: 'Worst-case BST shape when data is sorted' }, + { points: "Each parent has only one child (left or right)" }, + { points: "Effectively a linked list → Θ(n) height" }, + { points: "Worst-case BST shape when data is sorted" }, ]; const defComplete = [ - { points: 'All levels fully filled except possibly the last' }, - { points: 'Last-level nodes are packed from the left' }, - { points: 'Array-based heap relies on this structure' }, + { points: "All levels fully filled except possibly the last" }, + { points: "Last-level nodes are packed from the left" }, + { points: "Array-based heap relies on this structure" }, ]; const identify = [ - { points: 'Count children for every node' }, - { points: 'If any node has exactly one child → not full' }, - { points: 'If height = n – 1 → degenerate / skewed' }, - { points: 'If level-order scan finds a gap before last node → not complete' }, + { points: "Count children for every node" }, + { points: "If any node has exactly one child → not full" }, + { points: "If height = n – 1 → degenerate / skewed" }, + { points: "If level-order scan finds a gap before last node → not complete" }, ]; return (
+
+
-
+
{/* Quick tags */}

@@ -182,16 +170,14 @@ export default function content() { Three Types

- {['Full Binary Tree', 'Degenerate / Skewed', 'Complete Binary Tree'].map( - (t) => ( -
- {t} -
- ) - )} + {["Full Binary Tree", "Degenerate / Skewed", "Complete Binary Tree"].map((t) => ( +
+ {t} +
+ ))}
@@ -205,32 +191,39 @@ export default function content() {
{[ { - title: 'Full Binary Tree', + title: "Full Binary Tree", svgRef: fullSvg, - description: "In a Full Binary Tree, there's no such thing as a node with just one child — every node has either zero children or exactly two. That strict rule keeps the tree evenly shaped, with leaves sitting at the same level or one level apart, which makes it a good starting point for understanding how balanced trees behave." + description: + "In a Full Binary Tree, there's no such thing as a node with just one child — every node has either zero children or exactly two. That strict rule keeps the tree evenly shaped, with leaves sitting at the same level or one level apart, which makes it a good starting point for understanding how balanced trees behave.", }, { - title: 'Degenerate (Skewed) Tree', + title: "Degenerate (Skewed) Tree", svgRef: degenSvg, - description: "A Degenerate, or Skewed, Tree is what you get when every parent node has only a single child — at that point it's really just a linked list wearing a tree's name. This is the worst case for height, Θ(n), and it typically happens when you insert already-sorted data into a binary search tree with no rebalancing, which tanks the performance benefits a tree is supposed to give you." + description: + "A Degenerate, or Skewed, Tree is what you get when every parent node has only a single child — at that point it's really just a linked list wearing a tree's name. This is the worst case for height, Θ(n), and it typically happens when you insert already-sorted data into a binary search tree with no rebalancing, which tanks the performance benefits a tree is supposed to give you.", }, { - title: 'Complete Binary Tree', + title: "Complete Binary Tree", svgRef: completeSvg, - description: "A Complete Binary Tree fills every level entirely except possibly the last one, and even that last level has to fill up left-to-right with no gaps. That predictable, gap-free shape is exactly what heaps are built on, since it guarantees a compact height and keeps operations efficient." + description: + "A Complete Binary Tree fills every level entirely except possibly the last one, and even that last level has to fill up left-to-right with no gaps. That predictable, gap-free shape is exactly what heaps are built on, since it guarantees a compact height and keeps operations efficient.", }, ].map(({ title, svgRef, description }, i) => (
-
+
-

{title}

-

{description}

+

+ {title} +

+

+ {description} +

))} @@ -243,18 +236,18 @@ export default function content() { Structural Rules -
+
{[defFull, defDegenerate, defComplete].map((rules, idx) => (
-

- {['Full', 'Degenerate', 'Complete'][idx]} +

+ {["Full", "Degenerate", "Complete"][idx]}

    {rules.map((r, i) => ( -
  1. +
  2. {r.points}
    3. ))} @@ -270,7 +263,7 @@ export default function content() { How to Identify a Type -
    +
      {identify.map((r, i) => (
    1. @@ -281,36 +274,44 @@ export default function content() {
    - {/* Complexity */} + {/* Height & Complexity */}

    - Height & Complexity + Height & Complexity

    - - - - - -
    Tree TypeHeight + + + + + + {[ - ['Full (balanced)', 'Θ(log n)', 'Θ(log n)'], - ['Complete', 'Θ(log n)', 'Θ(log n)'], - ['Degenerate / Skewed', 'Θ(n)', 'Θ(n)'], + ["Full (balanced)", "Θ(log n)", "Θ(log n)"], + ["Complete", "Θ(log n)", "Θ(log n)"], + ["Degenerate / Skewed", "Θ(n)", "Θ(n)"], ].map(([t, h, op], i) => ( - - - + + @@ -323,6 +324,9 @@ export default function content() { + ); -} \ No newline at end of file +}; + +export default Content; diff --git a/app/visualizer/trees/binaryTree/types/page.jsx b/app/visualizer/trees/binaryTree/types/page.jsx index a21d366..f23ab68 100755 --- a/app/visualizer/trees/binaryTree/types/page.jsx +++ b/app/visualizer/trees/binaryTree/types/page.jsx @@ -1,8 +1,12 @@ -import Animation from "@/app/visualizer/trees/binaryTree/types/animation"; import Navbar from "@/app/components/navbarinner"; import ModuleHeader from "@/app/components/modules/Header"; import Footer from "@/app/components/footer"; -import BackToTopButton from "@/app/components/ui/backtotop"; +import BackToTop from "@/app/components/ui/backtotop"; +import ExploreOther from "@/app/components/ui/exploreOther"; +import CodeBlock from "@/app/components/modules/CodeBlock"; +import codeExamples from "./code"; +import Quiz from "@/app/visualizer/trees/binaryTree/types/quiz"; +import Content from "@/app/visualizer/trees/binaryTree/types/content"; export const metadata = { title: 'Binary Tree Types | Learn Full, Complete, and Degenerate Binary Trees in DSA', @@ -22,8 +26,19 @@ export const metadata = { 'Binary Tree in Python', 'Binary Tree in Java', 'Learn Binary Trees DSA', + 'Binary Tree Quiz', ], robots: 'index, follow', + openGraph: { + images: [ + { + url: '/og.png', + width: 1200, + height: 630, + alt: 'Binary Tree Types Visualization', + }, + ], + }, }; export default function Page() { @@ -42,15 +57,30 @@ export default function Page() {
    +
    -
    - +
    +

    + Test Your Knowledge before moving forward! +

    + +
    + +
    + +
    + +
    +
    - +
    ); -} \ No newline at end of file +} diff --git a/app/visualizer/trees/binaryTree/types/quiz.jsx b/app/visualizer/trees/binaryTree/types/quiz.jsx new file mode 100755 index 0000000..dec8369 --- /dev/null +++ b/app/visualizer/trees/binaryTree/types/quiz.jsx @@ -0,0 +1,379 @@ +"use client"; +import React, { useState } from 'react'; +import { FaCheck, FaTimes, FaArrowRight, FaArrowLeft, FaInfoCircle, FaRedo, FaTrophy, FaStar, FaAward } from 'react-icons/fa'; +import { motion, AnimatePresence } from 'framer-motion'; + +const BinaryTreeTypesQuiz = () => { + const questions = [ + { + question: "What defines a Full Binary Tree?", + options: [ + "Every level is completely filled", + "Every node has either zero or exactly two children", + "The tree has the minimum possible height", + "Every node has exactly one child" + ], + correctAnswer: 1, + explanation: "A Full Binary Tree only requires that no node has exactly one child — every node has either zero children (a leaf) or two." + }, + { + question: "A Degenerate (Skewed) Binary Tree behaves most like which other data structure?", + options: ["A hash table", "A linked list", "A heap", "A graph"], + correctAnswer: 1, + explanation: "Since every node has only one child, a degenerate tree is structurally just a linked list, giving it the same Θ(n) height and worst-case performance." + }, + { + question: "What is required for a tree to be a Complete Binary Tree?", + options: [ + "Every node must have exactly two children", + "All levels must be completely full, no exceptions", + "All levels are full except possibly the last, which fills left to right", + "The tree must be sorted" + ], + correctAnswer: 2, + explanation: "A Complete Binary Tree allows the last level to be partially filled, but only if it's filled left to right with no gaps." + }, + { + question: "Why do heaps rely on the Complete Binary Tree structure?", + options: [ + "It makes every node a leaf", + "It guarantees a compact, predictable height that keeps operations efficient", + "It's required for sorting", + "It doubles the number of comparisons needed" + ], + correctAnswer: 1, + explanation: "The gap-free, left-packed shape of a Complete Binary Tree means it can be stored efficiently in an array and always has a minimal height for its node count." + }, + { + question: "What commonly causes a Binary Search Tree to become degenerate?", + options: [ + "Inserting random values", + "Inserting already-sorted data with no rebalancing", + "Deleting the root node", + "Using a heap instead" + ], + correctAnswer: 1, + explanation: "Inserting sorted (or reverse-sorted) data into a plain BST with no rebalancing causes every new node to become the only child of the previous one, producing a skewed shape." + } + ]; + + const [currentQuestion, setCurrentQuestion] = useState(0); + const [selectedAnswer, setSelectedAnswer] = useState(null); + const [score, setScore] = useState(0); + const [showResult, setShowResult] = useState(false); + const [quizCompleted, setQuizCompleted] = useState(false); + const [answers, setAnswers] = useState(Array(questions.length).fill(null)); + const [showIntro, setShowIntro] = useState(true); + const [showSuccessAnimation, setShowSuccessAnimation] = useState(false); + + const handleAnswerSelect = (optionIndex) => { + setSelectedAnswer(optionIndex); + const newAnswers = [...answers]; + newAnswers[currentQuestion] = optionIndex; + setAnswers(newAnswers); + }; + + const handleNextQuestion = () => { + if (selectedAnswer === null) return; + + if (selectedAnswer === questions[currentQuestion].correctAnswer) { + setScore(score + 1); + } + if (currentQuestion < questions.length - 1) { + setCurrentQuestion(currentQuestion + 1); + setSelectedAnswer(null); + } else { + setShowSuccessAnimation(true); + setTimeout(() => { + setShowSuccessAnimation(false); + setQuizCompleted(true); + setShowResult(true); + }, 2000); + } + }; + + const handlePreviousQuestion = () => { + setCurrentQuestion(currentQuestion - 1); + setSelectedAnswer(answers[currentQuestion - 1]); + }; + + const resetQuiz = () => { + setCurrentQuestion(0); + setSelectedAnswer(null); + setScore(0); + setShowResult(false); + setQuizCompleted(false); + setAnswers(Array(questions.length).fill(null)); + setShowIntro(true); + }; + + const calculateWeakAreas = () => { + const weakAreas = []; + if (answers[0] !== questions[0].correctAnswer) { + weakAreas.push("the definition of a Full Binary Tree"); + } + if (answers[1] !== questions[1].correctAnswer) { + weakAreas.push("degenerate/skewed tree behavior"); + } + if (answers[2] !== questions[2].correctAnswer) { + weakAreas.push("Complete Binary Tree rules"); + } + if (answers[3] !== questions[3].correctAnswer) { + weakAreas.push("why heaps use complete trees"); + } + if (answers[4] !== questions[4].correctAnswer) { + weakAreas.push("what causes a BST to degenerate"); + } + + return weakAreas.length > 0 + ? `Focus on improving: ${weakAreas.join(', ')}. Review the corresponding sections above.` + : "Perfect! You've mastered binary tree types!"; + }; + + const startQuiz = () => { + setShowIntro(false); + }; + + const getStarRating = () => { + const percentage = (score / questions.length) * 100; + if (percentage >= 90) return 5; + if (percentage >= 70) return 4; + if (percentage >= 50) return 3; + if (percentage >= 30) return 2; + return 1; + }; + + return ( +
    + {showIntro ? ( + +
    +
    + +
    +
    +

    + Binary Tree Types Quiz +

    +
    +

    + How it works: +

    +
      +
    • + + +1 point for each correct answer +
      • +
    • + + 0 points for wrong answers +
      • +
    • + + -0.5 point penalty for viewing explanations +
      • +
    • + + Earn stars based on your final score (max 5 stars) +
      • +
    +
    + +     + ) : showSuccessAnimation ? ( +
    + +
    +
    + +
    + +
    +     + + Quiz Completed! + +
    + ) : !showResult ? ( +
    +
    +
    + + Question {currentQuestion + 1} of {questions.length} + + + Score: {score.toFixed(1)} + +
    +
    +
    +
    +
    + + +

    + {questions[currentQuestion].question} +

    + +
    + {questions[currentQuestion].options.map((option, index) => ( + handleAnswerSelect(index)} + > +
    + + {String.fromCharCode(65 + index)} + + {option} +
    +     + ))} +
    + +     + +
    + + + +
    +
    + ) : ( + +
    +
    +
    +
    + {score.toFixed(1)}/{questions.length} +
    +
    +
    + {[...Array(5)].map((_, i) => ( + + ))} +
    +
    + +

    + {score === questions.length ? "Perfect Score!" : + score >= questions.length * 0.8 ? "Excellent Work!" : + score >= questions.length * 0.6 ? "Good Job!" : + score >= questions.length * 0.4 ? "Keep Practicing!" : "Let's Review Again!"} +

    +

    + You scored {((score / questions.length) * 100).toFixed(0)}% correct +

    +
    + +
    +

    + Performance Analysis +

    +

    {calculateWeakAreas()}

    +
    + +
    +

    Question Breakdown:

    + {questions.map((q, index) => ( +
    +

    {q.question}

    +
    + {answers[index] === q.correctAnswer ? ( + + ) : ( + + )} +
    +

    Your answer: {answers[index] !== null ? q.options[answers[index]] : "Not answered"}

    + {answers[index] !== q.correctAnswer && ( +

    Correct answer: {q.options[q.correctAnswer]}

    + )} +
    +
    +
    + ))} +
    + + +     + )} +
    + ); +}; + +export default BinaryTreeTypesQuiz; diff --git a/public/sitemap-0.xml b/public/sitemap-0.xml index 2dbd87f..04eb8ad 100755 --- a/public/sitemap-0.xml +++ b/public/sitemap-0.xml @@ -1,51 +1,51 @@ -https://dsavisualizer.in/blogs2026-08-02T17:39:07.996Z -https://dsavisualizer.in/blogs/Content/dsaDifferent2026-08-02T17:39:08.001Z -https://dsavisualizer.in/blogs/Content/dsaWebDev2026-08-02T17:39:08.001Z -https://dsavisualizer.in/blogs/Content/timeRequired2026-08-02T17:39:08.001Z -https://dsavisualizer.in/blogs/Content/whatIsDS2026-08-02T17:39:08.001Z -https://dsavisualizer.in/cookies2026-08-02T17:39:08.001Z -https://dsavisualizer.in/dashboard2026-08-02T17:39:08.001Z -https://dsavisualizer.in/login2026-08-02T17:39:08.001Z -https://dsavisualizer.in/privacy2026-08-02T17:39:08.001Z -https://dsavisualizer.in/terms2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/linkedList/operations/comparison2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/linkedList/operations/deletion2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/linkedList/operations/insertion2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/linkedList/operations/merge2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/linkedList/operations/reverse2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/linkedList/operations/traversal2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/linkedList/types/circular2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/linkedList/types/doubly2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/linkedList/types/singly2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/queue/implementation/array2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/queue/implementation/linkedList2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/queue/operations/enqueue-dequeue2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/queue/operations/isempty2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/queue/operations/isfull2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/queue/operations/peek-front2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/queue/types/circular2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/queue/types/deque2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/queue/types/priority2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/queue/types/singleEnded2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/searching/binarysearch2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/searching/linearsearch2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/sorting/bubblesort2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/sorting/insertionsort2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/sorting/mergesort2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/sorting/quicksort2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/sorting/selectionsort2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/stack/implementation/usingArray2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/stack/implementation/usingLinkedList2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/stack/isempty2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/stack/isfull2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/stack/peek2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/stack/polish/postfix2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/stack/polish/prefix2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/stack/push-pop2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/trees/binaryTree/properties2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/trees/binaryTree/types2026-08-02T17:39:08.001Z -https://dsavisualizer.in/visualizer/trees/traversing/in-order2026-08-02T17:39:08.001Z +https://dsavisualizer.in/blogs2026-08-02T18:12:47.748Z +https://dsavisualizer.in/blogs/Content/dsaDifferent2026-08-02T18:12:47.756Z +https://dsavisualizer.in/blogs/Content/dsaWebDev2026-08-02T18:12:47.756Z +https://dsavisualizer.in/blogs/Content/timeRequired2026-08-02T18:12:47.756Z +https://dsavisualizer.in/blogs/Content/whatIsDS2026-08-02T18:12:47.756Z +https://dsavisualizer.in/cookies2026-08-02T18:12:47.756Z +https://dsavisualizer.in/dashboard2026-08-02T18:12:47.756Z +https://dsavisualizer.in/login2026-08-02T18:12:47.756Z +https://dsavisualizer.in/privacy2026-08-02T18:12:47.756Z +https://dsavisualizer.in/terms2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/linkedList/operations/comparison2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/linkedList/operations/deletion2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/linkedList/operations/insertion2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/linkedList/operations/merge2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/linkedList/operations/reverse2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/linkedList/operations/traversal2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/linkedList/types/circular2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/linkedList/types/doubly2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/linkedList/types/singly2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/queue/implementation/array2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/queue/implementation/linkedList2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/queue/operations/enqueue-dequeue2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/queue/operations/isempty2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/queue/operations/isfull2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/queue/operations/peek-front2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/queue/types/circular2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/queue/types/deque2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/queue/types/priority2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/queue/types/singleEnded2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/searching/binarysearch2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/searching/linearsearch2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/sorting/bubblesort2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/sorting/insertionsort2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/sorting/mergesort2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/sorting/quicksort2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/sorting/selectionsort2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/stack/implementation/usingArray2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/stack/implementation/usingLinkedList2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/stack/isempty2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/stack/isfull2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/stack/peek2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/stack/polish/postfix2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/stack/polish/prefix2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/stack/push-pop2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/trees/binaryTree/properties2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/trees/binaryTree/types2026-08-02T18:12:47.756Z +https://dsavisualizer.in/visualizer/trees/traversing/in-order2026-08-02T18:12:47.756Z \ No newline at end of file
    + Tree Type + + Height + Search/Insert/Delete
    {t}{h} + + {t} + + {h} + {op}