A salt bridge is an ionic connection between electrolyte compartments that limits bulk mixing while permitting electric charge transport. Its mobile ions compensate changes caused by the electrode half-reactions, keeping the bulk chemical solutions approximately electrically neutral during sustained electric current. It does not conduct electrons like the external wire, and its ions need not be consumed at either electrode. The ionic return path and compensating ion flows are explained in Purdue University, Electrochemical Reactions: salt bridge and charge balance.

In a discharging Daniell cell, anions moving toward the anode compartment and cations moving toward the cathode compartment both contribute to the internal conventional current from anode toward cathode. This charge-balance role is compatible with a negative anode: terminal signs do not imply that the whole anode chemical solution is negatively charged. The simple compensating-inventory example in Daniell cell does not fix all individual ion fluxes; diffusion and the cell's other mobile ions can contribute. A real bridge also introduces electrical resistance and may introduce a junction electric potential difference, so its presence does not guarantee an exact thermodynamic cell reading. See IUPAC Gold Book: salt bridge and liquid-junction potential.

A half-reaction is a balanced chemical equation for either the oxidation or the reduction part of a redox chemical reaction, explicitly including exchanged electrons. Match the electron counts before adding the two half-reactions; the net equation then contains no transferred electrons. A half-reaction is bookkeeping, not necessarily an elementary reaction. See Florida State University, lab background: separate electrode reactions and Daniell cell.

Electrolysis uses an external source of electrical work to drive redox chemical reactions at the electrodes of an electrolytic cell. Its characteristic application is forcing a chemical reaction in a direction that is nonspontaneous under the specified conditions: a discharging galvanic cell supplies electrical work, whereas electrolysis consumes electrical work. This makes electrolysis useful for producing otherwise difficult-to-obtain chemical substances, charging a rechargeable battery, and depositing a metal coating on a conducting object.^[ref]

Always identify the anode by oxidation and the cathode by reduction. In ordinary driven two-terminal operation, the source withdraws electrons from the positive anode and delivers electrons to the negative cathode. In a discharging galvanic cell, the anode is negative and the cathode positive. Thus terminal signs change with operating mode, while the reaction definitions remain valid. Through the electrolyte, ions transport electric charge; they need not all be consumed at an electrode. The electrolyte and electrolytic cell articles explain this transport and its conventional current direction.

For a net chemical equation transferring $z$ electrons per reaction event, the molar reaction Gibbs free energy obeyswhere $F$ is the Faraday constant and $E_{\mathrm{chem}}$ is the reversible cell electromotive force for the reaction in the written direction. A nonspontaneous direction has ${\Delta }_{r}G>0$ and $E_{\mathrm{chem}}<0$ at fixed temperature and pressure. The ideal opposing voltage magnitude is ${\Delta }_{r}G/(zF)$; sustaining a finite electric current generally needs additional drive because of electrical resistance and finite electrode reaction rates. This thermodynamic voltage concerns the actual composition, rather than necessarily standard conditions.^[ref] Not every use of electrolysis increases bulk chemical Gibbs free energy: transferring copper between equivalent surfaces can have zero bulk ${\Delta }_{r}G$ while the source still supplies dissipated electrical work. See the existing electrolytic cell example.

A particularly revealing experiment measures copper transfer instead of merely looking for a coating. Two separated copper electrodes stand in aqueous $\mathrm{CuS}{\mathrm{O}}_4$ electrolyte in a vessel, with insulated leads to a regulated direct-current power supply, a series ammeter and a switch. A balance reads each electrode's mass before and after a timed run. The Institute of Physics describes copper cells with ammeters, adjustable current and removable cathodes; its comparison uses three similar cells at $1\mathrm{A}$ for ten minutes, $0.5\mathrm{A}$ for ten minutes, and $0.5\mathrm{A}$ for twenty minutes. The specified observation to test is that deposited copper mass is proportional to electric current times time. These are documented experimental settings, not measurements generated here.^[ref]

The ideal half-reactions areEach deposited copper chemical atom requires two electrons, so $z=2$. The anode loses copper and the cathode gains it; ideally their mass changes have equal magnitudes, and the bulk copper cation inventory stays constant. Local concentrations near the electrodes can nevertheless differ. The sulfate anions participate in ionic transport without appearing in these net half-reactions; electronic electric current in the wires becomes ionic electric current in the electrolyte through the two interfaces.^[ref]

