Looking for a C# algorithm to compare two lists

List<string> lstIn1NotIn2 = lst1.Except(lst2).ToList();
List<string> lstIn2NotIn1 = lst2.Except(lst1).ToList();

Use LINQ to compare two lists of strings[^]

class CompareLists
{        
    static void Main()
    {
        // Create the IEnumerable data sources.
        string[] names1 = System.IO.File.ReadAllLines(@"../../../names1.txt");
        string[] names2 = System.IO.File.ReadAllLines(@"../../../names2.txt");

        // Create the query. Note that method syntax must be used here.
        IEnumerable<string> differenceQuery =
          names1.Except(names2);

        // Execute the query.
        Console.WriteLine("The following lines are in names1.txt but not names2.txt");
        foreach (string s in differenceQuery)
            Console.WriteLine(s);

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit");
        Console.ReadKey();
    }
}
/* Output:
     The following lines are in names1.txt but not names2.txt
    Potra, Cristina
    Noriega, Fabricio
    Aw, Kam Foo
    Toyoshima, Tim
    Guy, Wey Yuan
    Garcia, Debra
     */

-KR

Please see my comment to the question.

The problem is quite trivial, the only question is how efficient your search can be. First of all, your "in a way that I know which list it came from" means pretty big thing. As your solution will list all encountered words, and each word can be found in both lists or in a subset of lists (in case of just two, in one or another) "the way to know" would mean that each element of solution should contain the following components: 1) a word itself, 2) a set (or any other collection) of references to original lists. The whole solution would be something like
using System.Collections.Generic;

using System.Collections.Generic;

//...

Dictionary<string, HashSet<string>> = //...</string>

The key of your dictionary would represent a word, and the value type — the set of references to your original lists. I suggested the type HashSet for purely "ideological" reasons: the order of references may not matter; but the reason to choose dictionary is more important: this is the performance of finding already added word you will need to do on each step, which will be of the time complexity of O(1), in contrast to list's O(N).

Now, as you will need to perform the search many times, the List type is not the best choice. I would populate the data in System.Collections.Generic.HashSet, which provides the time complexity for search of O(1):
https://msdn.microsoft.com/en-us/library/bb359438%28v=vs.110%29.aspx[^],
https://msdn.microsoft.com/en-us/library/bb356440%28v=vs.110%29.aspx[^] (search method).

At the same time, if the lists are small, the overhead of re-population of data may not pay off, so using lists in all cases will be good enough; and you can use LINQ to Objects: https://msdn.microsoft.com/en-us/library/bb397919.aspx[^].

You can iterate this collection is a usual way with the usual way, foraach… in, because this type implements System.Collections.Generic.IEnumerable<>:
https://msdn.microsoft.com/en-us/library/9eekhta0(v=vs.110).aspx[^].

So, you would need to iterate one set, checking presence of each word in a second one and adding it in the solution dictionary. After that, you will need to do it with the second set, because some words may never appear in the first one. When you add data to the dictionary, you use the method TryGetValue:
https://msdn.microsoft.com/en-us/library/xfhwa508%28v=vs.110%29.aspx[^],
https://msdn.microsoft.com/en-us/library/bb347013(v=vs.110).aspx[^].

If the word is already found, you try to add the source set reference(s) to the value part of the dictionary element, if not, you add the element by the new key (source word).

That's all. Your overall time complexity will be of O(1), which is the fastest possible. However, the absolute time could be better for, say, lists, if the input data set is very small, but combination of set and dictionary will very quickly outperform any other solution as size of data grows.

—SA