When you prove things by induction, it is best to follow a few rules, and organize your proof. Here are a few rules to follow

Write down whatever definitions you will use.
State clearly what variable you are doing induction over.
Write down the formula you are trying to prove, both as a sentence and as a formula of the induction variable.
Write down all the cases, be sure to include the induction hypotheses, if a case has induction hypotheses
Then write down all the steps for each case. Justify each step.

Here is an example of a structural induction over lists. First note that every list has only one of two forms

It is the empty list: []
It was formed by consing an element x onto an existing list xs, so it looks like: (x : xs )

Prove: map id x = id x.
Induction variable is: x.
Formula: P(x) = map id x = id x
-- List all the definitions and equations you use.
-- label each with a name
1 map f [] = []
2 map f (x:xs) = (f x) : (map f xs)
3 id x = x
-- Set up the structure of the proof
Prove 2 things
1) P([])
 map id [] = id []
2) P(zs) => P(z:zs)
 Assuming: map id zs = id zs
 Prove: map id (z:zs) = id (z:zs)
-- label each step with the label of the definition
-- or equation that justifes it.
1) map id [] = id []
Proceed by transforming LHS into RHS with meaning preserving steps
 map id [] = [] --> (By 1)
 [] = id [] --> (By 3, backwards)
 QED
2) Assuming: map id zs = id zs
 Prove: map id (z:zs) = id (z:zs)
 Proceed by transforming LHS into RHS with meaning preserving steps
map id (z:zs) = (id z): (map id zs) --> (By 2)
(id z):(map id z) = id z:(id zs) --> (By induction hyp)
id z:(id zs) = z : zs --> (By 3, used twice)
z:zs = id (z:zs) --> (By 3 used backwards)
--------------------------------------------------------

Proofs about strings have a lot in common with proofs about lists (they are both finite sequences). When we prove things about strings we sometimes have a choice about how we break the string into parts.

Character on the Left

First note that every string has only one of two forms

It is the empty string: ""
It was formed by adding a character x onto an existing string on the left y, so it looks like: (x y)

Character on the Right

First note that every string has only one of two forms

It is the empty string: ""
It was formed by adding a character x onto an existing string on the right y, so it looks like: (y x)

Both of these are legitimate strategies. Sometimes one works better than the other. Example: Proove that string concatenation is associatve.

Prove: xs++(ys++zs) = (xs++ys)++zs
Where ++ is string concatenation.
-- List all the definitions and equations you use.
-- label each with a name. Here we use the Character on the Left convention
-- We also use two character names (ending in 's') to name strings, and one
-- character names to name charaters
1) "" ++ ws = ws
2) (x ys) ++ ws = x (ys ++ ws)
Prove: x++(y++z) = (x++y)++z
By induction on: x
Formula: P(x) = x++(y++z) = (x++y)++z
-- Set up the structure of the proof
Prove 2 things
A) P("") = "" ++(ys++zs) = ("" ++ys)++zs
B) P(ws) => P(w ws)
Assume: ws++(ys++zs) = (ws++ys)++zs
Prove: (w ws)++(ys++zs) = ((w ws)++ys)++zs
Step A
"" ++(ys++zs) = By rule (1)
(ys++ zs) = By rule (1) backwards on ys
("" ++ys)++zs
Step B
(w ws)++(ys++zs) = By rule (2)
w (ws++(ys++zs)) = By assumption
w ((ws++ys)++zs) = By rule (2) backwards on (ws+zs)
((w (ws++ys))++zs) = By rule (2) backwards on ws
((w ws)++ys)++zs