Clean, rinse, dry and identify the electrodes before their initial weighing. After interrupting the electric current, rinse away adhering electrolyte, dry again and weigh without rubbing off the deposit. KIT's university practical explicitly calls for distilled-water rinsing, careful drying and weighing both electrodes; it warns that loose copper grains can be lost during handling.^[ref] Useful additional controls are repeated drying and weighing until the reading stabilizes, and a matched unpowered immersion followed by the same rinse/dry cycle. These controls test retained liquid, residual dissolved salts, handling loss and chemical changes unrelated to passed electric charge; they are proposed checks, not additional observations reported by KIT. Keep immersed electrode area, spacing, electrolyte composition and temperature comparable across runs, and keep the electrodes from touching.

Record the electric current as a function of time, together with the exact switch-on and switch-off times. Taking $I(t)\ge 0$ in the chosen deposition direction, the transported electric charge isFor constant electric current, $Q=I(t_1-t_0)$; with sampled readings, use numerical integration rather than assuming that one ammeter reading remained constant. The two equal-charge Institute of Physics settings each give $600\mathrm{C}$, while its shorter $0.5\mathrm{A}$ setting gives $300\mathrm{C}$. With $M_{\mathrm{Cu}}=63.546\mathrm{g}\mathrm{mo}{\mathrm{l}}^{-1}$, the mass per amount of substance tabulated by KIT, and $F\approx 96485.33212\mathrm{C}\mathrm{mo}{\mathrm{l}}^{-1}$, ideal Faraday's laws of electrolysis predictThese are calculated predictions for complete conversion of the measured electric charge into retained copper, not experimental results. For a stable process, doubling the electric charge doubles the deposited mass; equal electric charge gives equal deposited mass even when the electric current and duration differ.

The balance reading is a test of the whole model. Competing reduction of water or other chemical species can divert electric current from copper deposition; transient electrode capacitance can also consume part of a short pulse without producing copper. A fragile deposit can detach even when its formation used the expected electric charge. Conversely, retained electrolyte or salts can increase an apparent mass gain. Comparing anode loss with cathode gain helps detect such problems but does not identify every cause. A slope below $M_{\mathrm{Cu}}/(2F)$ alone cannot distinguish competing chemical reactions from lost deposit. Current efficiency measures the fraction of transported electric charge assigned to a specified electrode reaction, rather than the fraction of electrical energy stored chemically.^[ref]

The beautiful connection is that an electrical measurement counts chemical events: integrating electric current and reading a balance provide two ways of following the same electron stoichiometry. This makes electrolysis useful for controlling coating quantity and for testing a charge-to-amount of substance relation. It does not determine coating uniformity, adhesion or the required voltage, which depend on transport and electrode chemical kinetics as well.

A galvanic cell supplies electrical work from a spontaneous redox chemical reaction under the specified conditions. In discharge through a passive load, oxidation occurs at its negative anode and reduction at its positive cathode. Separating the reacting compartments makes the electrons take an external route, where their transport can deliver useful work. See Flowers et al., Chemistry 2e, §17.2: separated reactions and electrical work.

In the metallic external electrical circuit, electrons move from anode to cathode, while conventional current goes from cathode through the load to anode. Inside the cell, net ionic conventional current closes the loop from the anode compartment toward the cathode compartment. Oppositely moving cations and anions can both contribute to that direction; see electrolyte for the signed current density calculation. A cell can maintain a nonzero terminal electric potential difference near open circuit while delivering almost no power; the Daniell cell voltage and load experiment makes this distinction concrete.

An electrode is an electronic electrical conductor in contact with an electrolyte. In a cell carrying sustained redox electric current, chemical reactions at this interface exchange electrons with chemical species. An electrode can participate in the chemical reaction, as the dissolving zinc anode of a Daniell cell does, or provide a conducting surface without appearing in the net chemical equation. This distinction is illustrated by active and inert electrodes in Flowers, Theopold, Langley and Robinson, Chemistry 2e, §17.2.

The interface connects two kinds of electric charge transport: electrons in the external electrical circuit and ions in the electrolyte. The same electron does not travel through the wire, swim through the salt bridge, and complete a circuit! The half-reactions account for how electronic and ionic transport meet. This is the useful idea behind both obtaining electrical work in a galvanic cell and supplying electrical work in an electrolytic cell.

