Q:

Scheme split operation not working

I'm new to scheme and am having some trouble debugging my code. 
; returns number of elements in a list
(define (length L)
  (cond ((null?  L) 0)
        (else (+ (length (cdr L)) 1))))

; split the list in half:
; returns ((first half)(second half))
(define (split L)
  (cond 
    ((= (length L) 0) (list L L) )
    ((= (length L) 1) (list L '() ))
    (else 
      (list (sublist L 1 (/ (length L) 2) 1)
            (sublist L (+ (/ (length L) 2) 1) (length L) 1)))))

; extract elements start to end into a list
(define (sublist L start end counter)
  (cond ((null?  L) L)
        ((< counter start) (sublist (cdr L) start end (+ counter 1)))
        ((> counter end) '())
        (else (cons (car L) (sublist (cdr L) start end (+ counter 1))))))

To me, this feels like it would split a single list into two sub lists.   There may be an easier way to do this, and so I apologize if this seems cumbersome. 
Anyway, the results:
Expected: (split '(1 2 3 4 5)) = ('(1 2) '(3 4 5))
Actual:  (split '(1 2 3 4 5)) = ('(1 2) '(4 5))

It's clear that the length or split is losing the middle value, but I've checked it again and again and it seems to lose the middle value.   It seems like an easy solution would be to get rid of the (+ 1) of (+ (/ (length L) 2) 1) but this seems counter intuitive to me, as:
Assume L = '(1 2 3 4 5), (/ (length L) 2) = 2, and (+ (/ (length L) 2) 1) = 3
(sublist L 1 (2) 1) = '(1 2)
(sublist L (3) 5 1) = '(3 4 5)
** I put parens around the 2 and 3 to indicate that they were length calculations. 

Clearly an assumption I am making is false, or I am overlooking something trivial. 
Thanks in advance! 

A:

Do you know the tortoise-and-hare algorithm?  The tortoise walks the list, the hare runs the list at double speed.  The split occurs at the position of the tortoise when the hare reaches the end of the list.  Here's most of the code; I'll let you figure out the rest:
(define (split xs)
  (let loop ((ts xs) (hs xs) (zs (list)))
    (if (or (null?  hs) (null? ( cdr hs)))
        (values (reverse zs) ts)
        (loop ...))))

Here ts is the remaining list of items to be examined by the tortoise, hs is the remaining list of items to be examined by the hare, and zs is the list of items already examined by the tortoise, in reverse order. 
Note that you never need to count the items in the input list. 