Dictionary

List1. Giới thiệu:Biểu diễn một tập hợp các đối tượng cùng kiểu dữ liệu, có thể truy cập bởi

chỉ số. Ngoài ra cung cấp các phương pháp sắp xếp, tìm kiếm, và thao tác trên tập hợp đó.Namespace: System.Collections.Generic

2. Một số thành phần quan trọng:a. Constructor:

- List<T>() : khởi tạo 1 list rỗng.

- List<T>(int n) : khởi tạo 1 list có sức chứa n phần tử.

b. Properties:

- Capacity: (kiểu int) sức chứa của list.

- Count : (kiểu int) số phần tử của list.

c. Methods:

Add : thêm một phần tử vào cuối list.

BinarySearch(T x): trả về chỉ số của phần tử x trong list, nếu ko có thì trả về số âm.

Clear() : xóa tất cả các phần tử trong list.

Contains(T x): trả về true nếu x thuộc list, false nếu ngược lại.

CopyTo(T[] a) : copy list qua mảng a.

GetType : trả về kiểu dữ liệu của phần tử.

IndexOf(T x) : trả về chỉ số của phần tử x trong list, -1 nếu x không thuộc list.

Insert(int index, T x): chèn x vào list tại chỉ số index.

InsertRange(int index, T[] a): chèn a vào list tại chỉ số index.

LastIndexOf(T x, int a, int b): trả về chỉ số của x trong list chỉ tính từ chỉ số a đến chỉ số b.

Remove(T x) : xóa phần tử x trong list.

RemoveAt(int x): xóa phần tử tại chỉ số x.

Reverse(): đảo thứ tự các phần tử trong list.

Sort() : sắp xếp các phần tử trong list.

3. Ghi chú:

Lớp List có nét tương tự với lớp ArrayList. Nó cài đặt các hàm của interface IList bằng cách sử dụng một mảng có kích thước tự động tăng lên theo yêu cầu.

Các phần tử của list có thể chưa được sắp xếp, vì vậy trước khi thực hiện một số hàm như BinarySearch thì cần phải sắp xếp List.Các phần tử trong List có thể truy cập bằng chỉ số kiểu integer. Chỉ số này bắt đầu từ 0.

List có thể có phần tử mang giá trị null, và có thể có nhiều phần tử giống nhau.

Cân nhắc khi dùng:

Vì hai lớp List và ArrayList khá giống nhau, nên khi quyết định chọn một trong hai lớp này, bạn nên nhớ rằng List thường tốt hơn trong hầu hết các trường hợp và thường "an toàn" hơn. Nếu kiểu dữ liệu của phần tử là kiểu reference, thì hai lớp List và ArraylList giống hệt nhau. Tuy nhiên, nếu phần tử là kiểu giá trị (value), cần cân nhắc vấn đề boxing. Trong trường hợp này nên dùng List.

4. Code ví dụ:

using System;using System.Collections.Generic;

public class Example{ public static void Main() { List<string> dinosaurs = new List<string>();

Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity);

dinosaurs.Add("Tyrannosaurus"); dinosaurs.Add("Amargasaurus"); dinosaurs.Add("Mamenchisaurus"); dinosaurs.Add("Deinonychus"); dinosaurs.Add("Compsognathus");

Console.WriteLine(); foreach(string dinosaur in dinosaurs) { Console.WriteLine(dinosaur); }

Console.WriteLine("\nCapacity: {0}", dinosaurs.Capacity); Console.WriteLine("Count: {0}", dinosaurs.Count);

Console.WriteLine("\nContains(\"Deinonychus\"): {0}", dinosaurs.Contains("Deinonychus"));

Console.WriteLine("\nInsert(2, \"Compsognathus\")"); dinosaurs.Insert(2, "Compsognathus");

Console.WriteLine(); foreach(string dinosaur in dinosaurs)

{ Console.WriteLine(dinosaur); }

Console.WriteLine("\ndinosaurs[3]: {0}", dinosaurs[3]);

Console.WriteLine("\nRemove(\"Compsognathus\")"); dinosaurs.Remove("Compsognathus");

Console.WriteLine(); foreach(string dinosaur in dinosaurs) { Console.WriteLine(dinosaur); }

dinosaurs.TrimExcess(); Console.WriteLine("\nTrimExcess()"); Console.WriteLine("Capacity: {0}", dinosaurs.Capacity); Console.WriteLine("Count: {0}", dinosaurs.Count);

dinosaurs.Clear(); Console.WriteLine("\nClear()"); Console.WriteLine("Capacity: {0}", dinosaurs.Capacity); Console.WriteLine("Count: {0}", dinosaurs.Count); }}

