C \ # 사용자 정의 LinkedList 와 ArrayList 구현
21040 단어 C#
이 글 은 제 가 실습 단계 에서 연습 한 문제 입 니 다. 코드 는 제 사상 과 지도 교수 님 의 지 도 를 받 아 쓴 것 입 니 다. 저 는 제 프로 그래 밍 능력 이 어느 정도 향상 되 었 다 고 생각 합 니 다. 그래서 저 는 코드 를 공유 하고 필요 한 사람들 을 도 울 수 있 기 를 바 랍 니 다.
제목 설명:
소개: 링크 의 데이터 구 조 를 작성 하고 IList 인 터 페 이 스 를 실현 해 야 합 니 다.
구체 적 인 요구:
1、 코드 규범 을 사용 하 다.
2、 적어도 IList 의 Add, Remove, Insert, Indexer, IEnumerator 에 대해 유닛 테스트 를 실시 합 니 다.
3、 상기 각 단원 테스트 방법 에 대해 적어도 4 가지 서로 다른 단원 테스트 를 쓴다.
4、 Object 에서 파생 하여 System. collections. Generic. IList 를 실현 할 것 을 요구 합 니 다.
5、 내부 저장 소 는. NET 내 장 된 링크 를 사용 할 수 없습니다.
분석: 제목 은 linkedList (내부 에서 링크 를 사용 하여 실현) 를 실현 해 야 한다. 여기 서 저 는 Array List (내부 에서 배열 을 사용 하여 실현) 를 실 현 했 습 니 다. 이 두 가지 방식 으로 링크 를 실현 하면 저 는 실현 중의 일부 변수 임계 조건 에 대해 더욱 정확 한 판단 을 했 고 지도 교수 님 의 지 도 를 통 해 프로 그래 밍 에 대한 인식 이 어느 정도 향상 되 었 습 니 다.
ArrayList. cs = 배열 + 교체 기 + 정밀 한 제어 및 이상
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
namespace MyList
{
public class ArrayList : IList
{
///
/// default capacity
///
private int defaultCapacity;
///
/// storage data
///
private T[] array;
///
/// number of elements
///
private int count;
///
/// ， 1，
/// dilatancy factor, the default is 1 that is double expansion
///
private double dilatancyFactor;
///
/// custom iterator
///
private MyIEnumerator myIEnumerator;
///
/// init data
///
private void initData()
{
Debug.WriteLine("init data ......");
defaultCapacity = 8;
count = 0;
dilatancyFactor = 1;
}
public ArrayList()
{
initData();
array = new T[defaultCapacity];
myIEnumerator = new MyIEnumerator(this.array);
}
public ArrayList(int capacity)
{
initData();
this.defaultCapacity = capacity;
array = new T[defaultCapacity];
myIEnumerator = new MyIEnumerator(this.array);
}
public ArrayList(double dilatancyFactor)
{
initData();
this.dilatancyFactor = dilatancyFactor;
array = new T[defaultCapacity];
myIEnumerator = new MyIEnumerator(this.array);
}
public ArrayList(int capacity, double dilatancyFactor)
{
initData();
this.defaultCapacity = capacity;
this.dilatancyFactor = dilatancyFactor;
array = new T[defaultCapacity];
myIEnumerator = new MyIEnumerator(this.array);
}
public T this[int index] {
get {
if(index < 0 || index >= count)
{
throw new ArgumentOutOfRangeException("index");
} else
{
return array[index];
}
}
set {
if (index < 0 || index >= count)
{
throw new ArgumentOutOfRangeException("index");
}
else
{
array[index] = value;
}
}
}
public int Count => count;
public bool IsReadOnly => false;
///
/// add element
///
/// element
public void Add(T item)
{
if (count >= defaultCapacity)
{
Reset();// dilatation
}
array[count++] = item;
}
public void Clear()
{
T[] newArray = new T[this.defaultCapacity];
this.array = newArray;
count = 0;// count 0
}
public bool Contains(T item)
{
int index = this.IndexOf(item);
if(index == -1)
{
Debug.WriteLine("list no exit this item");
throw new ArgumentException("item");
} else
{
return true;
}
}
///
/// copy the element from list to array and start with arrayIndex
///
/// target array
/// arrayIndex
public void CopyTo(T[] array, int arrayIndex)
{
int targetArrayLength = array.Length;
//first judge whether the target arrayIndex is mistaken
if(arrayIndex < 0 || arrayIndex >= targetArrayLength)
{
Debug.WriteLine("arrayIndex out of bound");
throw new ArgumentOutOfRangeException("arrayIndex");
}
//second judge whether the array capacity is mistaken
if(this.count + arrayIndex > targetArrayLength)
{
throw new ArgumentException("array");
} else
{
//copy
Array.Copy(this.array, 0, array, arrayIndex, count);
}
}
///
/// get the list enumerator
///
///
public IEnumerator GetEnumerator()
{
// new ， ，
// （ ） reset ，
//return (IEnumerator)new MyIEnumerable(this.array);
// ， ，
return (IEnumerator)this.myIEnumerator;
}
///
/// return the item's index
///
/// value
/// if -1 is returned,it means that this element is not found
public int IndexOf(T item)
{
int index = -1;
for(int i = 0; i < count; i++)
{
try
{
if(Object.Equals(array[i], item))
{
return i;
}
//if (array[i].Equals(item))
//{
// return i;
//}
}
catch (NullReferenceException e)
{
Debug.WriteLine(" ， ");
throw e;
}
}
return index;
}
///
/// intert an element to list
///
/// the index in array
/// the value
public void Insert(int index, T item)
{
if (index >= count)//
{
Debug.WriteLine("insert method' argument has error");
throw new ArgumentOutOfRangeException("index");
} else
{
if (count >= defaultCapacity)//
{
Reset(); //
}
//
for (int i = count; i > index; i--)
{
array[i] = array[i - 1];
}
//
array[index] = item;
count++;
}
}
///
/// remove the element in list
///
///
///
public bool Remove(T item)
{
int index = -1;
//
for(int i = 0; i < count; i++)
{
if (array[i].Equals(item))
{
index = i;
break;
}
}
//
if(index == -1)
{
Debug.WriteLine("the will be removed element does not exist");
return false;
}
//
for (int j = index; j < count - 1; j++)
{
array[j] = array[j + 1];
}
count--;
return true;
}
///
/// remove element according to the index
///
/// the index
public void RemoveAt(int index)
{
if(index >= count)
{
Debug.WriteLine("the argument 'index' out of range");
throw new IndexOutOfRangeException("index");
} else
{
for (int i = index; i < count - 1; i++)
{
array[i] = array[i + 1];
}
}
}
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("[");
for (int i = 0; i < count; i++)
{
stringBuilder.Append(array[i] + ((i != count - 1) ? "," : ""));
}
stringBuilder.Append("]");
return stringBuilder.ToString();
}
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
public int GetCapacity()
{
return defaultCapacity;
}
///
/// reset configuration argument
///
private void Reset()
{
Console.WriteLine(" ……");
//
defaultCapacity += Convert.ToInt32(defaultCapacity * dilatancyFactor);
T[] newArray = new T[defaultCapacity];
//
for (int i = 0; i < array.Length; i++)
{
newArray[i] = array[i];
}
//
array = newArray;
//
this.myIEnumerator = new MyIEnumerator(array);
}
///
/// set the element according to the index
///
///
///
private void SetValue(int index, T value)
{
if(index >= count)
{
throw new IndexOutOfRangeException("index");
} else
{
array[index] = value;
}
}
}
enum ErrorStatus
{
NO_ELEMENT_TO_BE_DELETE,
THE_ELEMENT_INDEX_ERROR,
THE_TARGET_ARRAY_INDEX_ERROR,
THE_TARGET_ARRAY_LENGTH_TOO_SMALL,
THE_INDEX_OUT_OF_BOUND,
}
class MyException : ApplicationException
{
private String message;
private ErrorStatus status;
public MyException(String message, ErrorStatus status)
{
this.message = message;
this.status = status;
}
public String Info()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("Exception info { ");
stringBuilder.Append("message : [" + this.message + "], ");
stringBuilder.Append("status : [" + this.status + "]");
stringBuilder.Append(" }");
return stringBuilder.ToString();
}
}
///
/// custom iterator
///
///
class MyIEnumerator : IEnumerator
{
T[] array;
int index = -1;
int count;
public MyIEnumerator(T[] array)
{
this.array = array;
}
public T Current => GetCurrent();
object IEnumerator.Current => GetCurrent();
public void Dispose()
{
Console.WriteLine(" ……");
}
public bool MoveNext()
{
count = this.GetCount();
index++;
return index < count;
}
public void Reset()
{
index = -1;
}
private T GetCurrent()
{
try
{
return array[index];
}
catch (IndexOutOfRangeException e)
{
Debug.WriteLine(e.Message);
throw e;
}
}
private int GetCount()
{
int i;
for(i = 0; i < array.Length; i++)
{
if(array[i] != null)
{
} else
{
break;
}
}
return i;
}
}
}
LinkedList. cs = 링크 (노드) + 교체 기 + 정교 한 제어 와 이상
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;
namespace MyList2
{
internal class MyNode
{
public T Data { get; set; }
public MyNode Next { get; set; }
public MyNode(T data)
{
this.Data = data;
}
}
public class MyLinkedList : IList
{
private MyNode _head;
private int _count = 0;
public T this[int index]
{
get
{
CheckArrayIndex(index, _count);
var node = this.FindNodeByIndex(index);
return node.Data;
}
set
{
CheckArrayIndex(index, _count);
var node = this.FindNodeByIndex(index);
node.Data = value;
}
}
public int Count => _count;
public bool IsReadOnly => false;
///
/// add element
///
///
public void Add(T item)
{
var newNode = new MyNode(item);
if (_count == 0)
{
_head = newNode;
}
else
{
this.FindNodeByIndex(_count - 1).Next = newNode;
}
_count++;
}
///
/// clear linkedList
///
public void Clear()
{
_head = null;
_count = 0;//set 0
}
///
/// judge linkedList weather contain the item
///
///
///
public bool Contains(T item)
{
int index = IndexOf(item);
if(index == -1)
{
return false;
}
return true;
}
public void CopyTo(T[] array, int arrayIndex)
{
CheckArrayIndex(arrayIndex, array.Length);
if(arrayIndex + _count > array.Length)
{
throw new ArgumentOutOfRangeException("array,arrayIndex");
}
MyNode temp = _head;
while(temp != null)
{
array[arrayIndex++] = temp.Data;
temp = temp.Next;
}
}
public IEnumerator GetEnumerator()
{
var node = _head;
while (node != null)
{
yield return node.Data;// ，
node = node.Next;
}
}
///
/// get index that the item in linkedList
///
///
///
public int IndexOf(T item)
{
int index = -1;
MyNode temp = _head;
while(temp != null)
{
index++;
//
if(System.Collections.Generic.EqualityComparer.Default.Equals(temp.Data, item))
{
return index;
}
temp = temp.Next;
}
return -1;
}
///
/// insert the item into linkedList
///
///
///
public void Insert(int index, T item)
{
CheckArrayIndex(index, _count);
var newNode = new MyNode(item);
if (index == 0)//head insert
{
newNode.Next = _head;
_head = newNode;
}
else
{
var preNode = this.FindNodeByIndex(index - 1);
newNode.Next = preNode.Next;
preNode.Next = newNode;
}
_count++;
}
///
/// delete element by item
///
///
///
public bool Remove(T item)
{
int index = this.IndexOf(item);
if(index <= -1)
{
return false;
}
this.RemoveAt(index);
return true;
}
///
/// delete element by index
///
///
public void RemoveAt(int index)
{
CheckArrayIndex(index, _count);
if (index == 0)//remove _head
{
_head = _head.Next;
}
MyNode preNode = FindNodeByIndex(index - 1);
MyNode target = FindNodeByIndex(index);
preNode.Next = target.Next;
_count--;
}
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
private MyNode FindNodeByIndex(int index)
{
MyNode result = this._head;
while (index > 0)
{
result = result.Next;
index--;
}
return result;
}
private MyNode FindNodeByValue(T value)
{
MyNode temp = this._head;
while(temp != null)
{
if(System.Collections.Generic.Comparer.Equals(temp.Data, value))
{
return temp;
}
}
return null;
}
///
/// check index order by array.length
///
///
///
private void CheckArrayIndex(int index, int length)
{
if (index < 0 || index >= length)
{
throw new ArgumentOutOfRangeException("index");
}
}
public override string ToString()
{
return string.Join(",", this);
//return String.Join(",", this);
}
}
class MyIEnumerator : IEnumerator {
MyNode head;
MyNode current;
public MyIEnumerator(MyNode head)
{
this.head = head;
this.current = head;
}
public T Current => GetCurrent();
object IEnumerator.Current => GetCurrent();
public void Dispose()
{
Console.WriteLine(" ……");
}
public bool MoveNext()
{
if(current != null)
{
if(current == head)
{
return true;
}
current = current.next;
return true;
}
return false;
}
private T GetCurrent()
{
return current.data;
}
///
/// reset the head
///
///
public void _ResetHead(MyNode head)
{
this.head = head;
}
public void Reset()
{
throw new NotImplementedException();
}
}
}
요약:
이번 연습 을 통 해 저 는 Array List 와 LinkedList 에 대해 더욱 깊 은 이 해 를 가지 게 되 었 고 제 프로 그래 밍 능력 도 어느 정도 향상 되 었 습 니 다. 인 코딩 과정 에서 문법 에 대한 고려 뿐만 아니 라 문 제 를 처리 하 는 방식, 문 제 를 생각 하 는 논리, 처리 방식 의 선택 등에 대한 고려 이기 때 문 입 니 다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
WebView2를 Visual Studio 2017 Express에서 사용할 수 있을 때까지Evergreen .Net Framework SDK 4.8 VisualStudio2017에서 NuGet을 사용하기 때문에 패키지 관리 방법을 packages.config 대신 PackageReference를 사용해야...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
