# Effective method of merging multiple lists based on item weights

I am writing a chess engine and I require an efficient way of merging multiple lists into a singular list ordered by the smallest value.

Each list is quintessentially a group of chess pieces that are already ordered in perfect attack order. For example I have a White Queen on a2, White Bishop on b3, White Rook on f1 and White Rook on f2. Now say I have a Black Pawn on f7 then all four White pieces are converging on the f7 square from two different discrete directions - North East (Queen & Bishop) and North (Rooks).

These two groups would be ordered as follows:

Group A) 1st - Bishop (b3); 2nd - Queen (a2)
Group B) 1st - Rook (f2); 2nd - Rook (f1)

Now using the points system below I would expect both lists to be merged into a single list in the following order (lowest value to highest value): Bishop (b3), Rook (f2), Rook (f1) and finally Queen (a2).

Queen = 900 pts
Rook = 500 pts
Bishop = 375 pts
Knight = 350 pts
Pawn = 100 pts

Some code:

``````using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace SO_22015528
{
public enum eRayDirection
{
North,
NorthEast,
East,
SouthEast,
South,
SouthWest,
West,
NorthWest
}

public enum ePieceType
{
Empty = 0,
Pawn = 1,
Knight = 2,
Bishop = 3,
Rook = 4,
Queen = 5,
King = 6
}

public struct BoardPosition : IComparable<BoardPosition>
{
public int File;
public int Rank;
public int Square;

public BoardPosition( int square )
{
Square = square;
File = square % 7;
Rank = 8 - ( square >> 3 );
}

public static Boolean operator >( BoardPosition b1, BoardPosition b2 )
{
return ( b1.Rank > b2.Rank ) || ( b1.Rank == b2.Rank && b1.File < b2.File );
}

public static Boolean operator <( BoardPosition b1, BoardPosition b2 )
{
return ( b1.Rank < b2.Rank ) || ( b1.Rank == b2.Rank && b1.File > b2.File );
}

public int CompareTo( BoardPosition obj )
{
if ( this < obj ) return 1;
else if ( this > obj ) return -1;
else return 0;
}
}

public class ChessPiece
{
public int Value { get; set; }
public ePieceType Type { get; set; }
public int Square { get; set; }
public BoardPosition XY
{
get
{
return new BoardPosition( this.Square );
}
}
public ChessPiece( ePieceType type, int value, int square )
{
Value = value;
Type = type;
Square = square;
}
}

public class Constraint
{
public ChessPiece Piece { get; set; }
public eRayDirection Ray { get; set; }
public Constraint( ChessPiece piece, eRayDirection ray )
{
Piece = piece;
Ray = ray;
}
public override string ToString()
{
return String.Format( "{0} {1} {2}", Piece.Square, Piece.Type, Ray );
}
}

}

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

namespace SO_22015528
{
class Program
{
static void Main( string[] args )
{
// test code
ChessPiece a2 = new ChessPiece( ePieceType.Queen, 900, 48 );
ChessPiece b3 = new ChessPiece( ePieceType.Bishop, 375, 41 );
ChessPiece f1 = new ChessPiece( ePieceType.Rook, 500, 61 );
ChessPiece f2 = new ChessPiece( ePieceType.Rook, 500, 53 );

// This just simulates pieces that attack on the f7 square.
List<Constraint> f7 = new List<Constraint>();
f7.Add( new Constraint( b3, eRayDirection.NorthEast ) );
f7.Add( new Constraint( a2, eRayDirection.NorthEast ) );
f7.Add( new Constraint( f1, eRayDirection.North ) );
f7.Add( new Constraint( f2, eRayDirection.North ) );

// Get all positive ray directions ( use to simplify LINQ orderby )
List<eRayDirection> positiveRayDirections = new List<eRayDirection>();

var groups = f7
.GroupBy( g => g.Ray )
.Select( a =>
new
{
Key = a.Key,
Results = positiveRayDirections.Contains( a.Key ) ? a.OrderBy( x => x.Piece.XY ).ToList() : a.OrderByDescending( x => x.Piece.XY ).ToList()
} ).ToList();

// The groups object returns two discrete groups here;
// NorthEast containing 2 entries (Bishop & Queen) and North
// also containing to entries (Rook x 2).
List<Constraint> attackOrder = new List<Constraint>();

List<Int32> groupIndicies = new List<Int32>( groups.Count() );
for ( int n = 0; n < groups.Count(); n++ )

while ( true )
{
Int32 value = Int32.MaxValue;
Int32 groupIndex = -1;

for ( int n = 0; n < groups.Count(); n++ )
{
var g = groups[ n ];
int gIndex = groupIndicies[ n ];

if ( gIndex < g.Results.Count && g.Results[ gIndex ].Piece.Value < value )
{
value = g.Results[ gIndex ].Piece.Value;
groupIndex = n;
}
}

if ( groupIndex < 0 )
break;

attackOrder.Add( groups[ groupIndex ].Results[ groupIndicies[ groupIndex ] ] );

groupIndicies[ groupIndex ]++;

}

foreach ( var ao in attackOrder )
Console.WriteLine( ao.ToString() );

}
}
}
```
```

I do not think the last bit is very efficient and I would appreciate it if someone could find a much simpler way of doing this.

Order each list individually using quicksort and then sort by insert into the final list.

``````Order the lists individually.
Create the empty Final list.

do
{
consider the first item in each of the sorted lists and find the highest ranking candidate.
remove the item from its sorted list and add it to the final list.
}
until all of the sorted lists are empty.
```
```