Name an electrode from its net chemical reaction: oxidation means anode, and reduction means cathode. State the operating mode before assigning terminal signs. For a galvanic cell supplying a passive load, the anode is negative and the cathode positive; for an ordinary two-terminal electrolytic cell driven by a source, the anode is positive and the cathode negative. Here positive means higher terminal electric potential than the other electrode, not a claim that the bulk material has a large positive net electric charge. See Pingarrón et al., Terminology of electrochemical methods of analysis (IUPAC Recommendations 2019), §§3.1 and 3.4.

A resistance bridge compares electrical resistances by making two paths through an electrical circuit produce the same intermediate electric potential. The Wheatstone bridge turns this into a null measurement: adjust one arm until a detector joining the two intermediate points reads zero, then infer the unknown from a ratio. This is useful because the balance relation does not require an accurately calibrated detector gain or supply electric potential difference, provided the supply is nonzero and the resistors obey Ohm's law.

A null measurement adjusts a known comparison until a detector indicates zero difference. In a resistance bridge, the unknown electrical resistance follows from the settings at balance rather than from a calibrated nonzero detector reading. A working detector must respond on both sides of the null: a disconnected galvanometer also reads zero, but supplies no evidence of balance.

Predation is the consumption of prey by a predator, affecting the demographic rates of both populations.

In the usual animal-feeding sense, a predator kills and eats its prey. This distinguishes the interaction from feeding on already-dead material and from the prolonged exploitation of a living host in parasitism. In the illustrative food web, a small fish eating zooplankton is a predator; a large fish eating that small fish makes the same small fish its prey. These roles belong to a particular interaction. See Clark, Douglas and Choi, Biology 2e, 45.6: predation and community interactions.

For a toy count, suppose 50 small fish begin a day and 8 are eaten by large fish. With births, other deaths and movement explicitly omitted, 42 small fish remain, and the fraction removed by predation is $8/50=0.16$. This measures removal of prey, not production of new predators. Food intake can support survival and reproduction, but eight meals do not imply eight new predators; energy flow and life-history details intervene. Lotka-Volterra equations provide one idealized account of such population dynamics, rather than a guarantee that every interacting pair must cycle.

Parasitism is an interaction in which a parasite obtains resources from a host, reducing some component of the host's performance. Its demographic effects depend on exposure, within-host processes and transmission opportunities.

Endosymbiosis is an ecological association in which one organism, the endosymbiont, lives inside another. The definition specifies location, not that both partners benefit, nor that the internal partner has become an organelle. An intracellular association can remain an association between distinct organisms. Endosymbiotic theory addresses a different question: how particular ancestral bacteria became inherited, functionally integrated organelles during evolution.

The striking consequence is that a eukaryotic biological cell can combine histories: its nuclear lineage and its mitochondria need not have the same ancestry. Mitochondria have bacterial ancestry related to Alphaproteobacteria; the plastids of plants and many algae, including chloroplasts, have ancestry within cyanobacteria. These are ancestral lineages, not a claim that a named living bacterial species is the literal ancestor. Present-day bacteria and organelles have both evolved since their shared ancestors. ^[ref]

An ecosystem is a system of interacting organisms and their nonliving surroundings. A pond study might include algae, fish, bacteria, water, dissolved chemical compounds and incoming light. The useful step is to state the boundary and time interval: the pond surface, bottom and shoreline might enclose the study region, but water, organisms and energy can cross them. The chosen boundary specifies what counts as internal storage, input or output; it does not make the ecosystem sealed. See Clark, Douglas and Choi, Biology 2e, 46.1: ecosystems and their components.

For a toy pond water budget over one day, begin with $1000{\mathrm{m}}^3$, add $120{\mathrm{m}}^3$ crossing inward, and remove $90{\mathrm{m}}^3$ crossing outward. With all other transfers omitted by assumption, the final amount is $1000+120-90=1030{\mathrm{m}}^3$. The same bookkeeping asks whether a change inside an ecosystem came from internal processes or exchanges with its surroundings. Changing the boundary to include an upstream reservoir changes which transfers are internal, while preserving the accounting.

A biological population is a set of organisms of a species occupying a specified area or experimental setting at a specified time. State the boundary for the question being studied: a flask, a breeding locality, or a wider region connected by gene flow. A biological population need not be perfectly mixed or isolated.

Biological development is the organized change of an organism through growth, differentiation and maturation. It can change cell identities, spatial relationships and function, rather than merely increasing size.

