Sort array by order specified in another array

You can sort by the index of the item in the requiredOrder array by using Array.IndexOf()

listToBeSorted = listToBeSorted.OrderBy(x => Array.IndexOf(requiredOrder, x.Value)).ToList();

I loved Lasse's answer, but it can be even a bit neater. Try this:

var requiredOrder = new String[] { "PH", "HH", "PR", "SR", "UN", "UD", "WD", "WE", "OT" };

var listToBeSorted = new List<KeyValuePair<string, string>>()
{
    new KeyValuePair<string, string>("A","PR"),
    new KeyValuePair<string, string>("B","PH"),
    new KeyValuePair<string, string>("C","HH"),
    new KeyValuePair<string, string>("D","WD"),
    new KeyValuePair<string, string>("E","OT"),
    new KeyValuePair<string, string>("F","UN"),
};

var lookup = listToBeSorted.ToLookup(x => x.Value);

var sorted =
    from x in requiredOrder
    from y in lookup[x]
    select y;

That gives:

Considered that the list to be sorted has only uniques:

The O(N^2) approach will perform better than OrderBy with IndexOf, the latter being NLogN * N = (N^2)LogN (since the indexof, which hides N, performed at each step of the sort), see comment within the code

var sortedList = new List<KeyValuePair<string, string>>();

for (int i = 0; i < requiredOrder.Length; i++) { // "i" spares indexof.
    for (int j = 0, l = listToBeSorted.Count; j < l; j++) {
        if (requiredOrder[i].Equals(listToBeSorted[j].Value)) {
            sortedList.Add(listToBeSorted[j]);
            //might as well Remove from listToBeSorted to decrease complexity.
            //listToBeSorted.RemoveAt(j);
            break;
        }
    }
}

Not the classiest of code, but can be further improved.

If you Remove from listToBeSorted (and adjust loop indexes) complexity will tend to NLogN (to be accurate, still 1/2 N^2) and space complexity to "0 additional".

I don't see the need for any sorting at all.

var requiredOrder = new String[] { "PH", "HH", "PR", "SR", "UN", "UD", "WD", "WE", "OT" };

var listToBeSorted = new List<KeyValuePair<string, string>>() {
    new KeyValuePair<string, string>("A","PR"),
    new KeyValuePair<string, string>("B","PH"),
    new KeyValuePair<string, string>("C","HH"),
    new KeyValuePair<string, string>("D","WD"),
    new KeyValuePair<string, string>("E","OT"),
    new KeyValuePair<string, string>("F","UN"),
    .....
};

Simply transform the listToBeSorted into a lookup table, then grab all the objects from this table when iterating the requiredOrder:

var lookup = listToBeSorted.ToLookup(kvp => kvp.Value);
var result =
    from key in requiredOrder
    from obj in lookup[key]
    select obj;

Here's another approach:

1. Create an array of indices the same length as the array to be sorted.
2. Use Array.Sort(Array keys, Array items) to sort the indices into the correct order.
3. Use the index array to access the list in the desired order.

Here's the sample code - the lines corresponding to the steps in the algorithm above are annotated with (1), (2) and (3):

using System;
using System.Collections.Generic;
using System.Linq;

namespace Demo
{
    public static class Program
    {
        public static void Main(string[] args)
        {
            var requiredOrder = new [] { "PH", "HH", "PR", "SR", "UN", "UD", "WD", "WE", "OT" };

            var listToBeSorted = new List<KeyValuePair<string, string>>() {
                new KeyValuePair<string, string>("A", "PR"),
                new KeyValuePair<string, string>("B", "PH"),
                new KeyValuePair<string, string>("C", "HH"),
                new KeyValuePair<string, string>("D", "WD"),
                new KeyValuePair<string, string>("E", "OT"),
                new KeyValuePair<string, string>("F", "UN"),
                new KeyValuePair<string, string>("G", "UD"),
                new KeyValuePair<string, string>("H", "WE"),
                new KeyValuePair<string, string>("I", "SR")
            };

            int[] indices = Enumerable.Range(0, requiredOrder.Length).ToArray(); // (1)

            Array.Sort(requiredOrder, indices); // (2)

            foreach (var index in indices) // (3)
            {
                Console.WriteLine(listToBeSorted[index].Key);
            }
        }
    }
}