list遍历效率问题

Question

List<CharacteristicStat> listStat;
List<string> listTmp = new List<string>();
for (int i = 0; i < listStat.Count; i++)
{
if (!listTmp.Contains(listStat[i].TARGET_X))
{
listTmp.Add(listStat[i].TARGET_X);
}
}listStat中有1.5w条记录。我想把TARGET_X重复的过滤掉。这样操作要3秒左右，怎么样提高效率呢？

Answer 1

你先按照TARGET_X排序一下，然后
list[i].TARGET_X==list[i-1].TARGET_X反向遍历这样应该会快点吧因为不用去跟你的listTmp 比较了

Answer 2

int count=listStat.Count;
然后在循环中用count变量

Answer 3

1楼2楼馊主意，没楼主的方法好
建议楼主试试listTmp用hashtable类型

Answer 4

汗我只是改进下啊，循环中不用每次读写List的长度，这也馊主意么

Answer 5

Linq的实现，不过估计效果也不高9.Distinct形式：
说明：筛选字段中不相同的值。用于查询不重复的结果集。生成SQL语句为：SELECT DISTINCT [City] FROM [Customers]var q = (
    from c in db.Customers
    select c.City )
    .Distinct();
语句描述：查询顾客覆盖的国家。[/code]

Answer 6

用基类循环foreach(object obj in )
先定义一个int j=listStat.Count
再循环

Answer 7

indexof 好像比contains要快那么一点点。其实不改容器的话，没什么提高的余地了

Answer 8

.NET FrameWork 3.5 LINQ，楼主可以试下，不知道效率怎么样List<MA01.Model.RequestOrder> list_test = new List<MA01.Model.RequestOrder>();
list_test=list_test.Distinct<MA01.Model.RequestOrder>().ToList<MA01.Model.RequestOrder>();

Answer 9

List <CharacteristicStat> listStat; 
List <string> listTmp = new List <string>(); 
for (int i = 0; i < listStat.Count; i++) 
foreach(CharacteristicStat c in listStat)
{ 
if (!listTmp.Contains(c.TARGET_X)) 
{ 
     listTmp.Add(c.TARGET_X); 
} 
} 

Answer 10

再试试,不用 Contains方法,写个循环看看.List <CharacteristicStat> listStat; 
List <string> listTmp = new List <string>(); 
for (int i = 0; i < listStat.Count; i++) 
foreach(CharacteristicStat c in listStat)
{ 
if (!IsExists(listTmp,c.TARGET_X)) 
{ 
     listTmp.Add(c.TARGET_X); 
} 
} 
private bool IsExists(List <string> list,string str)
{
   for(int i=0;i<list.count;i++)
   {
         if(list[i]==str)
         {
            return true;
         }
   } 
   return false;
}

Answer 11

我觉得的还是可以了，不知道用LINQ试试会怎么样?

Answer 12

如果你使用了.NET3.5那么可以直接使用Linq，这个效率最高，代码如下：
1、实现接口
    public class ChEqualityComparer : IEqualityComparer<CharacteristicStat> {
        public bool Equals(CharacteristicStat x, CharacteristicStat y) {
            return x.TARGET_X == y.TARGET_X;
        }        public int GetHashCode(CharacteristicStat obj) {
            return obj.TARGET_X.GetHashCode();
        }
    }
2、调用方法：
List<CharacteristicStat> distinctArr = array.Distinct(new ChEqualityComparer()).ToList<CharacteristicStat>();如果你使用的是.NET 2.0则可以使用下面的方法：
1、实现接口
    public class ChComparer : IComparer<CharacteristicStat> {
        public int Compare(CharacteristicStat x, CharacteristicStat y) {
// 这里的比较规则由你自己实现，我假设他们都是整数
            int a = Convert.ToInt32(x.TARGET_X);
            int b = Convert.ToInt32(y.TARGET_X);
            return a - b;
        }
    }
