See if you can figure this bit out.
Is this meant to be a Programming Puzzle Programming Puzzle?
You don't call append until after you finish calling reverse; reverse is recursive; so all the append calls will be called after all the reverse calls: and that explains why reverse will eventually terminate i.e. why the list will eventually be empty.
From a code-review point of view:
- I fear that a recursive implementation might exceed your finite maximum stack size if the list is long.
- You're deleting and creating new Node objects; you might instead be able to do it in a way that reuses existing Node instances.
Also, it should be spelled "sentinel".
See if you can figure this bit out.
Is this meant to be a Programming Puzzle?
You don't call append until after you finish calling reverse; reverse is recursive; so all the append calls will be called after all the reverse calls: and that explains why reverse will eventually terminate i.e. why the list will eventually be empty.
From a code-review point of view:
- I fear that a recursive implementation might exceed your finite maximum stack size if the list is long.
- You're deleting and creating new Node objects; you might instead be able to do it in a way that reuses existing Node instances.
Also, it should be spelled "sentinel".
See if you can figure this bit out.
Is this meant to be a Programming Puzzle?
You don't call append until after you finish calling reverse; reverse is recursive; so all the append calls will be called after all the reverse calls: and that explains why reverse will eventually terminate i.e. why the list will eventually be empty.
From a code-review point of view:
- I fear that a recursive implementation might exceed your finite maximum stack size if the list is long.
- You're deleting and creating new Node objects; you might instead be able to do it in a way that reuses existing Node instances.
Also, it should be spelled "sentinel".
See if you can figure this bit out.
Is this meant to be a Programming Puzzle?
You don't call append until after you finish calling reverse; reverse is recursive; so all the append calls will be called after all the reverse calls: and that explains why reverse will eventually terminate i.e. why the list will eventually be empty.
From a code-review point of view:
- I fear that a recursive implementation might exceed your finite maximum stack size if the list is long.
- You're deleting and creating new Node objects; you might instead be able to do it in a way that reuses existing Node instances.
Also, it should be spelled "sentinel".
See if you can figure this bit out.
Is this meant to be a Programming Puzzle?
You don't call append until after you finish calling reverse; reverse is recursive; so all the append calls will be called after all the reverse calls: and that explains why reverse will eventually terminate i.e. why the list will eventually be empty.
From a code-review point of view:
- I fear that a recursive implementation might exceed your finite maximum stack size if the list is long.
- You're deleting and creating new Node objects; you might instead be able to do it in a way that reuses existing Node instances.
See if you can figure this bit out.
Is this meant to be a Programming Puzzle?
You don't call append until after you finish calling reverse; reverse is recursive; so all the append calls will be called after all the reverse calls: and that explains why reverse will eventually terminate i.e. why the list will eventually be empty.
From a code-review point of view:
- I fear that a recursive implementation might exceed your finite maximum stack size if the list is long.
- You're deleting and creating new Node objects; you might instead be able to do it in a way that reuses existing Node instances.
Also, it should be spelled "sentinel".
See if you can figure this bit out.
Is this meant to be a Programming Puzzle?
You don't call append until after you finish calling reverse; reverse is recursive; so all the append calls will be called after all the reverse calls: and that explains why reverse will eventually terminate i.e. why the list will eventually be empty.
From a code-review point of view:
- I fear that a recursive implementation might exceed your finite maximum stack size if the list is long.
- You're deleting and creating new Node objects; you might instead be able to do it in a way that reuses existing Node instances.