`
索菲亚．　　ぅ
  • 浏览: 16609 次
  • 性别: Icon_minigender_2
  • 来自: 北京
最近访客 更多访客>>
社区版块
存档分类
最新评论

4.24学习笔记

    博客分类：
  • NET
CC++C#LinqUI 
阅读更多

C#中
数组长度表示用.length;
arraylist集合中对象个数表示用.count;

 

c#数组的声明方式

int[] intArray;
int[] intArray = {99,34,56,12,1};
int[] intArray = new int[5];
int[] intArray = new int[varsize];
int[] intArray = new int[5]{99,34,56,12,1};

 

从旧数组复制到新数组，2表示新数组开始位置

oldArray.CopyTo(newArray, 2);

 循环迭代出Hashtable中对象
错误：

foreach(Person  p in peopleHashtable) // Will compile but not run!
{
    Response.Write(p.FullName + "<BR/>");
}

 正确：

foreach (DictionaryEntry de in peopleHashtable)
{
    Response.Write(de.Key.ToString() + ":" + ((Person)de.Value).FullName + 
       "<BR/>");
}

 

 

SortedList

1创建空的SortedList
2手动迭代Hashtable的DictionaryEntry（Hashtable是无须存放的）
3把它们添加到SortedList（添加过程中自动排序）
实例：
SortedList peopleSortedList = new SortedList(peopleHashtable);
foreach (Person p in peopleSortedList.Values)
{
    Response.Write(p.FullName + "<BR/>");
}
Response.Write("Index of Srinivasa: " + peopleSortedList.IndexOfKey("ss"));

 

Queues适合于按照对象进入的顺序来存储它们（先进先出），

而Stack是一个先进后出结构。

但要取的话必须删一个取一个

 

BitArray
管理一个布尔值数组或者集合使用

 


强类型化的集合如PersonList类
注意：强制类型转换隐藏在了属性访问器中，属性的返回值是强类型化的。（这里this是C#属性访问器的关键字）

 

using System;
using System.Data;
using System.Configuration;
using System.Linq;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Linq;

using System.Collections;

/// <summary>
///PersonList 的摘要说明
/// </summary>
public class PersonList:System.Collections.IEnumerable
{
 public PersonList()
 {
  //
  //TODO: 在此处添加构造函数逻辑
  //
 }
    private ArrayList innerList = new ArrayList();

    public void Add(Person aPerson)
    {
        innerList.Add(aPerson);
    }

    public void Remove(Person aPerson)
    {
        innerList.Remove(aPerson);
    }

    public int Count
    {
        get
        {
            return innerList.Count;
        }
    }

    //Get/Set element at given index
    public Person this[int index]
    {
        get 
        {
            return (Person)innerList[index];
        }
        set
        {
            innerList[index] = value;
        }
    }

    public IEnumerator GetEnumerator()
    {
        return innerList.GetEnumerator();
    }
}

 

 泛型的Hashtable 和Hashtable区别，读取的时候不需要强制类型转化

 

LinkedList<T>是一个强类型化的双链接表，该链接表中的每个节点都指向前一个节点和后一个节点

 

 问题：谁能帮我讲解下BinarySearch方法？小女谢谢了。。

分享到：
| ASP.NET 页面事件顺序和生命周期
评论
4 楼 尔今尔后 2012-02-03  
小女子 姿色不错呀~·~~
3 楼 kimmking 2009-04-29  
<div class="quote_title">索菲亚．　　ぅ 写道</div><div class="quote_div"><div class="quote_title">kimmking 写道</div>
<div class="quote_div">
<pre name="code" class="c#"> ArrayList的binary search：
</pre>
<pre name="code" class="c#">// Searches a section of the list for a given element using a binary search
        // algorithm. Elements of the list are compared to the search value using
        // the given IComparer interface. If comparer is null, elements of
        // the list are compared to the search value using the IComparable
        // interface, which in that case must be implemented by all elements of the
        // list and the given search value. This method assumes that the given
        // section of the list is already sorted; if this is not the case, the
        // result will be incorrect.
        //
        // The method returns the index of the given value in the list. If the
        // list does not contain the given value, the method returns a negative
        // integer. The bitwise complement operator (~) can be applied to a
        // negative result to produce the index of the first element (if any) that
        // is larger than the given search value. This is also the index at which
        // the search value should be inserted into the list in order for the list
        // to remain sorted.
        //
        // The method uses the Array.BinarySearch method to perform the
        // search.
        //
        public virtual int BinarySearch(int index, int count, Object value, IComparer comparer) {
            if (index &lt; 0 || count &lt; 0)
                throw new ArgumentOutOfRangeException((index&lt;0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            if (_size - index &lt; count)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
   
            return Array.BinarySearch((Array)_items, index, count, value, comparer);
        }
</pre>
<p> </p>
<p> </p>
<p>Array的：</p>
<pre name="code" class="c#">[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int BinarySearch(Array array, int index, int length, Object value, IComparer comparer) {
            if (array==null)
                throw new ArgumentNullException("array");
            int lb = array.GetLowerBound(0);
            if (index &lt; lb || length &lt; 0)
                throw new ArgumentOutOfRangeException((index&lt;lb ? "index" : "length"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            if (array.Length - (index - lb) &lt; length)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
            if (array.Rank != 1)
                throw new RankException(Environment.GetResourceString("Rank_MultiDimNotSupported"));
           
            if (comparer == null) comparer = Comparer.Default;
            if (comparer == Comparer.Default) {
                int retval;
                bool r = TrySZBinarySearch(array, index, length, value, out retval);
                if (r)
                    return retval;
            }

            int lo = index;
            int hi = index + length - 1;  
            Object[] objArray = array as Object[];
            if(objArray != null) {
                while (lo &lt;= hi) {
                    // i might overflow if lo and hi are both large positive numbers.
                    int i = GetMedian(lo, hi);

                    int c;
                    try {
                        c = comparer.Compare(objArray[i], value);
                    }
                    catch (Exception e) {
                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"), e);
                    }
                    catch {
                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"));
                    }
                    if (c == 0) return i;
                    if (c &lt; 0) {
                        lo = i + 1;
                    }
                    else {
                        hi = i - 1;
                    }
                }
            }
            else {
                while (lo &lt;= hi) {
                    int i = GetMedian(lo, hi);                   

                    int c;
                    try {
                        c = comparer.Compare(array.GetValue(i), value);
                    }
                    catch (Exception e) {
                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"), e);
                    }
                    catch {
                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"));
                    }
                    if (c == 0) return i;
                    if (c &lt; 0) {
                        lo = i + 1;
                    }
                    else {
                        hi = i - 1;
                    }
                }
            }
            return ~lo;
        }
</pre>
<p> </p>
<p>总的来说，就是二分法来查找元素，如果使用此方法前没有排序，或是查找的比较方式和排序的比较方式不一样的话，结果可能找不到。</p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
</div>
<p><br>谢谢昂。····多用在什么时候呢？</p></div><br/>用在已经排序过了的时候，特别是数据量比较大的时候，可以提高查找效率。

一般不用，也许你一辈子用不着。


----mm加我qq  3694826
2 楼 索菲亚．　　ぅ 2009-04-29  
<div class="quote_title">kimmking 写道</div>
<div class="quote_div">
<pre name="code" class="c#"> ArrayList的binary search：
</pre>
<pre name="code" class="c#">// Searches a section of the list for a given element using a binary search
        // algorithm. Elements of the list are compared to the search value using
        // the given IComparer interface. If comparer is null, elements of
        // the list are compared to the search value using the IComparable
        // interface, which in that case must be implemented by all elements of the
        // list and the given search value. This method assumes that the given
        // section of the list is already sorted; if this is not the case, the
        // result will be incorrect.
        //
        // The method returns the index of the given value in the list. If the
        // list does not contain the given value, the method returns a negative
        // integer. The bitwise complement operator (~) can be applied to a
        // negative result to produce the index of the first element (if any) that
        // is larger than the given search value. This is also the index at which
        // the search value should be inserted into the list in order for the list
        // to remain sorted.
        //
        // The method uses the Array.BinarySearch method to perform the
        // search.
        //
        public virtual int BinarySearch(int index, int count, Object value, IComparer comparer) {
            if (index &lt; 0 || count &lt; 0)
                throw new ArgumentOutOfRangeException((index&lt;0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            if (_size - index &lt; count)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
   
            return Array.BinarySearch((Array)_items, index, count, value, comparer);
        }
</pre>
<p> </p>
<p> </p>
<p>Array的：</p>
<pre name="code" class="c#">[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int BinarySearch(Array array, int index, int length, Object value, IComparer comparer) {
            if (array==null)
                throw new ArgumentNullException("array");
            int lb = array.GetLowerBound(0);
            if (index &lt; lb || length &lt; 0)
                throw new ArgumentOutOfRangeException((index&lt;lb ? "index" : "length"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            if (array.Length - (index - lb) &lt; length)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
            if (array.Rank != 1)
                throw new RankException(Environment.GetResourceString("Rank_MultiDimNotSupported"));
           
            if (comparer == null) comparer = Comparer.Default;
            if (comparer == Comparer.Default) {
                int retval;
                bool r = TrySZBinarySearch(array, index, length, value, out retval);
                if (r)
                    return retval;
            }

            int lo = index;
            int hi = index + length - 1;  
            Object[] objArray = array as Object[];
            if(objArray != null) {
                while (lo &lt;= hi) {
                    // i might overflow if lo and hi are both large positive numbers.
                    int i = GetMedian(lo, hi);

                    int c;
                    try {
                        c = comparer.Compare(objArray[i], value);
                    }
                    catch (Exception e) {
                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"), e);
                    }
                    catch {
                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"));
                    }
                    if (c == 0) return i;
                    if (c &lt; 0) {
                        lo = i + 1;
                    }
                    else {
                        hi = i - 1;
                    }
                }
            }
            else {
                while (lo &lt;= hi) {
                    int i = GetMedian(lo, hi);                   

                    int c;
                    try {
                        c = comparer.Compare(array.GetValue(i), value);
                    }
                    catch (Exception e) {
                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"), e);
                    }
                    catch {
                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"));
                    }
                    if (c == 0) return i;
                    if (c &lt; 0) {
                        lo = i + 1;
                    }
                    else {
                        hi = i - 1;
                    }
                }
            }
            return ~lo;
        }
</pre>
<p> </p>
<p>总的来说，就是二分法来查找元素，如果使用此方法前没有排序，或是查找的比较方式和排序的比较方式不一样的话，结果可能找不到。</p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
</div>
<p><br>谢谢昂。····多用在什么时候呢？</p>
1 楼 kimmking 2009-04-28  
<pre name="code" class="c#"> ArrayList的binary search：
</pre>
<pre name="code" class="c#">// Searches a section of the list for a given element using a binary search
        // algorithm. Elements of the list are compared to the search value using
        // the given IComparer interface. If comparer is null, elements of
        // the list are compared to the search value using the IComparable
        // interface, which in that case must be implemented by all elements of the
        // list and the given search value. This method assumes that the given
        // section of the list is already sorted; if this is not the case, the
        // result will be incorrect.
        //
        // The method returns the index of the given value in the list. If the
        // list does not contain the given value, the method returns a negative
        // integer. The bitwise complement operator (~) can be applied to a
        // negative result to produce the index of the first element (if any) that
        // is larger than the given search value. This is also the index at which
        // the search value should be inserted into the list in order for the list
        // to remain sorted.
        //
        // The method uses the Array.BinarySearch method to perform the
        // search.
        //
        public virtual int BinarySearch(int index, int count, Object value, IComparer comparer) {
            if (index &lt; 0 || count &lt; 0)
                throw new ArgumentOutOfRangeException((index&lt;0 ? "index" : "count"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            if (_size - index &lt; count)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
   
            return Array.BinarySearch((Array)_items, index, count, value, comparer);
        }
</pre>
<p> </p>
<p> </p>
<p>Array的：</p>
<pre name="code" class="c#">[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
        public static int BinarySearch(Array array, int index, int length, Object value, IComparer comparer) {
            if (array==null)
                throw new ArgumentNullException("array");
            int lb = array.GetLowerBound(0);
            if (index &lt; lb || length &lt; 0)
                throw new ArgumentOutOfRangeException((index&lt;lb ? "index" : "length"), Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            if (array.Length - (index - lb) &lt; length)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
            if (array.Rank != 1)
                throw new RankException(Environment.GetResourceString("Rank_MultiDimNotSupported"));
           
            if (comparer == null) comparer = Comparer.Default;
            if (comparer == Comparer.Default) {
                int retval;
                bool r = TrySZBinarySearch(array, index, length, value, out retval);
                if (r)
                    return retval;
            }

            int lo = index;
            int hi = index + length - 1;  
            Object[] objArray = array as Object[];
            if(objArray != null) {
                while (lo &lt;= hi) {
                    // i might overflow if lo and hi are both large positive numbers.
                    int i = GetMedian(lo, hi);

                    int c;
                    try {
                        c = comparer.Compare(objArray[i], value);
                    }
                    catch (Exception e) {
                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"), e);
                    }
                    catch {
                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"));
                    }
                    if (c == 0) return i;
                    if (c &lt; 0) {
                        lo = i + 1;
                    }
                    else {
                        hi = i - 1;
                    }
                }
            }
            else {
                while (lo &lt;= hi) {
                    int i = GetMedian(lo, hi);                   

                    int c;
                    try {
                        c = comparer.Compare(array.GetValue(i), value);
                    }
                    catch (Exception e) {
                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"), e);
                    }
                    catch {
                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_IComparerFailed"));
                    }
                    if (c == 0) return i;
                    if (c &lt; 0) {
                        lo = i + 1;
                    }
                    else {
                        hi = i - 1;
                    }
                }
            }
            return ~lo;
        }
</pre>
<p> </p>
<p>总的来说，就是二分法来查找元素，如果使用此方法前没有排序，或是查找的比较方式和排序的比较方式不一样的话，结果可能找不到。</p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
<p> </p>
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    4.24师德师风政治学习笔记.pdf

    教师自身需要关注人文关怀，持续学习，提升人格魅力，实现自我完善。学校应营造良好的师德氛围，提供支持和引导。社会则需理解和尊重教师，为教师的成长提供良好的环境，共同促进教育事业的健康发展。通过这样的共同...

    GTK学习笔记

    ### GTK学习笔记知识点详解 #### 一、入门篇 ##### 1.1 Hello! World! 在GTK编程中，“Hello! World!”程序是最基础的入门示例。本节将引导读者编写一个简单的GTK程序，实现一个带有自定义标题的窗口。 **1.11 ...

    Sap配置学习笔记(MM+SD+FICO

    ### SAP配置学习笔记(MM+SD+FICO)关键知识点总结 #### 一、配置总体框架 在本笔记中，作者概述了SAP系统的整体配置框架，主要包括系统环境、机构设置、工厂结构等基本组成部分。 ##### 1.1 系统环境 系统环境是SAP...

    10oa协同办公系统下载 v8.0

    并且10oa协同办公系统易理解、易学习、易操作。 使用优势： 1.100多个免费功能模块，实现全面协同办公。 2.50多个免费电子流程，一键申请辅助填单，全自动规范运作。 3.10分钟学会使用，界面体验更简约。 4.24小时...

    java 讲师笔记

    4.24 对象序列化：对象序列化是将对象状态转换为可以保存或传输的过程。 4.25 Thread线程类及多线程：Java提供了丰富的API支持多线程编程。 4.26 Socket网络编程：Java通过Socket API支持网络通信。 4.27 线程池：...

Magicbox
Global site tag (gtag.js) - Google Analytics