/* This code example produces the following output:

Capacity: 0

TyrannosaurusAmargasaurusMamenchisaurusDeinonychusCompsognathus

Capacity: 8Count: 5

Hashtable

1. Hashtable là cấu trúc lưu trữ dữ liệu tìm kiếm rất hiệu quả, biểu diễn một tập hợp các cặp khóa/giá trị được lấy từ mã băm của khóa.

Chú ý

Mỗi phần tử là một cặp khóa/giá trị được lưu trong đối tượng DictionaryEntry. Khóa không được là null, nhưng giá trị có thể là null.

Khóa trong hashtable phải nạp chồng phương thức Object.GetHashCode và Object.Equals. Hơn nữa, những phương thức này phải cho ra cùng kết quả khi được gọi với cùng tham số.

Khóa trong hashtable không được thay đổi.

Khi thêm một phần tử vào hashtable, phần tử được lưu trong bucket dựa theo mã băm của khóa. Sau đó việc tìm kiếm khóa dựa vào mã băm của khóa để tìm kiếm trong một bucket nên giảm đáng kể số lượng phép so sánh trong lúc tìm kiếm.

Yếu tố tải của hashtable quyết định tỉ lệ tối đa số phần tử trên một bucket. Nếu trong một bucket có ít phần tử thì tốc độ tìm kiếm nhanh hơn nhưng phải tốn nhiều bộ nhớ hơn. Chỉ số tải mặc định là 1.0 thường là tốt nhất, cân bằng giữa tốc độ và tiêu tốn bộ nhớ. Chỉ số tải có thể truyền vào khi tạo hashtable.

Khi thêm vào một phần tử, số phần tử trong bucket tăng lên. Khi bucket đã chứa tối đa, số lượng bucket sẽ được tăng lên tới số nguyên tố nhỏ nhất sao cho lớn hơn gấp đôi số lượng bucket hiện tại.

Mỗi khóa trong hashtable phải cung cấp hàm băm của riêng nó. Chúng ta có thể truy cập hàm này bằng phương thức GetHash. Tuy nhiên,nếu một đối tượng thực hiện IHashCodeProvider và được truyền vào hàm dựng (constructor) khi khởi tạo hashtable, và hàm băm đó sẽ được dùng chung cho tất cả khóa.

Sức chứa (Capacity) của hashtable là số phần tử mà hashtable có thể chứa. Khi thêm phần tử vào hashtable, sức chứa có thể tự động tăng lên theo yêu cầu bằng cách cấp phát lại.

Câu lệnh foreach yêu cầu kiểu dữ liệu của mỗi phần tử trong tập hợp. Vấn đề là mỗi phần tử của hashtable là một cặp khóa/giá trị, và kiểu dữ liệu của mỗi phần tử không phải là kiểu dữ liệu của khóa, cũng không phải kiểu dữ liệu của giá trị. Thay vào đó, kiểu dữ liệu của mỗi phần tử là kiểu DictionaryEntry. Ví dụ:

foreach(DictinaryEntry a in myHashTable)

{

...

}

Khi dùng câu lệnh foreach, chỉ có thể đọc các phần tử mà không thể ghi các phần tử vào tập hợp.

Một số thành phần quan trọng

Constructor

Hashtable() : tạo mới một hashtable.

Hashtable(IDictionary x): tạo mới một hashtable bằng cách copy các phần tử từ một dictionary.

Hashtable(int n): tạo mới một hashtable với capacity bằng n.

Properties

Count : số lượng khóa/giá trị được chứa trong hashtable.

IsFixedSize : cho biết kích thước hashtable cố định hay không.

IsReadOnly : cho biết hashtable có thuộc tính readonly hay không.

Item : giá trị đi kèm với khóa.

Keys : khóa.

Methods

Add : thêm một phần tử (khóa, giá trị) vào hashtable.

Clear : xóa tất cả các phần tử trong hashtable.

Clone : tạo một bản copy của hashtable.

Contains( T x) : cho biết hashtable có chứa khóa x không.

CopyTo : copy các phần tử của hashtable vào mảng tại chỉ số truyền vào.

GetType : trả về kiểu dữ liệu của phần tử.

Remove : xóa phần tử trong hashtable với key truyền vào.

Code ví dụ:using System;using System.Collections;

class Example{ public static void Main() { // Create a new hash table. // Hashtable openWith = new Hashtable();

// Add some elements to the hash table. There are no // duplicate keys, but some of the values are duplicates. openWith.Add("txt", "notepad.exe"); openWith.Add("bmp", "paint.exe"); openWith.Add("dib", "paint.exe");

openWith.Add("rtf", "wordpad.exe");

// The Add method throws an exception if the new key is // already in the hash table. try { openWith.Add("txt", "winword.exe"); } catch { Console.WriteLine("An element with Key = \"txt\" already exists."); }

// The Item property is the default property, so you // can omit its name when accessing elements. Console.WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]);

// The default Item property can be used to change the value // associated with a key. openWith["rtf"] = "winword.exe"; Console.WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]);

// If a key does not exist, setting the default Item property // for that key adds a new key/value pair. openWith["doc"] = "winword.exe";

// ContainsKey can be used to test keys before inserting // them. if (!openWith.ContainsKey("ht")) { openWith.Add("ht", "hypertrm.exe"); Console.WriteLine("Value added for key = \"ht\": {0}", openWith["ht"]); }

// When you use foreach to enumerate hash table elements, // the elements are retrieved as KeyValuePair objects. Console.WriteLine(); foreach( DictionaryEntry de in openWith ) { Console.WriteLine("Key = {0}, Value = {1}", de.Key, de.Value); }

// To get the values alone, use the Values property. ICollection valueColl = openWith.Values;

// The elements of the ValueCollection are strongly typed // with the type that was specified for hash table values. Console.WriteLine(); foreach( string s in valueColl ) { Console.WriteLine("Value = {0}", s); }

// To get the keys alone, use the Keys property. ICollection keyColl = openWith.Keys;

// The elements of the KeyCollection are strongly typed // with the type that was specified for hash table keys. Console.WriteLine(); foreach( string s in keyColl ) { Console.WriteLine("Key = {0}", s); }

// Use the Remove method to remove a key/value pair. Console.WriteLine("\nRemove(\"doc\")"); openWith.Remove("doc");

if (!openWith.ContainsKey("doc")) { Console.WriteLine("Key \"doc\" is not found."); } }}

/* This code example produces the following output:

An element with Key = "txt" already exists.For key = "rtf", value = wordpad.exe.For key = "rtf", value = winword.exe.Value added for key = "ht": hypertrm.exe

Key = dib, Value = paint.exeKey = txt, Value = notepad.exeKey = ht, Value = hypertrm.exeKey = bmp, Value = paint.exeKey = rtf, Value = winword.exeKey = doc, Value = winword.exe

Value = paint.exeValue = notepad.exeValue = hypertrm.exeValue = paint.exeValue = winword.exeValue = winword.exe

Key = dibKey = txtKey = htKey = bmpKey = rtfKey = doc

Remove("doc")Key "doc" is not found. */