For example, gastrulation reorganizes an embryo's cells into a new arrangement, while later cell differentiation produces specialized tissues. Developmental stage is consequently more informative than chronological age alone when an intervention changes the rate or sequence of events.

A data structure representing a sequence through linked list nodes and links between them. In the singly linked representation used here, each linked list node holds an item and a next reference to its successor. head identifies the first linked list node; the final next is null, meaning no successor. An empty linked list has head = null. Sedgewick and Wayne use this representation to implement both a stack and a FIFO queue. ^[ref]

For $A\to B\to C$, place the linked list nodes at conceptual computer memory positions $40,12,76$, respectively. These deliberately separated labels describe a toy layout, not actual pointer values. The sequence order comes from the links, not increasing positions. To read index $2$, begin at head and follow two next references. For index $i$, this takes $i$ link-following steps and $O(1+i)$ time complexity, hence $O(n)$ in the worst case for $n$ linked list nodes, under the constant-cost operations assumed for the array example. ^[ref]

Suppose a reference to the existing linked list node $B$ is already known. To insert a fresh linked list node $X$ after it, first set X.next = B.next, preserving the old successor $C$, and then set B.next = X. The result is $A\to B\to X\to C$; none of the old items moves. Reversing these assignments would read the newly changed B.next and set X.next = X, losing the route to $C$ from head. This is a two-update algorithm correctness argument, rather than a claim that finding the insertion location is free.

The two pointer updates take $O(1)$ time in Big O notation. The complete insertion has $O(1)$ time complexity if the predecessor is already known, allocating and initializing the fixed-size linked list node costs $O(1)$, and copying its item has constant cost. Finding $B$ from head can instead cost $O(n)$; a position described only by an index does not confer the constant-cost advantage. This makes a linked list useful when an algorithm already holds the needed linked list node, or repeatedly works at the front as a stack does.

Deletion similarly needs the incoming link: to remove $X$ after known $B$, set B.next = X.next. A reference to $X$ alone does not identify its predecessor in this singly linked representation. The head is a special case: after checking for a nonempty linked list, remove it with head = head.next. If a tail reference is also maintained, deleting the only linked list node must clear that reference too; a stored length must also be updated. Removing a linked list node from the sequence and reclaiming its storage are separate responsibilities. ^[ref]

There are practical costs beyond Big O notation. Each singly linked linked list node needs a successor reference in addition to its item; separate allocation may add further overhead, while an array can reserve unused capacity. Consecutive array slots can make a scan reuse nearby contents already brought into a memory cache; separated linked list nodes can make link following wait for successive computer memory fetches. These are layout-dependent effects, not a guarantee that every array operation beats every linked list operation on every machine. An array of references can still lead to scattered objects, and linked list nodes can be allocated close together. ^[ref]

A binary tree, in the data structure convention used here, is a rooted tree in which each vertex has zero, one or two children in a rooted tree, occupying distinct left and right positions. A single left child and a single right child give different binary trees. A vertex with no children in a rooted tree is called a leaf. An empty binary tree has no root of a tree and is also allowed as a storage case. ^[ref]

For example, give the root of a tree label $4$, its left child label $2$ and its right child label $6$. Attach $1,3$ as the left and right children in a rooted tree of $2$, and $5,7$ as those of $6$. This binary tree has seven vertices, six edges, and height of a binary tree $2$: a longest downward graph path contains two edges. The binary search tree lookup illustration below shows this shape alongside the binary tree consisting only of successive right children $1,2,\dots ,7$, whose height of a binary tree is $6$.

Left and right positions specify an ordered shape, not a numerical total order on stored labels. Swapping labels $1$ and $7$ in the first example still gives a binary tree, but destroys the binary search tree property. Nor must a binary tree be balanced: the right-child chain is just as valid. The same shape convention supports a binary heap, a Huffman code, or a binary search tree, each with its own additional rules. The useful idea is to describe two smaller subtrees at each vertex, making structural recursion natural.

For a precise recursive description, a finite binary tree is either empty or a root of a tree carrying a value together with an ordered pair $(L,R)$ of disjoint smaller binary trees. The entries of this ordered pair are its left and right subtrees, each of which may be empty. Thus two binary tree child slots exist even when fewer than two children in a rooted tree exist; an empty slot does not denote an extra vertex. This decomposition is the basis of structural recursion.^[ref]

