It's the original C syntax as designed by Dennis Ritchie, so bite your tongue :-)
As mentioned in another answer, the style was not unusual at the time. For an example of early art: FORTRAN II (1958) did not have variable declarations at all. A variable existed by being mentioned. The type of an identifier was determined by its initial letter (I to N INTEGER, otherwise REAL). There was a DIMENSION statement for specification of array identifiers.
Subroutine declarations would therefore have no type information in the SUBROUTINE statement, though may be followed by a DIMENSION.
SUBROUTINE FOO(VALUES, KOUNT)
VALUES is a REAL array of KOUNT elements.
(We all learned the art of bad spelling)
FORTRAN IV (~1962) added type declarations, but they were optional in general. The implicit declaration and "initial letter" rules still applied. The dummy arguments of subroutines could have type specifiers in subsequent statements, but were not required to.
SUBROUTINE BAR(VALUES, KOUNT)
DOUBLE PRECISION VALUES
In Algol 60, the argument types are specified after the procedure heading, and before the body of the procedure - here just a single statement. Assignment to the procedure name was how a return value was indicated.
integer procedure square(n);
value n; integer n;
square := n × n;
By Algol 68, you might find the formal-parameter style a little more familiar. The returned value is the value of the last expression to be executed. The type of 'square' is read as something like 'proc of int returning int'.
proc square = (int n) int :
(n × n);
In short, there was nothing unusual at the time about that aspect of C. The style that C initially adopted for function definitions was quite common at the time, so it's not so strange a choice for Ritchie to have made. The style you are more familiar with did not fully emerge in C until ANSI C, in 1989 - 17 years after C was created.
Note too that there was not necessarily a way to state all of the attributes of a formal parameter in a single statement: Algol needed integer for type, and (optionally) value for mechanism.
Incidentally, the reason for the ANSI C change was not so much in the definition of a function -- both forms of function definitions convey the argument types -- but in the declaration of functions, for example in header files. The latter carried no argument information at all - for example all you could say about an external function in K&R style was what it returned:
This is error-prone; you don't find out (with the compiler technology of the day) until execution time that you've got a mismatch.
While ANSI C added the new syntax, they did not outlaw the old K&R syntax, which remains valid, in the successive ISO standards as well as the original ANSI.
Link: paper from Ritchie on the history of C