1. ArrayList

ArrayList được chứa trong System.Collections và nó có thể chứa các phần tử thuộc bất cứ kiểu dữ liệu nào.

Một số thành phần quan trọng:

Constructor:

ArrayList() : tạo mới một arraylist.

ArrayList(int n) : tạo mới một arraylist với sức chứa (capacity) là n.

Properties

Capacity : số phần tử arraylist có thể chứa.

Count : số phần tử arraylist hiện tại chứa.

IsFixedSize : kiểm tra arraylist có kích thước cố định không.

Methods:

Add : thêm một phần tử vào cuối arraylist.

BinarySearch(Object): tìm trong arraylist đã sắp xếp một phần tử, trả về chỉ số của nó nếu có và trả về -1 nếu không tìm thấy.

Clear : xóa tất cả các phần tử trong arraylist.

Contains : kiểm tra một phần tử có trong arraylist hay không.

Insert(int n, Object x): chèn phần tử x vào vị trí n.

Remove(Object x) : xóa phần tử x đầu tiên trong arraylist.

RemoveAt(int n) : xóa phần tử tại vị trí x.

Sort : sắp xếp arraylist.

Code ví dụ:using System;using System.Collections;public class SamplesArrayList {

public static void Main() {

// Creates and initializes a new ArrayList. ArrayList myAL = new ArrayList(); myAL.Add("Hello"); myAL.Add("World"); myAL.Add("!");

// Displays the properties and values of the ArrayList. Console.WriteLine( "myAL" ); Console.WriteLine( " Count: {0}", myAL.Count ); Console.WriteLine( " Capacity: {0}", myAL.Capacity );

Console.Write( " Values:" ); PrintValues( myAL ); }

public static void PrintValues( IEnumerable myList ) { foreach ( Object obj in myList ) Console.Write( " {0}", obj ); Console.WriteLine(); }

}