In the four-vertex mixed example, $A$ has left child $B$ and right child $D$, while $B$ has only a right child $C$. Count its vertices by structural recursion: the empty binary tree contributes zero and each nonempty binary tree contributes one plus the counts of its left and right subtrees. Thus $B$ contributes $1+0+1=2$, and $A$ contributes $1+2+1=4$. The same decomposition computes height of a binary tree, supports inorder traversal, and supplies short proofs by structural induction. It separates shape from the values stored in a data structure.

Ignoring values, let $b_n$ count finite binary tree shapes with $n$ vertices, retaining left and right slots and counting the empty shape once. Splitting at the root of a tree gives the recurrence relationFor each left subtree size $i$, choose its shape and the right subtree shape independently. This yields the Catalan numbers: $b_1=1$, $b_2=2$, and $b_3=2+1+2=5$. The two shapes at $n=2$ are exactly the left-only and right-only examples. Forgetting the slot distinction would change the counting problem.

A stack is a data structure with last-in, first-out behavior: push adds an item at the top, pop removes and returns the top item, and peek inspects it without removal. Push $A,B,C$: successive removals return $C,B,A$. Inspection and removal require a nonempty stack, or a specified empty-case result. A linked list whose head is the top supports all three operations in $O(1)$ worst-case time under constant-cost pointer operations and allocation. The stack interface itself does not fix these costs. ^[ref]

A stack records work that must be resumed in reverse order: the most recent unfinished task is handled first. Depth-first search uses this discipline to finish a newly entered branch before resuming the older branch that led to it. Breadth-first search uses a FIFO queue to resume the oldest pending vertex instead. Both are small interfaces whose removal rule changes the shape of a graph search.

A FIFO queue is a data structure with first-in, first-out behavior: enqueue inserts at the rear, dequeue removes and returns the front, and peek inspects the front without removing it. Removal and inspection require a nonempty FIFO queue, or an explicitly defined empty-case result. Enqueue $A,B,C$ in that order, dequeue $A$, then enqueue $D$: the remaining sequence is $B,C,D$, with $B$ next. A LIFO stack would remove the most recently inserted item instead. A FIFO queue models arrival-order service and supplies the next vertex for breadth-first search; a stochastic service model belongs to queueing theory. ^[ref]

The FIFO queue interface specifies removal order, not time complexity. A linked list with both front and rear pointers supports enqueue, dequeue and peek in $O(1)$ worst-case time under constant-cost pointer operations and allocation, as in Sedgewick and Wayne's implementation. A plain array that deletes its first entry by shifting the remaining $n-1$ entries takes $O(n)$ time per such removal. An array with advancing front and rear indices can avoid these shifts; storage and resizing policies still need analysis. The two-list functional queue gives a different implementation with constant amortized analysis cost along a single sequence of uses. These representation choices matter when deriving the linear time complexity of breadth-first search in Big O notation.

// Destination: computer-science.bigb

A circular buffer stores a changing sequence in a fixed-capacity array, reusing slots by wrapping array indices through modular arithmetic. A front array index and an occupied count can represent a FIFO queue without shifting entries after removal. The physical array stays in place; the position at which its logical sequence begins moves. This makes a circular buffer useful when storage must remain bounded while successive items arrive and leave.

Capacity and overflow behavior are separate choices. A rejecting FIFO queue preserves all accepted items until removal and reports failure on a full insertion. An overwriting circular buffer deliberately discards its oldest item to retain the newest arrivals. These are different application programming interfaces. The existing representation independence example specifies the rejecting policy and gives its abstraction function and correctness argument against a shifting array implementation.

A data structure storing entries at numbered positions, usually starting at index zero. The fixed-capacity representation considered here puts equal-sized slots consecutively in computer memory. The number $n$ of occupied slots can be smaller than the capacity; unused slots provide room for later entries. An array of references stores consecutive references, while the objects they identify can be elsewhere. ^[ref]

Let the first slot have abstract address $b$ and each slot occupy $s$ address units. Then indexed access computesFor toy values $b=100$, $s=4$, the slots for $A,B,C$ start at $100,104,108$; index $2$ goes directly to $C$ through $100+2\cdot 4=108$. These are illustrative slot addresses, not observed allocation addresses. Under the word-RAM (random-access machine) model for time complexity, word-sized arithmetic operations and any addressed computer memory access have constant cost, and the addresses and entries fit in words. Thus one array access takes $O(1)$ time in Big O notation, independently of the index. This is the access assumption needed by binary search. ^[ref]

