how to store array of long integer values to 16 bit memory
So the flash you are using only supports writes to a 16-bit word at a time and cannot be accessed in another way (that is a bit odd). Because of that you will have to do some manual address management, but the flash luckily comes with an address auto-increment write.

So as you can transfer just a byte via SPI anyways (there are some 16-bit variants but let's forget about them for a minute, although it would be most fitting here), the most natural way to interface with it is with byte arrays.

So I'd change the Flash_Write like so:

long int Start_Flash_Write(int StartAddress, unsigned char* Data, long int Datacount, const unsigned char FINISH_BYTE)
{
    long int dataSent = 0;
    // Make chip select Low
    Flash_Set_CS_Status(0);

    // Send Command ID 0x17
    data0 = Flash_SPI_SendByte(0x17);

    // Send Address Byte 3
    data0 = Flash_SPI_SendByte((StartAddress &amp; 0xFF0000) &gt;&gt; 16);    

    // Send Address Byte 2
    data0 = Flash_SPI_SendByte((StartAddress &amp; 0xFF00) &gt;&gt; 8);

    // Send Address Byte 1
    data0 = Flash_SPI_SendByte(StartAddress &amp; 0xFF);

    // Send first two DataBytes
    data0 = Flash_SPI_SendByte(Data[dataSent++]);
    if (dataSent &lt; (Datacount))
    {
        data0 = Flash_SPI_SendByte(Data[dataSent++]);
    }
    else
    {
        data0 = Flash_SPI_SendByte(FINISH_BYTE);
    }
    // Send Dummy Byte
    data0 = Flash_SPI_SendByte(0);

    // Make Chip select high
    Flash_Set_CS_Status(1);

    return dataSent;

}

int Flash_Write(int StartAddress, unsigned char* Data, long int Datacount)   //Flash wirte function
{ 
    int error ;
    int data0 = 0;
    long int dataSent;
    const unsigned char FINISH_BYTE  = 0xFF;

    if (Datacount == 0)
    {
        return 0; // writing nothing is easy
    }

    // First Write sets StartAddress
    dataSent = Start_Flash_Write(StartAddress, Data, Datacount, FINISH_BYTE);

    while (dataSent &lt; (Datacount))
    {
        // Make chip select Low
        Flash_Set_CS_Status(0);

        // Send Command ID 0x18 (auto increment write)
        data0 = Flash_SPI_SendByte(0x18);

        // Send first two DataBytes
        data0 = Flash_SPI_SendByte(Data[dataSent++]);
        if (dataSent &lt; (Datacount))
        {
            data0 = Flash_SPI_SendByte(Data[dataSent++]);
        }
        else
        {
            data0 = Flash_SPI_SendByte(FINISH_BYTE);
        }

        // Send Dummy Byte
        data0 = Flash_SPI_SendByte(0);

        // Make Chip select high
        Flash_Set_CS_Status(1); 
    }
}


And you would then call it like this:

Flash_Write(0x1234, (unsigned char*)(sampledata), sizeof(sampledata))

How it works:

It starts with writing the StartAddress and the first two bytes to the flash. Afterwards it writes the bytes as a pair to the next address using the auto increment mode of the flash.

As the byte count of data might not be even, I check if the data count has been reached after each byte is written. If that is the case, a constant FINISH_BYTE is used to end the transfer in a normal way.

Notes: 

I'd strongly advice against the use of integral data types directly as no one can tell how big they really are (is an int 16 or 32 bit wide?).

The datacount has to be passed to the function as information on the size of the array gets lost when it is cast to a pointer and out of scope.

The function does not return something, that should be fixed. Error is unused.