ลบรายการซ้ำออกจากรายการ <T> ใน C #

ทุกคนมีวิธีที่รวดเร็วสำหรับการยกเลิกการทำรายการทั่วไปใน C # หรือไม่

บางทีคุณควรพิจารณาใช้HashSet

จากลิงก์ MSDN:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> evenNumbers = new HashSet<int>();
        HashSet<int> oddNumbers = new HashSet<int>();

        for (int i = 0; i < 5; i++)
        {
            // Populate numbers with just even numbers.
            evenNumbers.Add(i * 2);

            // Populate oddNumbers with just odd numbers.
            oddNumbers.Add((i * 2) + 1);
        }

        Console.Write("evenNumbers contains {0} elements: ", evenNumbers.Count);
        DisplaySet(evenNumbers);

        Console.Write("oddNumbers contains {0} elements: ", oddNumbers.Count);
        DisplaySet(oddNumbers);

        // Create a new HashSet populated with even numbers.
        HashSet<int> numbers = new HashSet<int>(evenNumbers);
        Console.WriteLine("numbers UnionWith oddNumbers...");
        numbers.UnionWith(oddNumbers);

        Console.Write("numbers contains {0} elements: ", numbers.Count);
        DisplaySet(numbers);
    }

    private static void DisplaySet(HashSet<int> set)
    {
        Console.Write("{");
        foreach (int i in set)
        {
            Console.Write(" {0}", i);
        }
        Console.WriteLine(" }");
    }
}

/* This example produces output similar to the following:
 * evenNumbers contains 5 elements: { 0 2 4 6 8 }
 * oddNumbers contains 5 elements: { 1 3 5 7 9 }
 * numbers UnionWith oddNumbers...
 * numbers contains 10 elements: { 0 2 4 6 8 1 3 5 7 9 }
 */

หากคุณใช้. Net 3+ คุณสามารถใช้ Linq

List<T> withDupes = LoadSomeData();
List<T> noDupes = withDupes.Distinct().ToList();

เกี่ยวกับ:

var noDupes = list.Distinct().ToList();

ใน. net 3.5

เพียงเริ่มต้น HashSet ด้วยรายการประเภทเดียวกัน:

var noDupes = new HashSet<T>(withDupes);

หรือถ้าคุณต้องการส่งคืนรายการ:

var noDupsList = new HashSet<T>(withDupes).ToList();

เรียงลำดับจากนั้นตรวจสอบสองและสองถัดจากกันและกันเนื่องจากรายการที่ซ้ำกันจะรวมกันเป็นกลุ่ม

บางสิ่งเช่นนี้

list.Sort();
Int32 index = list.Count - 1;
while (index > 0)
{
    if (list[index] == list[index - 1])
    {
        if (index < list.Count - 1)
            (list[index], list[list.Count - 1]) = (list[list.Count - 1], list[index]);
        list.RemoveAt(list.Count - 1);
        index--;
    }
    else
        index--;
}

หมายเหตุ:

• ทำการเปรียบเทียบจากหลังไปข้างหน้าเพื่อหลีกเลี่ยงรายการรีสอร์ทหลังจากการลบแต่ละครั้ง
• ตัวอย่างนี้ใช้ Tuples มูลค่า C # เพื่อทำการแลกเปลี่ยนโดยแทนที่ด้วยรหัสที่เหมาะสมหากคุณไม่สามารถใช้มันได้
• ผลลัพธ์สุดท้ายจะไม่ถูกจัดเรียงอีกต่อไป

ฉันชอบที่จะใช้คำสั่งนี้:

List<Store> myStoreList = Service.GetStoreListbyProvince(provinceId)
                                                 .GroupBy(s => s.City)
                                                 .Select(grp => grp.FirstOrDefault())
                                                 .OrderBy(s => s.City)
                                                 .ToList();