Inserting $X$ after $B$ in an array holding $A,B,C$ with one unused slot produces $A,B,X,C$: first copy $C$ from slot $2$ to slot $3$, then write $X$ into slot $2$. Writing $X$ first would lose $C$ unless it had been saved separately. More generally, insert at index $i$ by copying occupied slots from right to left, then fill the gap; with spare capacity this moves $n-i$ entries and takes $O(1+n-i)$ time in Big O notation, so insertion near the middle has $O(n)$ time complexity. Removing an entry closes the gap by shifting later entries left. ^[ref]

A fixed-capacity array cannot accept another entry when full. A resizable representation can allocate a larger array and copy the entries. Doubling capacity when full gives $O(1)$ append cost by amortized analysis over a sequence starting empty, but a single append that copies $n$ entries still has $O(n)$ worst-case time complexity. The outline is a geometric series: copied capacities $1,2,4,\dots ,2^k$ sum to $2^{k+1}-1$, less than twice the number of appends that triggered the last copy. Middle insertion still pays for its shifts. ^[ref]

A hash table stores records by key: for example, a product number can select its current stock count without scanning every product. A hash function selects a hash bucket in an array, and a collision-handling method such as separate chaining retains distinct keys assigned to the same hash bucket. The useful idea is to narrow the search to one small collection, while key equality decides which record actually matches.

Use a map interface with one value per key: get(k) returns the associated value or an explicit absent result; put(k,v) replaces the value if an equal key is present, otherwise inserts a new record; delete(k) removes the matching record if present. The absent result must be distinguishable from every permitted stored value. Replacing a value does not increase the record count $n$. A hash collision between unequal keys must never cause one record to replace the other.^[ref]

Let $x\sim y$ denote the chosen key equality, an equivalence relation, and let $h_m$ be the bucket-index hash function for $m>0$ hash buckets. Correctness requiresThe converse is false: equal bucket indices merely identify candidates for a key equality comparison. If an implementation first computes a full hash value $H(k)$ and then reduces it to a bucket index, equal keys must have equal $H$ values too. Keep both key equality and the hash function stable while a key is stored; changing the key so it selects another hash bucket can make its record unreachable. This distinction is explicit in the published hashCode/equals contract.^[ref]

For a constructed integer example, use modular arithmetic to define $h_m(k)=k\mathrm{mod}m$ and store keys $1,5,9,2$ with values $A,B,C,D$. At $m=4$, three records share hash bucket $1$ and one occupies hash bucket $2$. The hash table load factor isIt is the mean number of records per hash bucket, including empty hash buckets, not a bound on the longest chain. With separate chaining, $\alpha$ may exceed $1$ because records live in the chains rather than one record being confined to each array slot.

Growing this example to $m=8$ changes the bucket-index hash function: key $5$ now belongs to hash bucket $5$, while keys $1,9$ still share hash bucket $1$. Every record must be assigned using the new bucket-index hash function; copying the old array of chain heads unchanged is insufficient. The hash table load factor becomes $4/8=1/2$.

For an insertion-only sequence starting empty with constant initial capacity, one policy doubles $m$ before inserting a new key that would make $n>m$. A rebuild for separate chaining allocates the new array and transfers each existing record directly into its new chain. Since keys are already distinct, transfer needs no duplicate search. With constant-cost hashing and linking, this takes $O(n+m)$ time complexity, hence $O(n)$ at a growth threshold. Amortized analysis charges the occasional rebuild across many insertions: the old capacities $1,2,4,\dots ,2^r$ form a geometric series with sum $2^{r+1}-1$, so total rebuilding work over $N$ insertions is $O(N)$. This gives $O(1)$ amortized resizing overhead; an insertion that triggers a rebuild can still take $O(n)$.^[ref]

The search to check for an existing key is additional work. Bounded hash table load factor together with the probabilistic assumptions in separate chaining gives expected amortized $O(1)$ insertion, not worst-case $O(1)$. Rehashing alone gives no distribution guarantee: the diagram's keys $1,9,17,25$ all collide modulo both $4$ and $8$. Even a low hash table load factor permits a long chain. If supporting shrinkage too, leave a gap between growth and shrink thresholds to avoid repeated rebuilding when insertions and deletions alternate near one threshold.^[ref]