2、调用方法：
    array.Sort(new ChComparer());
    for (int i = 0; i <= array.Count - 1; i++) {
        if (array[i].TARGET_X == array[i + 1].TARGET_X) {
            array.RemoveAt(i);
        }
    }

Answer 13

第二个方法的改进版本，可以使用迭代器来完成，代码如下：    // 定义一个迭代器，这里也可以通过实现接口IEnumerator
    public class DistinctIterator {        private List<CharacteristicStat> source;
        // 这里使用字典对象力求达到最快的查找速度
        private Dictionary<string, CharacteristicStat> duplicatedElement = new Dictionary<string, CharacteristicStat>();
        private int index = -1;        public DistinctIterator(List<CharacteristicStat> list) {
            this.source = list;
        }        public object Current {
            get {
                return this.source[index];
            }
        }        // 这里可以抽象为接口的方法由调用者提供实现
        private bool Duplicate(CharacteristicStat ch) {
            if (duplicatedElement.ContainsKey(ch.TARGET_X)) {
                return true;
            }
            else {
                duplicatedElement.Add(ch.TARGET_X, ch);
                return false;
            }
        }        public bool Move() {
            index++;
            if (!Duplicate(this.source[index])) {
                if (index < this.source.Count) {
                    return true;
                }
            }
            return false;
        }        public List<CharacteristicStat> ToList() {
            List<CharacteristicStat> list = new List<CharacteristicStat>();
            while (this.Move()) {
                list.Add((CharacteristicStat)this.Current);
            }
            return list;
        }
    }

调用代码如下：
List<CharacteristicStat> list = new DistinctIterator(array).ToList();

这三种方法效率差不多，没有明显的差异。

Answer 14

对 TARGET_X  进行排序
(排序算法, 比如二分法 比当前采用的重复的比较法效率应该会高很多的)
在排序过程中,去除重复的,并记录 i所有i的记录即为所需

Answer 15

如果lz你的集合里面的数据是不重复的话，强烈推荐你用HashSet<T>。速度绝对快

Answer 16

Contians方法比较费时， 2楼是最好的方法了。

Answer 17

lz 目前采用的方法  比较次数为  1.5W!  采用排序方式,  1.5W条数据排序需要 比较次数为  二分法约为 lg1.5W排序过程中可以去除重复的i明显不是一个数量级别的  

Answer 18

采用排序方式,  1.5W条数据排序需要 比较次数为  二分法小于 lg1.5W * 1.5w

Answer 19

以前做一个词库合并工具的遇到这个问题。
楼主干脆用linq 的过滤重复数据的语法算了，瞬间能够完成。如果打算用.net 2.0来解决，不设计高超算法的情况下。每次添加一个值马上把listStat集合里面的的刚才的值删除。
listStat.RemoveAll(delegate(string X) { return X == 值; });
List <CharacteristicStat> listStat; 
List <string> listTmp = new List <string>(); 
foreach(CharacteristicStat C in listStat)
{
   listTmp.add( C.TARGET_X);
   listStat.RemoveAll(delegate(string X) { return X == C.TARGET_X; });
}

Answer 20

 listStat 集合越来越小，后面的速度越来越快。RemoveAll 的次数大幅小于Contains 的次数。性能应该明显高于你原先的代码。

Answer 21

List<string> distinctCharacteristicStat(List<CharacteristicStat> listStat) {
List<string> result = new List<string>();
Dictionary<string, bool> d = new Dictionary<string, bool>();
foreach (CharacteristicStat ch in listStat) {
if (d.ContainsKey(ch.TARGET_X) == false) {
d.Add(ch.TARGET_X, true);
result.Add(ch.TARGET_X);
}
}
return result;
}

Answer 22

z415353144
你好，是ASP.NET的高手！

Answer 23

有没有ASP.NET的高手？
我现在遇到一种情况，在当前也显示的从数据库读出的表能否保存为word？