My C code for Fibonacci Sequence
Doesn't work
The program doesn't work for me.  Example:
$ ./fibonacci
Please input the Nth index of the last sequence value.
Program will return entire Fibonacci Sequence up to and including Nth value.
10
1 1 2 3 1 0 1 1 2 3

The problem is that the array tempseq is a temporary local variable, which means that every time you call the function Fibonacci(), that variable becomes unitialized.  Your code is doing two things wrong:

It assumes that tempseq will contain the values that it had from previous invocations of the function Fibonacci().
It assumes that Fibonacci() will be called in a loop from 0 to n.  If you just called Fibonacci(10) directly, it would not work because it depends on the answers for 8 and 9 being precomputed.

Fixes

To fix problem #1, you can declare your tempseq array using the static keyword.  This makes the array persist across invocations.  You can think of it like if the static keyword made the tempseq variable into a global variable.

To fix problem #2, you should not assume that an entry in tempseq is necessarily valid.  You can do something like check if the entry is 0.  If it is zero, then the entry must be computed, otherwise it is valid to use.


Rewrite
I have rewritten your function with the two problems fixed:
#define FIBMAX        100

// Computes the Nth Fibonacci number.
unsigned int Fibonacci(unsigned int n)
{
    // FibResult is a persistent array of already computed values.
    // We initialize fibResult[0] and [1] to take care of special cases.
    static unsigned int fibResult[FIBMAX] = { 1, 1 };

    // Guard against bad input.
    if (n &gt;= FIBMAX)
        return 0;

    if (fibResult[n] == 0) {
        // We have not previously computed this entry, so compute it now
        // using the recurrence relation.
        //
        // Note: calling Fibonacci(n-1) guarantees that fibResult[n-2] will
        // be set, so we just use that to avoid one function call.  We
        // could have written this and it would have worked just fine:
        //
        // fibResult[n] = Fibonacci(n-1) + Fibonacci(n-2);
        //
        fibResult[n] = Fibonacci(n-1) + fibResult[n-2];
    }

    return fibResult[n];
}

This rewrite also:

Replaces the magic number 100 with a defined constant and checks the input so that we don't have any buffer overflow problems.
Takes care of the special cases of n=0 and n=1 by filling in those entries in the fibResult array.

Simpler way
You might also want to consider a simpler function that doesn't use an array of precomputed values.  Calculating a fibonacci number can be done in a simple loop like this:
unsigned int Fibonacci(unsigned int n)
{
    unsigned int f1 = 1;
    unsigned int f2 = 1;

    for (unsigned int i = 0; i &lt; n; i++) {
        f2 = f1 + f2;
        f1 = f2 - f1;
    }
    return f1;
}