/* This code produces output similar to the following:

myAL Count: 3 Capacity: 4 Values: Hello World !

*/

2. TupleTuple là cấu trúc dữ liệu trong đó số phần tử có số lượng cụ thể và được sắp xếp theo một trình tự. .NET Framework hỗ trợ Tuple với 7 phần tử. Bạn có thể tạo ra tuple với 8 hay nhiều hơn số phần tử trong phần còn lại của property của tuple.Tuple thường được sử dụng theo 4 cách:- Để biểu diễn một kiểu dữ liệu đơn. Ví dụ như một bản ghi (record), các phần tử của tuple là các trường của bản ghi.- Để dễ dàng truy cập và thao tác mộ tập hợp dữ liệu. - Để trả về nhiều giá trị từ một hàm mà không cần dùng tham số đầu ra (out parameters).- Để đưa nhiều thông số vào hàm với một tham số. Lưu ý: mặc dù có thể tạo một tuple bằng cách gọi constructor, chúng ta không nên làm như vậy vì khá rườm rà. Tốt nhất nên làm như sau, tuple chứa dân số của New York trong 7 lần điều tra dân số:

var population = new Tuple<string, int, int, int, int, int, int>( "New York", 7891957, 7781984,

7894862, 7071639, 7322564, 8008278);

Dictionary:

1. Giới thiệu:Kiểu Dictionary là một trong những kiểu dữ liệu quan trọng nhất mà bạn cần dùng trong chương trình C#. Nó là sự cài đặt của hashtable, là một cách cực kỳ hiệu quả để lưu trữ các khóa cho việc tìm kiếm.

2. Các thành phần cơ bản:a. Constructor:- Dictionary<TKey, TValue>(): tạo một Dictionary trống.

Hàm dựng này có chi phí tìm kiếm là O(1).- Dictionary<TKey, TValue>(IDictionary<TKey, TValue>): tạo một

Dictionay mới bằng cách copy các phần tử từ IDictionary<TKey, TValue>.Hàm dựng này có chi phí tìm kiếm là O(n) với n là số phần tử có trong Dictionary.

- Dictionary<TKey, TValue>(Int32): tạo một Dictionary trống với sức chứa (capacity) là tham số truyền vào.Hàm dựng này có chi phí tìm kiếm là O(1).

b. Properties:- Comparer: dùng IEqualityComparer<T> để so sánh các khóa.- Count: số các khóa, giá trị trong Dictionary.- Item: giá trị tương ứng với khóa.- Keys: khóa.c. Methods:- Add: thêm một cặp khóa và giá trị vào dictionary.- Clear: xóa tất cả các khóa, giá trị trong dictionary.- ContainsKey(Tkey x): cho biết Dictionary có chứa key “x” hay không.- ContainsValue(Tvalue x): cho biết Dictionary có chứa giá trị “x” hay

không.- GetType: trả về kiểu dữ liệu của đối tượng hiện tại.- Remove(Tkey x): xóa giá trị trong Dictionary tương ứng với khóa “x”.

3. Chú ý:- Dictionary cung cấp một ánh xạ giữa khóa và giá trị. Mỗi khi thêm giá trị

vào Dictionary cần đồng thời thêm khóa của giá trị đó. Lấy giá trị bằng cách sử dụng khóa của nó rất hiệu quả bởi vì Dictionary là một cài đặt của hashtable. Tốc độ tìm kiếm phụ thuộc vào thuật toán băm của kiểu dữ liệu khóa.

- Khóa trong Dictionary không được thay đổi nếu làm ảnh hưởng đến giá trị băm của nó. Tất cả khóa trong Dictionary phải là duy nhất. Khóa không thể là null nhưng giá trị có thể là null.

- Dictionary yêu cầu hàm so sánh để so sánh giữa các khóa. Bạn có thể chỉ định một hàm của giao diện IEqualityComparer<T> bằng cách dùng nó như là tham số trong hàm dựng của Dictionary. Nếu không hàm so sánh mặc định sẽ được dùng.

- Capacity của một Dictionary là số phần tử mà Dictionary có thể chứa khi thêm một phần tử vào Dictionary capacity sẽ tự động tăng lên nếu cần.

- Để thuận lợi cho việc tìm kiếm mỗi phần tử trong Dictionary bao gồm khóa và giá trị. Thứ tự của các phần tử là không xác định.