ฉันมีเขตข้อมูลเหล่านี้ในรายการของฉัน: รหัส, ชื่อร้านค้า, เมือง, รหัสไปรษณีย์ฉันต้องการแสดงรายการเมืองในรายการแบบเลื่อนลงซึ่งมีค่าซ้ำกัน วิธีแก้ปัญหา: จัดกลุ่มตามเมืองจากนั้นเลือกรายการแรกสำหรับรายการ

ฉันหวังว่ามันจะช่วย :)

มันใช้งานได้สำหรับฉัน เพียงใช้

List<Type> liIDs = liIDs.Distinct().ToList<Type>();

แทนที่ "Type" ด้วยประเภทที่คุณต้องการเช่น int

ตามที่ kronoz กล่าวใน. Net 3.5 คุณสามารถใช้ Distinct()คุณสามารถใช้

ใน. Net 2 คุณสามารถเลียนแบบได้:

public IEnumerable<T> DedupCollection<T> (IEnumerable<T> input) 
{
    var passedValues = new HashSet<T>();

    // Relatively simple dupe check alg used as example
    foreach(T item in input)
        if(passedValues.Add(item)) // True if item is new
            yield return item;
}

สิ่งนี้สามารถใช้เพื่อหักล้างการสะสมใด ๆ และจะคืนค่าในลำดับเดิม

ปกติแล้วมันจะเร็วกว่ามากในการกรองคอลเลกชัน (ทั้งคู่Distinct()และตัวอย่างนี้) กว่าจะเป็นการลบไอเท็มออกจากมัน

วิธีการขยายอาจเป็นวิธีที่เหมาะสมในการไป ... บางสิ่งเช่นนี้:

public static List<T> Deduplicate<T>(this List<T> listToDeduplicate)
{
    return listToDeduplicate.Distinct().ToList();
}

จากนั้นเรียกสิ่งนี้เช่น:

List<int> myFilteredList = unfilteredList.Deduplicate();

