Phương pháp LINQ để sắp xếp danh sách dựa trên danh sách lớn hơn

Question

List<int> _lstNeedToOrder = new List<int>(); 
_lstNeedToOrder.AddRange(new int[] { 1, 5, 6, 8 }); 

//I need to sort this based on the below list. 

List<int> _lstOrdered = new List<int>();//to order by this list 
_lstOrdered.AddRange(new int[] { 13, 5, 11, 1, 4, 9, 2, 7, 12, 10, 3, 8, 6 }); 

order will be -->_lstNeedToOrder = 5,1,8,6 

Tôi có thể làm như thế nào?

Answer 1

Vâng đơn giản - nhưng không hiệu quả - cách sẽ là:

var result = _lstNeedToOrder.OrderBy(x => _lstOrdered.IndexOf(x)); 

Một thay thế sẽ được làm việc ra một cách xa có được chỉ số mong muốn của một giá trị. Nếu giá trị của bạn luôn nằm trong phạm vi [1 ... n], bạn có thể đảo ngược danh sách "đã sắp xếp" đó thành "danh sách chỉ mục theo giá trị". Lúc này bạn có thể sử dụng:

var result = _lstNeedToOrder.OrderBy(x => indexes[x]); 

(nơi indexes sẽ có một giá trị thêm vào lúc bắt đầu cho 0, chỉ để làm cho mọi việc đơn giản hơn).

Hoặc, bạn có thể tạo Dictionary<int, int> từ giá trị đến chỉ mục. Đó sẽ là tổng quát hơn, trong đó nó sẽ xử lý một phạm vi rất rộng các giá trị mà không cần tốn nhiều bộ nhớ. Nhưng tra cứu từ điển rõ ràng là kém hiệu quả hơn so với tra cứu mảng hoặc danh sách.

Cũng giống như một lưu ý bên đó sẽ không định dạng cũng như nhận xét, khởi tạo của bạn có thể được đơn giản hóa bằng cách sử dụng khởi tạo bộ sưu tập:

var listToOrder = new List<int> { 1, 5, 6, 8 }; 
var orderedList = new List<int> { 13, 5, 11, 1, 4, 9, 2, 7, 12, 10, 3, 8, 6 }; 

Answer 2

List<int> results = _lstOrdered.Where(item => _lstNeedToOrder.Contains(item)).ToList(); 

Answer 3

tiết kiệm trong một từ điển trung gian thứ tự ...

// dict key will be the values of _lstOrdered, value will be the index of the 
// key in _lstOrdered 
// I'm using a seldom used .Select overload that returns the current value 
// plus its index (ix) 
var dict = _lstOrdered.Select((p, ix) => new { Value = p, Ix = ix }) 
         .ToDictionary(p => p.Value, p => p.Ix); 

// note that this will explode if _lstNeedToOrder contains values outside 
// _lstOrdered. 
_lstNeedToOrder.Sort((p, q) => dict[p] - dict[q]); 

Các .Sort cả các loại phương pháp tại chỗ để _lstNeedToOrder sẽ được đặt hàng.

Answer 4

Bạn có thể xây dựng một comparer tùy chỉnh như thế này:

public class SequenceComparer<T> : IComparer<T> { 
    private readonly Dictionary<T, int> indexes; 

    public SequenceComparer(IEnumerable<T> sequence) { 
     this.indexes = 
      sequence 
       .Select((item, index) => new { Item = item, Index = index }) 
       .ToDictionary(x => x.Item, x => x.Index); 
    } 

    public int Compare(T x, T y) { 
     return indexes[x].CompareTo(indexes[y]); 
    } 
} 

Bây giờ bạn có thể nói

var result = _lstNeedToOrder.OrderBy(x => x, new SequenceComparer(_lstOrdered)); 

Answer 5

này hoạt động khá tốt:

var lookup = _lstOrdered 
    .Select((x, n) => new { x, n }) 
    .ToLookup(x => x.x, x => x.n); 

var query = 
    from x in _lstNeedToOrder 
    let rank = lookup[x] 
     .DefaultIfEmpty(int.MaxValue) 
     .First() 
    orderby rank 
    select x; 

Answer 6

Một lựa chọn khác là sử dụng Intersect, đảm bảo trả về các phần tử theo thứ tự xuất hiện trong chuỗi đầu tiên.

Vì vậy, trong ví dụ này

var result = _lstOrdered.Intersect(_lstNeedToOrder); 

mang { 5, 1, 8, 6} theo yêu cầu.