- Câu lệnh foreach yêu cầu kiểu dữ liệu của mỗi phần tử trong tập hợp. Vấn đề ở đây là mỗi phần tử trong Dictionary bao gồm khóa và giá trị, kiểu của phần tử không phải là kiểu của khóa, cũng không phải là kiểu của giá trị. Kiểu của khóa là KeyValuePair<TKey, TValue>. Ví dụ:

foreach( KeyValuePair<string, string> kvp in myDictionary ){ Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);}

- Câu lệnh foreach chỉ cho phép đọc dữ liệu từ Dictionary mà không cho phép ghi dữ liệu vào Dictionary.

4. Code ví dụ:using System;using System.Collections.Generic;

public class Example{ public static void Main() { // Create a new dictionary of strings, with string keys. // Dictionary<string, string> openWith = new Dictionary<string, string>();

// Add some elements to the dictionary. There are no // duplicate keys, but some of the values are duplicates. openWith.Add("txt", "notepad.exe"); openWith.Add("bmp", "paint.exe"); openWith.Add("dib", "paint.exe"); openWith.Add("rtf", "wordpad.exe");

// The Add method throws an exception if the new key is // already in the dictionary. try { openWith.Add("txt", "winword.exe");

} catch (ArgumentException) { Console.WriteLine("An element with Key = \"txt\" already exists."); }

// The Item property is another name for the indexer, so you // can omit its name when accessing elements. Console.WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]);

// The indexer can be used to change the value associated // with a key. openWith["rtf"] = "winword.exe"; Console.WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]);

// If a key does not exist, setting the indexer for that key // adds a new key/value pair. openWith["doc"] = "winword.exe";

// The indexer throws an exception if the requested key is // not in the dictionary. try { Console.WriteLine("For key = \"tif\", value = {0}.", openWith["tif"]); } catch (KeyNotFoundException) { Console.WriteLine("Key = \"tif\" is not found."); }

// When a program often has to try keys that turn out not to // be in the dictionary, TryGetValue can be a more efficient // way to retrieve values. string value = ""; if (openWith.TryGetValue("tif", out value)) { Console.WriteLine("For key = \"tif\", value = {0}.", value); } else { Console.WriteLine("Key = \"tif\" is not found."); }

// ContainsKey can be used to test keys before inserting // them. if (!openWith.ContainsKey("ht")) { openWith.Add("ht", "hypertrm.exe"); Console.WriteLine("Value added for key = \"ht\": {0}", openWith["ht"]); }

// When you use foreach to enumerate dictionary elements, // the elements are retrieved as KeyValuePair objects. Console.WriteLine(); foreach( KeyValuePair<string, string> kvp in openWith ) {

Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value); }

// To get the values alone, use the Values property. Dictionary<string, string>.ValueCollection valueColl = openWith.Values;

// The elements of the ValueCollection are strongly typed // with the type that was specified for dictionary values. Console.WriteLine(); foreach( string s in valueColl ) { Console.WriteLine("Value = {0}", s); }

// To get the keys alone, use the Keys property. Dictionary<string, string>.KeyCollection keyColl = openWith.Keys;

// The elements of the KeyCollection are strongly typed // with the type that was specified for dictionary keys. Console.WriteLine(); foreach( string s in keyColl ) { Console.WriteLine("Key = {0}", s); }

// Use the Remove method to remove a key/value pair. Console.WriteLine("\nRemove(\"doc\")"); openWith.Remove("doc");

if (!openWith.ContainsKey("doc")) { Console.WriteLine("Key \"doc\" is not found."); } }}

/* This code example produces the following output:

An element with Key = "txt" already exists.For key = "rtf", value = wordpad.exe.For key = "rtf", value = winword.exe.Key = "tif" is not found.Key = "tif" is not found.Value added for key = "ht": hypertrm.exe

Key = txt, Value = notepad.exeKey = bmp, Value = paint.exeKey = dib, Value = paint.exeKey = rtf, Value = winword.exeKey = doc, Value = winword.exeKey = ht, Value = hypertrm.exe

Value = notepad.exeValue = paint.exeValue = paint.exeValue = winword.exeValue = winword.exeValue = hypertrm.exe

Key = txtKey = bmpKey = dibKey = rtfKey = docKey = ht

Remove("doc")Key "doc" is not found. */

Lookup table:1. Giới thiệu:

Ngoài Hashtable và Dictionary, C# còn có nhiều cấu trúc dữ liệu tìm kiếm khác, gọi chung là Lookup tables.

2. Các thành phần:a. ListDictionary: là một kiểu cấu trúc đại diện cho kiểu Dictionary của