ใน Java (ฉันถือว่า C # เหมือนกันมากหรือน้อย):

list = new ArrayList<T>(new HashSet<T>(list))

หากคุณต้องการที่จะกลายพันธุ์รายการเดิม:

List<T> noDupes = new ArrayList<T>(new HashSet<T>(list));
list.clear();
list.addAll(noDupes);

เพื่อรักษาคำสั่งซื้อเพียงแทนที่ HashSet ด้วย LinkedHashSet

สิ่งนี้ใช้เวลาที่แตกต่าง (องค์ประกอบโดยไม่ต้องทำซ้ำองค์ประกอบ) และแปลงเป็นรายการอีกครั้ง:

List<type> myNoneDuplicateValue = listValueWithDuplicate.Distinct().ToList();

ใช้ Linq ของสหภาพวิธี

หมายเหตุ: วิธีนี้ไม่จำเป็นต้องมีความรู้เกี่ยวกับ Linq นอกเหนือจากที่มีอยู่

รหัส

เริ่มต้นด้วยการเพิ่มสิ่งต่อไปนี้ที่ด้านบนของไฟล์คลาสของคุณ:

using System.Linq;

ตอนนี้คุณสามารถใช้สิ่งต่อไปนี้เพื่อลบรายการที่ซ้ำกันออกจากวัตถุที่เรียกว่าobj1:

obj1 = obj1.Union(obj1).ToList();

หมายเหตุ: เปลี่ยนชื่อobj1เป็นชื่อวัตถุของคุณ

มันทำงานอย่างไร

1. คำสั่ง Union แสดงรายการหนึ่งในแต่ละรายการของวัตถุต้นทางสองรายการ เนื่องจาก obj1 เป็นทั้งวัตถุต้นทางสิ่งนี้จะลด obj1 ให้เป็นหนึ่งในแต่ละรายการ

2. ToList()ส่งกลับรายการใหม่ นี่เป็นสิ่งจำเป็นเนื่องจากคำสั่ง Linq ต้องการUnionส่งคืนผลลัพธ์เป็นผลลัพธ์ IEnumerable แทนการแก้ไขรายการดั้งเดิมหรือส่งคืนรายการใหม่

เป็นวิธีการช่วยเหลือ (ไม่มี Linq):

public static List<T> Distinct<T>(this List<T> list)
{
    return (new HashSet<T>(list)).ToList();
}

หากคุณไม่สนใจเกี่ยวกับการสั่งซื้อคุณก็สามารถผลักรายการที่เป็นHashSetถ้าคุณไม่ต้องการที่จะรักษาความสงบเรียบร้อยที่คุณสามารถทำอะไรเช่นนี้

var unique = new List<T>();
var hs = new HashSet<T>();
foreach (T t in list)
    if (hs.Add(t))
        unique.Add(t);

หรือวิธี Linq:

var hs = new HashSet<T>();
list.All( x =>  hs.Add(x) );

แก้ไข:HashSetวิธีคือO(N)เวลาและO(N)พื้นที่ในขณะที่การเรียงลำดับและแล้วทำให้ไม่ซ้ำกัน (แนะนำโดย @ lassevkและอื่น ๆ ) เป็นO(N*lgN)เวลาและO(1)พื้นที่จึงไม่ให้ชัดเจนกับผม (ที่มันเป็นได้อย่างรวดเร็วก่อน) ว่าวิธีการเรียงลำดับรองลงมาคือ (ของฉัน ขอโทษสำหรับการลงคะแนนเสียงชั่วคราว ... )

นี่คือวิธีการขยายสำหรับการลบรายการที่ซ้ำกันที่อยู่ติดกันในแหล่งกำเนิด Call Sort () ก่อนและผ่านใน IComparer เดียวกัน สิ่งนี้ควรมีประสิทธิภาพมากกว่าเวอร์ชันของ Lasse V. Karlsen ที่เรียก RemoveAt ซ้ำ ๆ (ส่งผลให้เกิดการเคลื่อนย้ายหน่วยความจำบล็อกหลาย ๆ ครั้ง)

public static void RemoveAdjacentDuplicates<T>(this List<T> List, IComparer<T> Comparer)
{
    int NumUnique = 0;
    for (int i = 0; i < List.Count; i++)
        if ((i == 0) || (Comparer.Compare(List[NumUnique - 1], List[i]) != 0))
            List[NumUnique++] = List[i];
    List.RemoveRange(NumUnique, List.Count - NumUnique);
}

การติดตั้งแพ็คเกจMoreLINQผ่านทาง Nuget คุณสามารถแยกแยะรายการวัตถุได้โดยง่าย

IEnumerable<Catalogue> distinctCatalogues = catalogues.DistinctBy(c => c.CatalogueCode); 

อาจจะง่ายกว่าเพื่อให้แน่ใจว่าจะไม่เพิ่มรายการที่ซ้ำกันลงในรายการ

if(items.IndexOf(new_item) < 0) 
    items.add(new_item)

คุณสามารถใช้ยูเนี่ยน

obj2 = obj1.Union(obj1).ToList();

อีกวิธีหนึ่งใน. Net 2.0

    static void Main(string[] args)
    {
        List<string> alpha = new List<string>();

        for(char a = 'a'; a <= 'd'; a++)
        {
            alpha.Add(a.ToString());
            alpha.Add(a.ToString());
        }

        Console.WriteLine("Data :");
        alpha.ForEach(delegate(string t) { Console.WriteLine(t); });

        alpha.ForEach(delegate (string v)
                          {
                              if (alpha.FindAll(delegate(string t) { return t == v; }).Count > 1)
                                  alpha.Remove(v);
                          });

        Console.WriteLine("Unique Result :");
        alpha.ForEach(delegate(string t) { Console.WriteLine(t);});
        Console.ReadKey();
    }

มีหลายวิธีในการแก้ไข - ปัญหาที่ซ้ำกันในรายการด้านล่างเป็นหนึ่งในนั้น:

List<Container> containerList = LoadContainer();//Assume it has duplicates
List<Container> filteredList = new  List<Container>();
foreach (var container in containerList)
{ 
  Container duplicateContainer = containerList.Find(delegate(Container checkContainer)
  { return (checkContainer.UniqueId == container.UniqueId); });
   //Assume 'UniqueId' is the property of the Container class on which u r making a search

    if(!containerList.Contains(duplicateContainer) //Add object when not found in the new class object
      {
        filteredList.Add(container);
       }
  }

เชียร์ Ravi Ganesan

นี่เป็นวิธีง่ายๆที่ไม่ต้องการ LINQ ที่อ่านยากหรือการเรียงลำดับรายการก่อนหน้า

   private static void CheckForDuplicateItems(List<string> items)
    {
        if (items == null ||
            items.Count == 0)
            return;

        for (int outerIndex = 0; outerIndex < items.Count; outerIndex++)
        {
            for (int innerIndex = 0; innerIndex < items.Count; innerIndex++)
            {
                if (innerIndex == outerIndex) continue;
                if (items[outerIndex].Equals(items[innerIndex]))
                {
                    // Duplicate Found
                }
            }
        }
    }

คำตอบของ David J. เป็นวิธีการที่ดีไม่จำเป็นต้องมีวัตถุพิเศษการเรียงลำดับ ฯลฯ อย่างไรก็ตามสามารถปรับปรุงได้ใน:

for (int innerIndex = items.Count - 1; innerIndex > outerIndex ; innerIndex--)

ดังนั้นวงนอกจะไปด้านล่างสุดสำหรับรายการทั้งหมด แต่วงด้านในไปด้านล่าง "จนกว่าจะถึงตำแหน่งวงด้านนอก"

วนรอบด้านนอกทำให้แน่ใจว่ารายการทั้งหมดได้รับการประมวลผลแล้ววงด้านในจะค้นหารายการที่ซ้ำกันจริงซึ่งเกิดขึ้นได้เฉพาะในส่วนที่วงรอบนอกยังไม่ได้ประมวลผล

หรือถ้าคุณไม่ต้องการลงล่างสำหรับวงในคุณอาจเริ่มวนรอบด้านในที่ outerIndex + 1

คำตอบทั้งหมดคัดลอกรายการหรือสร้างรายการใหม่หรือใช้ฟังก์ชั่นช้าหรือเพียงช้าอย่างเจ็บปวด

เพื่อความเข้าใจของฉันนี่เป็นวิธีที่เร็วที่สุดและถูกที่สุดที่ฉันรู้ (เช่นกันซึ่งได้รับการสนับสนุนจากโปรแกรมเมอร์ที่มีประสบการณ์สูงซึ่งเชี่ยวชาญด้านการเพิ่มประสิทธิภาพฟิสิกส์ตามเวลาจริง)

// Duplicates will be noticed after a sort O(nLogn)
list.Sort();

// Store the current and last items. Current item declaration is not really needed, and probably optimized by the compiler, but in case it's not...
int lastItem = -1;
int currItem = -1;

int size = list.Count;

// Store the index pointing to the last item we want to keep in the list
int last = size - 1;

// Travel the items from last to first O(n)
for (int i = last; i >= 0; --i)
{
    currItem = list[i];

    // If this item was the same as the previous one, we don't want it
    if (currItem == lastItem)
    {
        // Overwrite last in current place. It is a swap but we don't need the last
       list[i] = list[last];

        // Reduce the last index, we don't want that one anymore
        last--;
    }

    // A new item, we store it and continue
    else
        lastItem = currItem;
}

// We now have an unsorted list with the duplicates at the end.

// Remove the last items just once
list.RemoveRange(last + 1, size - last - 1);

// Sort again O(n logn)
list.Sort();

ราคาสุดท้ายคือ:

nlogn + n + nlogn = n + 2nlogn = O (nlogn)ซึ่งค่อนข้างดี

หมายเหตุเกี่ยวกับ RemoveRange: เนื่องจากเราไม่สามารถกำหนดจำนวนรายการและหลีกเลี่ยงการใช้ funcions ลบได้ฉันไม่ทราบความเร็วของการดำเนินการนี้อย่างแน่นอน แต่ฉันคิดว่ามันเป็นวิธีที่เร็วที่สุด

หากคุณมีชั้นเรียนพ่วงProductและCustomerและเราต้องการที่จะลบรายการที่ซ้ำกันจากรายการของพวกเขา

public class Product
{
    public int Id { get; set; }
    public string ProductName { get; set; }
}

public class Customer
{
    public int Id { get; set; }
    public string CustomerName { get; set; }

}

คุณต้องกำหนดคลาสทั่วไปในแบบฟอร์มด้านล่าง

public class ItemEqualityComparer<T> : IEqualityComparer<T> where T : class
{
    private readonly PropertyInfo _propertyInfo;

    public ItemEqualityComparer(string keyItem)
    {
        _propertyInfo = typeof(T).GetProperty(keyItem, BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Public);
    }

    public bool Equals(T x, T y)
    {
        var xValue = _propertyInfo?.GetValue(x, null);
        var yValue = _propertyInfo?.GetValue(y, null);
        return xValue != null && yValue != null && xValue.Equals(yValue);
    }

    public int GetHashCode(T obj)
    {
        var propertyValue = _propertyInfo.GetValue(obj, null);
        return propertyValue == null ? 0 : propertyValue.GetHashCode();
    }
}

จากนั้นคุณสามารถลบรายการที่ซ้ำกันในรายการของคุณ

var products = new List<Product>
            {
                new Product{ProductName = "product 1" ,Id = 1,},
                new Product{ProductName = "product 2" ,Id = 2,},
                new Product{ProductName = "product 2" ,Id = 4,},
                new Product{ProductName = "product 2" ,Id = 4,},
            };
var productList = products.Distinct(new ItemEqualityComparer<Product>(nameof(Product.Id))).ToList();

var customers = new List<Customer>
            {
                new Customer{CustomerName = "Customer 1" ,Id = 5,},
                new Customer{CustomerName = "Customer 2" ,Id = 5,},
                new Customer{CustomerName = "Customer 2" ,Id = 5,},
                new Customer{CustomerName = "Customer 2" ,Id = 5,},
            };
var customerList = customers.Distinct(new ItemEqualityComparer<Customer>(nameof(Customer.Id))).ToList();

รหัสนี้ลบรายการที่ซ้ำกันโดยIdถ้าคุณต้องการลบรายการที่ซ้ำกันโดยคุณสมบัติอื่น ๆ คุณสามารถเปลี่ยนnameof(YourClass.DuplicateProperty) เหมือนกันnameof(Customer.CustomerName)แล้วลบรายการที่ซ้ำกันตามCustomerNameคุณสมบัติ

  public static void RemoveDuplicates<T>(IList<T> list )
  {
     if (list == null)
     {
        return;
     }
     int i = 1;
     while(i<list.Count)
     {
        int j = 0;
        bool remove = false;
        while (j < i && !remove)
        {
           if (list[i].Equals(list[j]))
           {
              remove = true;
           }
           j++;
        }
        if (remove)
        {
           list.RemoveAt(i);
        }
        else
        {
           i++;
        }
     }  
  }

การใช้งานง่ายที่เรียบง่าย:

public static List<PointF> RemoveDuplicates(List<PointF> listPoints)
{
    List<PointF> result = new List<PointF>();

    for (int i = 0; i < listPoints.Count; i++)
    {
        if (!result.Contains(listPoints[i]))
            result.Add(listPoints[i]);
        }

        return result;
    }