Object Not Read Exact Data From File

Without seeing where you are writing to the file, I can't suggest a fix, however I can suggest an alternative. Serialization[^]. The idea is that each class/struct is responsible for saving/restoring its own data, which really simplifies things.

#include <stdio.h>

#include "stdafx.h"
#include<iostream>
#include<conio.h>
#include<fstream>

using namespace std;
 
struct node {
	node *next;
	int Id;
	/*This is an initialiser list, which is only valid in a constructor
	It has the same effect as "next = NULL; Id = id;", only it is a touch faster*/
	node(int id) : next(NULL), Id(id) { } //Add a parameter in here for the value to make construction neater when you make it
	void serialize(ostream &s) {
		//recursively write to file
		s.write((char *)&Id, sizeof(Id));
		if (next != NULL) {
			next->serialize(s);
		}
	}
	static node *unserialize(istream &s) {
		//recursively read from file
		int i;
		s.read((char *)&i, sizeof(i));
		if (s.eof()) {
			return NULL;
		}
		node *n = new node(i);
		n->next = unserialize(s);
		return n;
	}
};
 
class LL {
	node* first;
	//This allows us to add directly to the end of the list, instead of iterating through each element.
	//When you start getting a few hundred elements in the list you will notice the difference
	node* last;
 
public:
	LL() : first(NULL), last(NULL) { } //Another initialiser list
	~LL() {
		//Clean up the memory
		node *n = first;
		while (n != NULL) {
			node *del = n;
			n = n->next;
			delete del;
		}
	}

	void add(int i) {
		if(first == NULL) {
			first = new node(i);
			last = first;
		} else {
			//Isn't this easier?
			node *temp = new node(i);
			last->next = temp;
			last = temp;
		}
	}
	void show() {
		node *tfirst = first;
		while (tfirst != NULL) {
			cout<<"ID "<<tfirst->Id<<endl;
			tfirst = tfirst->next;
		}
	}
	void serialize(ostream &s) {
		if (first != NULL) {
			first->serialize(s);
		}
	}
	static LL *unserialize(istream &s) {
		LL *ll = new LL();
		ll->first = node::unserialize(s);
		ll->last = ll->first;
		return ll;
	}
};

int _tmain(int argc, _TCHAR* argv[]) {
	LL *ll = new LL();
	ll->add(1);
	ll->add(2);
	ll->add(4);
	ll->add(3);
	cout << "Original list:" << endl;
	ll->show();
	fstream fs;
	//NOTE: This opens the file for appending.
	//The original contents will remain in the file, and this will be added to the end
	fs.open("Malik.txt", ios::out|ios::binary|ios::app);
	ll->serialize(fs);
	delete ll;
	fs.close();
	fs.open("Malik.txt", ios::in|ios::binary|ios::app);
	cout << "Saved list:" << endl;
	ll = LL::unserialize(fs);
	ll->show();
	delete ll;
	fs.close();
	return 0;
}

Also, you could use Templates[^] for this, which would make it a little more dynamic, if you need lists of multiple data types.