C# nói chung, được cài đặt dựa trên một danh sách liên kết. - Về cơ bản việc cài đặt và sử dụng ListDictionary cũng tương tự như

Hashtable. Chúng ta có thể thực hiện các thao tác thêm, sửa, xóa.- Đối với những dữ liệu có kích thước nhỏ nó tỏ ra ưu việt hơn so với

Hashtable. Nhưng nếu dữ liệu có kích thước càng lớn thì việc tìm kiếm trong ListDictionary càng tỏ ra chậm hơn so với Hashtable. Đối với mọi dữ liệu thì Hashtable thì thời gian tìm kiếm vẫn ổn định trong khi thời gian tìm kiếm của ListDictionary càng tăng một cách tuyến tính theo kích thước dữ liệu.

BitArray1. Giới thiệu:

Kiểu BitArray là một lọai cấu trúc dữ liệu trừu tượng dùng để lưu trữ các bit. Thường trong một chương trình có nhiều biến bool ta sử dụng Bitarray để lưu trữ và truy xuất các biến đó một cách hệ thống, rõ ràng.Kiểu BitArray có chi phí là O(n) với n là số bit có trong BitArray.

2. Các thành phần cơ bản:a. Constructors:- BitArray (BitArray bits): khởi tạo một BitArray mới chứa các giá trị trong một BitArray khác.- BitArray (bool[] values): khởi tạo một BitArray mới chứa các giá trị trong một mảng các biến Booleans sẵn có.- BitArray (byte[] values): khởi tạo một BitArray mới chứa các giá trị trong một mảng các biến kiểu byte sẵn có. Mỗi byte tương ứng với 8 bit.- BitArray (int[] values): khởi tạo một BitArray mới chứa các giá trị trong một mảng các biến kiểu int sẵn có. Mỗi biến int tương ứng với 32 bit.

- BitArray(int length, bool defaultValue): khởi tạo một BitArray có số bit là length, và giá trị mặc định của các bit là defaultValue.b. Properties:- Count: trả về số phần tử trong BitArray.- IsReadOnly: trả về một giá trị bool cho biết BitArray đó là chỉ đọc hay không.- Item: gán hoặc lấy giá trị của bit tại một vị trí trong BitArray.- Length: trả về số phần tử của BitArray.c. Method:- CopyTo(Array array, int index): copy các giá trị của một BitArray vào mảng một chiều bắt đầu từ vị trí index.- Get(int index): trả về giá trị của bit ở vị trí index.- Set(int index, bool value): gán giá trị nào đó cho bit ở một vị trí trong BitArray.- SetAll(bool value): gán tất cả các giá trị của các phần tử trong BitArray bằng một giá trị nào đó.

3. Chú ý:- Kích thước của một BitArray do người dùng định sẵn, nếu chỉ số cuối lớn hơn kích thước của BitArray thì sẽ phát sinh lỗi.

4. Code ví dụ:using System; using System.Collections; public class SamplesBitArray {

public static void Main() {

// Creates and initializes several BitArrays. BitArray myBA1 = new BitArray( 5 );

BitArray myBA2 = new BitArray( 5, false );

byte[] myBytes = new byte[5] { 1, 2, 3, 4, 5 }; BitArray myBA3 = new BitArray( myBytes );

bool[] myBools = new bool[5] { true, false, true, true, false }; BitArray myBA4 = new BitArray( myBools );

int[] myInts = new int[2] { 6, 7}; BitArray myBA5 = new BitArray( myInts );

// Displays the properties and values of the BitArrays. Console.WriteLine( "myBA1" ); Console.WriteLine( " Count: {0}", myBA1.Count ); Console.WriteLine( " Length: {0}", myBA1.Length ); Console.WriteLine( " Values:" ); PrintValues( myBA1, 8 );

Console.WriteLine( "myBA2" );

Console.WriteLine( " Count: {0}", myBA2.Count ); Console.WriteLine( " Length: {0}", myBA2.Length ); Console.WriteLine( " Values:" ); PrintValues( myBA2, 8 );

Console.WriteLine( "myBA3" ); Console.WriteLine( " Count: {0}", myBA3.Count ); Console.WriteLine( " Length: {0}", myBA3.Length ); Console.WriteLine( " Values:" ); PrintValues( myBA3, 8 );

Console.WriteLine( "myBA4" ); Console.WriteLine( " Count: {0}", myBA4.Count ); Console.WriteLine( " Length: {0}", myBA4.Length ); Console.WriteLine( " Values:" ); PrintValues( myBA4, 8 );

Console.WriteLine( "myBA5" ); Console.WriteLine( " Count: {0}", myBA5.Count ); Console.WriteLine( " Length: {0}", myBA5.Length ); Console.WriteLine( " Values:" );

PrintValues( myBA5, 8 ); Console.ReadLine();

}

public static void PrintValues( IEnumerable myList, int myWidth ) { int i = myWidth; foreach ( Object obj in myList ) { if ( i <= 0 ) { i = myWidth; Console.WriteLine(); } i--; Console.Write( "{0,8}", obj ); } Console.WriteLine(); }

}

