相关疑难解决方法(0)

什么时候使用List vs LinkedList更好？

我需要一个快速算法从通用列表中选择5个随机元素.例如,我想从a获得5个随机元素List<string>.

有没有在C#中创建动态数组的方法？

我总是被告知在数组中添加元素的方式如下:

创建数组+ 1element的空副本,然后将原始数组中的数据复制到其中,然后加载新元素的新数据

如果这是真的,那么由于内存和CPU利用率的原因,在需要大量元素活动的场景中使用数组是正确的,对吗？

如果是这种情况,你是否应该尽量避免在添加大量元素时尽可能多地使用数组？你应该使用iStringMap吗？如果是这样,如果您需要两个以上的维度并且需要添加大量元素添加,会发生什么.你刚刚受到性能打击还是应该使用其他东西？

我在C#中实现了一个quicksort版本,并执行了一些快速基准来与C#进行比较List<T>.Sort.我发现我的实现比库版本慢得多.我想知道为什么.这是一些粗略的基准数字.对于输入,我使用了一个随机(均匀)生成的整数列表,其中包含很少的重复元素.请注意,所有基准时间均为多次运行的平均值.

100,000 elements
My code         0.096 seconds
List<T>.Sort    0.011 seconds

1,000,000 elements
My code         1.10 seconds
List<T>.Sort    0.14 seconds

我的代码如下.以下是我尝试过的优化列表及其结果:

• 在线 - 我试图在线Swap和 我的ChoosePivotIndex功能内嵌,我看到了大约10%的改进.
• 枢轴选择 - 我知道我正在使用天真的枢轴选择方法.我也试过使用三个随机元素的中位数.这并没有带来太大的改善.我猜这是因为我用于基准测试的输入数据是均匀随机的.
• 并行性 - 我尝试并行进行递归分区调用.这似乎实际上增加了执行时间.
• 特殊外壳小输入 - 我已经尝试切换到小输入的插入排序(如List<T>.Sort声称做).这产生了大约20%的改善.

通过这些优化的组合,我已经能够将我的代码降低到

100,000 elements -   0.062 seconds
1,000,000 elements - 0.740 seconds 

这仍然比库Sort慢得多.在我的代码中有没有明显的解释性能差距,或者是从更小的调整中剩下的70-80%的差距？请注意,下面的代码是我未经优化的基础版本

public class Quicksorter<T> where T : IComparable<T>
{
    protected Random random;
    public Quicksorter()
    {
        random = new Random();
    }

    public void Sort(IList<T> …

考虑以下代码：

using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace ListAllocationPerformance
{
    class Program
    {
        const int count = 100000000;

        public static object Memory { get; private set; }

        static void Main(string[] args)
        {
            Console.WriteLine(string.Format("count: {0}", count));
            MeasureFunction(FillListWithoutAllocation, "without allocation");
            MeasureFunction(FillListWithAllocation, "with allocation");
            MeasureFunction(FillArray, "array");
            MeasureFunction(FillUnmanagedArray, "unsafe array");
            string input = Console.ReadLine();
        }

        static void MeasureFunction(Action function, string name)
        {
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            function();
            stopwatch.Stop();
            Console.WriteLine(string.Format("Function {0} finished after \t {1}ms", name, stopwatch.ElapsedMilliseconds, count));
        }

        static void FillListWithoutAllocation()
        { …

我有一个包含一些基本类型的类.(3x float,2x int).

现在我需要一个可以容纳这个类的数百万个实例的集合.我不需要派生类型.所有元素都完全来自这个单独的类.更多元素的数量是固定的.在极少数情况下,我计划复制整个列表/数组并修改副本.最初的列表/数组应该是不可变的,因此我不需要与其他线程同步.

现在的问题是:

• 我是从数组而不是列表中受益吗？
• 我是否使用数组保存内存？
• 速度怎么样？

我读到C#中的List也在内部实现为Array.

如果它是C++,我知道数组将保存完整的对象.但我不确定C#如何处理这个问题.C#数组是仅保存对类实例的引用还是保存完整的数据结构？

我在C#中为SharePoint webpart做一些自定义代码.具体来说,我正在进行测验,我的主要观点是解决问题清单,答案选择和正确答案.

在测验的最后阶段,我需要检查用户根据列表中的正确答案选择的答案.目前,我正在做以下检查是否每个都是正确的,我假设它不是很有效,因为它遍历每个问题.是否有一种方法,特别是对于SPList foreach循环,哪种方法更有效？

                // 1. Store questions and answers in class
                    List<submittedAnswers> answeredQuestions = new List<submittedAnswers>();

                // 2. From POST pull answered question IDs and answer IDs (which correspond to the question primary key and answer choice number both stored in the list)
                    // INSERT BEAUTFIUL AND EFFICIENT WHILE LOOP HERE

                // 3. Loop through each question is list, if question was given, test if correct/incorrect
                using (SPWeb myWeb = mySite.OpenWeb())
                {
                    SPList answerList = myWeb.Lists[questionList];
                    foreach (SPListItem quizEntry …

Visual Studio 在IEnumerable. 然后我添加ToList()它。但我开始想知道为什么这是一个不好的做法。

那么为什么多次枚举不好呢？

可能重复:
数组与列表<T>:何时使用哪个？

嗨,大家好,

这可能是一个非常简单的问题,但由于我刚刚开始,希望你不介意回答.

使用列表与数组时是否有任何最佳实践或经验法则？例如,我正在关注的教程使用数组来保存一些数据,他总是说"哦,一个40的数组就足够了,因为我永远不会使用更多.

但是,我已经将他的数组换成了Lists.这样,列表的大小可以根据我的运行时需求进行调整,它还允许我使用IEnumerable迭代器,这样我就可以用于每个循环.

那么,使用List有没有缩小尺寸？我猜测它比使用数组更受性能影响,但它有意义吗？我应该更频繁地尝试使用数组,还是使用列表,如果我发现性能问题,只使用数组？

感谢您的输入!