Most character lists are ordered the wrong way for writing: alphabetically by pinyin, or by raw frequency, as if each character were an independent unit to memorize. Characters are not independent; they are assembled from a smaller set of reusable parts. Ordering your learning by that structure, components before the characters that contain them, is dramatically more efficient, because every new character becomes mostly things you already know. Here is why component-first beats frequency-first.
Characters are assemblies, not atoms
The premise frequency lists ignore is that a character is built from radicals and components, reused across thousands of characters. Learn the parts and you have not learned one character; you have learned a piece of many. That is why treating each character as an atom to memorize, in alphabetical or pure-frequency order, wastes the structure: it makes you relearn the same components over and over inside different wholes, instead of learning them once, the foundation of any real structural breakdown.
Why hierarchy order is efficient
Order by hierarchy, parts before wholes, and each new character decomposes into components you have already mastered, so you are learning one or two new relationships rather than a dozen unfamiliar strokes. This leans directly on chunking in working memory: a character seen as three known parts is far easier to hold and produce than the same character seen as fifteen loose strokes, the same chunking that compresses immediate memory. The wall of strokes becomes a short list of familiar pieces, which is the heart of component-aware practice.
Pair it with spaced, from-memory practice
Sequencing is only half the system; it decides what to learn next, while spaced repetition decides when to review. Combine them: learn in component-hierarchy order, then space each item per the spacing effect, and produce from memory rather than recognizing, because the testing effect shows retrieval builds memory and for Chinese handwriting beats typing for learning. A smart order plus proper scheduling plus production is the efficient triple, the same engine behind stroke-order practice.
Why writing makes the hierarchy stick
Producing characters by hand is what cements the component structure, because writing forces you to build the character part by part in order, which is exactly the hierarchy you learned. The order you practice matters, as stroke-order learning shows, and from-memory production turns the abstract decomposition into a motor habit. So component-hierarchy ordering and handwriting reinforce each other: the order teaches the structure, and writing builds it into your hand, the same logic as comparing components across scripts.
Frequency order versus hierarchy order
| Frequency or alphabetical | Component hierarchy |
|---|---|
| Each character an atom | Each character an assembly |
| Relearns parts repeatedly | Learns parts once |
| A wall of loose strokes | A few known chunks |
| Ignores structure | Uses structure |
The right column is why a structure-aware sequence beats a flat list for writing efficiency.
A plan for component-first learning
- Learn high-yield radicals and components first.
- Then learn characters that combine the parts you know.
- See each new character as a few known chunks.
- Produce it from memory, building part by part.
- Space the repeats so the hierarchy holds.
How Hanzi Write Practice fits
Hanzi Write Practice has a radical and component breakdown built into the from-memory loop, which is what makes hierarchy-based learning practical. It hides the character, you produce it from memory part by part, and it checks stroke order and structure with spaced repetition, so you build wholes from components you already know. It is not a flat, alphabetical drill; it uses the structure that makes Chinese learnable, turning a daunting character into a short list of familiar pieces. The app is in early access.
Bottom line
Learning characters by component hierarchy, parts before the wholes they build, beats alphabetical or pure-frequency order, because each new character becomes a few things you already know. Combined with spaced, from-memory writing, it is far more efficient. Hanzi Write Practice has that component breakdown in the loop, and it is in early access, so join the list.
Frequently asked questions
Is it better to learn characters by component hierarchy than by frequency?
For efficient writing, component-first ordering is strong: by learning radicals and components before the characters that contain them, each new character decomposes into parts you already know, instead of a wall of unfamiliar strokes. Pure frequency or alphabetical order ignores this structure. Hanzi Write Practice has a radical and component breakdown built into the from-memory loop.
Why does learning components first help?
Because characters are built from a smaller set of reusable parts, so mastering the parts pays off across many characters at once, and a new character becomes a few known chunks rather than a dozen loose strokes. That chunking reduces memory load and makes both learning and recall faster and more stable.
Does component order replace spaced repetition?
No, they work together. Component-hierarchy sequencing decides what to learn next, parts before wholes, while spaced repetition decides when to review each item. Combining a smart order with spaced, from-memory practice is more efficient than either alone, because you are learning in a logical sequence and retaining it with proper scheduling.
Can an app teach characters by structural hierarchy?
Yes, if it exposes the radical and component breakdown and lets you build up from parts to wholes, with from-memory production and spacing. That structure-aware practice is more efficient than a flat list. Hanzi Write Practice includes a radical and component breakdown in its from-memory writing loop.
Want a smarter learning order? Join early access and build wholes from components you know.