/* This code produces the following output.

myBA1 Count: 5 Length: 5 Values: False False False False False myBA2 Count: 5 Length: 5 Values: False False False False False myBA3 Count: 40 Length: 40 Values: True False False False False False False False

False True False False False False False False True True False False False False False False False False True False False False False False True False True False False False False False myBA4 Count: 5 Length: 5 Values: True False True True False myBA5 Count: 64 Length: 64 Values: False True True False False False False False False False False False False False False False False False False False False False False False False False False False False False False False True True True False False False False False False False False False False False False False False False False False False False False False False False False False False False False False*/

KeyValuePair

1. Giới thiệu:- KeyValuePair là một trong những cấu trúc dữ liệu hữu ích nhất trong C#. Nó là một hình thức đơn giản của Tuple, cung cấp cho chúng ta một phương thức lưu trữ các key và giá trị theo từng cặp với nhau trong một struct.2. Các thành phần cơ bản:a. Constructor:- KeyValuePair(Tkey key, Tvalue value): khởi tạo một KeyValuePair với một khóa và giá trị sẵn có.b. Properties:- Tkey: giá trị của key.- Tvalue: giá trị cho value.Ví dụ: liệt kê các khóa và giá trị trong một từ điển, sử dụng cấu trúc KeyValuePair.

Console.WriteLine();foreach( KeyValuePair<string, string> kvp in openWith ){ Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);

}

c. Methods:- Equals: cho biết hai đối tượng có bằng nhau hay không, trả về kiểu bool.- GetHashCode: trả về mã băm của đối tượng.- GetType: trả về kiểu của đối tượng.

- ToString: trả về chuỗi mô tả đối tượng, bằng cách sử dụng chuỗi đại diện của khóa và giá trị.3. Chú ý:

Câu lệnh foreach yêu cầu phải có kiểu dữ liệu của các phần tử trong các mảng lưu trữ. Tuy nhiên, những thành phần dựa trên kiểu Idictionary<Tkey, Tvalue> là một cặp khóa/giá trị. Kiểu của các cặp khóa/giá trị đó là kiểu KeyValuePair<TKey, TValue>, chứ không phải kiểu của khóa cũng không phải kiểu của giá trị.Ví dụ sau sẽ làm rõ vấn đề này:

foreach( KeyValuePair<string, string> kvp in myDictionary ){ Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);}

4. Ví dụ:Ví dụ sau là một phần nằm trong ví dụ của Dictionary. Console.WriteLine();foreach( KeyValuePair<string, string> kvp in openWith ){ Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);

}

Stack1. Giới thiệu:

Stack là một cấu trúc dữ liệu hoạt động theo cơ chế “vào sau ra trước” (last in first out). Stack là một dạng danh sách liên kết mà trên đó việc thêm hay hủy một phần tử chỉ xảy ra trên một đầu duy nhất.

2. Các thành phần cơ bản:a. Constructor: - Stack(): khởi tạo một stack rỗng.- Stack(Icollection col): khởi tạo một stack có các phần tử được sao chép từ một collection khác, và có số phần tử đúng bằng số phần tử được sao chép.- Stack(int capacity): khởi tạo một stack rỗng có kích thước là một số nguyên “capacity”.b. Properties:- Count: trả về số phần tử của stack.c. Methods:- Push(object obj): thêm một phần tử vào đỉnh của stack.

- Pop(): trả về phần tử ở đỉnh của stack và xóa phần tử đó khỏi stack.- Peek(): trả về phần tử ở đỉnh của stack nhưng không xóa khỏi stack.- Clear(): xóa tất cả phần tử khỏi stack.- Contain(Object obj): kiểm tra một phần tử có tồn tại trong stack hay không.

3. Chú ý:- Khi một phần tử được thêm vào stack, kích thước của stack sẽ được tự động tăng lên bằng cách cấp phát lại bộ nhớ.- Stack chấp nhận null là một giá trị hợp lệ, và cho phép thêm vào các giá trị trùng lặp.

4. Code ví dụ:

using System;using System.Collections;public class SamplesStack{

public static void Main() {

// Creates and initializes a new Stack. Stack myStack = new Stack(); myStack.Push("Hello"); myStack.Push("World"); myStack.Push("!");

// Displays the properties and values of the Stack. Console.WriteLine("myStack"); Console.WriteLine("\tCount: {0}\n", myStack.Count); PrintValues(myStack); Console.WriteLine("(Peek)\t{0}\n", myStack.Peek()); PrintValues(myStack); Console.WriteLine("(Pop)\t{0}\n", myStack.Pop()); PrintValues(myStack); Console.WriteLine("Hello is in mystack: {0}\n", myStack.Contains("Hello")); Console.ReadLine(); }

public static void PrintValues(IEnumerable myCollection) { Console.WriteLine("mystack:"); foreach (Object obj in myCollection) Console.WriteLine(" {0}", obj); Console.WriteLine(); }

}

/*myStack Count: 3

mystack:

! World Hello

(Peek) !

mystack: ! World Hello

(Pop) !

mystack: World Hello

'Hello' is in mystack: True*/

Queue:1. Giới thiệu:

Queue (hàng đợi) là một cấu trúc dữ liệu làm việc theo cơ chế “vào trước ra trước” (first in first out).Trong queue đối tượng có thể được thêm vào bất kì lúc nào, nhưng chỉ có đối tượng được thêm vào đầu tiên mới được phép lấy ra. Thao tác thêm vào và lấy một đối tượng ra khỏi queue được gọi lần lượt là "enqueue" và "dequeue". Việc thêm một đối tượng luôn diễn ra ở cuối queue và một phần tử luôn được lấy ra từ đầu queue.

2. Các thành phần cơ bản:a. Constructor:- Queue(): khởi tạo một queue rỗng.- Queue(Icollection col): khởi tạo một queue mới có các phần tử được sao chép từ một mảng (hay list, …) khác.- Queue(int capacity): khởi tạo một queue mới có kích thước cho sẵn.b. Properties:- Count: trả về số phần tử trong queue.c. Method:- Enqueue(object obj): thêm một phần tử vào cuối queue.- Dequeue(): trả về phần tử nằm ở đầu queue và xóa nó khỏi queue.- Peek(): trả về phần tử nằm ở đầu queue mà không xóa nói khỏi queue.- Clear(): xóa tất cả phần tử trong queue.- Contains(): kiểm tra một giá trị có nằm trong queue hay không.

3. Chú ý:- Kích thước của queue là số phần tử mà queue có thể lưu trữ. Khi thêm một phần tử vào queue, kích thước của queue có thể tự động được tăng lên

bằng cách cấp phát lại bộ nhớ. Chúng ta cũng có thể giảm kích thước bộ nhớ của queue bằng cách gọi hàm TrimToSize.- Số gia (growth factor) là số lần mà kích thước của queue sẽ được nhân lên khi có yêu cầu vượt quá kích thước hiện tại của queue. Số gia mặc định là 2. Tuy nhiên, số gia tối thiểu luôn là 4. Giả sử ta gán số gia là 1 nhưng thực tế khi có yêu cầu, kích thước bộ nhớ của queue vẫn tăng lên 4 lần.- Queue chấp nhận giá trị null và các giá trị trùng lặp.

4. Code ví dụ:

using System;using System.Collections;public class SamplesStack{

public static void Main() {

// Creates and initializes a new queue. Queue myQueue = new Queue(); myQueue.Enqueue("We"); myQueue.Enqueue("are"); myQueue.Enqueue("the"); myQueue.Enqueue("world");

// Displays the properties and values of the Stack. Console.WriteLine("myQueue"); Console.WriteLine("\tCount: {0}\n", myQueue.Count); PrintValues(myQueue); Console.WriteLine("(Peek)\t{0}\n", myQueue.Peek()); PrintValues(myQueue); Console.WriteLine("(Pop)\t{0}\n", myQueue.Dequeue()); PrintValues(myQueue); Console.WriteLine("'We' is in myQueue: {0}\n", myQueue.Contains("Hello")); Console.ReadLine(); }

public static void PrintValues(IEnumerable myCollection) { Console.WriteLine("myQueue:"); foreach (Object obj in myCollection) Console.WriteLine(" {0}", obj); Console.WriteLine(); }

}

/*myQueue Count: 4

myQueue: We are the

world

(Peek) We

myQueue: We are the world

(Pop) We

myQueue: are the world

'We' is in myQueue: False*/