之前编写了自己的数组，下来基于之前的基础之上实现了栈的基本内容
namespace DataStructure
{
class Program
{
/// <summary>
/// 动态数组
/// </summary>
/// <typeparam name="E"></typeparam>
public class Array<E>
{
private E[] data;
private int size;
//构造函数，传入数组的容量capacity构造Array
public Array(int capacity)
{
data = new E[capacity];
//data = (E{ })new object[capacity];
size = 0;
}
//无参数构造函数，传入数组的容量capacity=10
public Array() : this(10)
{
}
//获取数组元素个数
public int getSize()
{
return size;
}
//获取数组的容量
public int getCapacity()
{
return data.Length;
}
//返回数组是否为空
public bool isEmpty()
{
return size == 0;
}
//向所有元素之后添加一个新元素
public void addLast(E e)
{
add(size, e);
}
public void addFirst(E e)
{
add(0, e);
}
//在index位置插入一个新元素e
public void add(int index, E e)
{
if (size == data.Length)
//扩容两倍
resize(2 * data.Length);
if (index < 0 || index > size)
throw new ArgumentException("Add failed.Require index < 0 || index > size");
for (int i = size - 1; i >= index; i--)
data[i + 1] = data[i];
data[index] = e;
size++;
}
//扩容数组
private void resize(int newCapacity)
{
E[] newData = new E[newCapacity];
for(int i = 0; i < size; i++)
{
newData[i] = data[i];
}
data = newData;
}
//获取index索引位置的元素
public E get(int index)
{
if (index < 0 || index >= size)
throw new ArgumentException("Get failed.Index is illegal");
return data[index];
}
public E getLast()
{
return get(size - 1);
}
public E getFirst()
{
return get(0);
}
//修改index索引位置的元素e
void set(int index, E e)
{
if (index < 0 || index >= size)
throw new ArgumentException("Set failed.Index is illegal");
data[index] = e;
}
//查找数组中是否有元素e
public bool contains(E e)
{
for (int i = 0; i < size; i++)
{
if (data[i].Equals(e))
return true;
}
return false;
}
//查找数组中元素e所在的索引，如果不存在元素e，则返回-1
public int find(E e)
{
for (int i = 0; i < size; i++)
{
if (data[i].Equals(e))
return i;
}
return -1;
}
//删除指定索引位置的元素
public E remove(int index)
{
if (index < 0 || index >= size)
throw new ArgumentException("Get failed.Index is illegal");
E ret = data[index];
for (int i = index + 1; i < size; i++)
{
data[i - 1] = data[i];
}
size--;
data[size] = default(E);
//元素减少到容量的1/2时，数组容量减少一半
if (size == data.Length / 2)
resize(data.Length / 2);
return ret;
}
//从数组中删除第一个元素，返回删除的元素
public E removeFirst()
{
return remove(0);
}
//从数组中删除最后一个元素，返回删除的元素
public E removeLast()
{
return remove(size - 1);
}
//从数组中删除元素e（只删除一个e）
public void removeElement(E e)
{
int index = find(e);
if (index != -1)
remove(index);
}
//重写ToString
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append($"Array:size = {size}, capacity = {getCapacity()}\n");
sb.Append("[");
for (int i = 0; i < size; i++)
{
sb.Append(data[i]);
if (i != size - 1)
sb.Append(",");
}
sb.Append("]");
return sb.ToString();
}
}
public class Student
{
private string name;
private int score;
public Student(string studentName, int studentScore)
{
name = studentName;
score = studentScore;
}
public override string ToString()
{
return String.Format("Student(name: {0:s},score: {1:d})", name, score);
}
}
public interface Stack<E>
{
int getSize();
bool isEmpty();
void push(E e);
E pop();
E peek();
}
public class ArrayStack<E> : Stack<E>
{
Array<E> array;
public ArrayStack(int capacity)
{
array = new Array<E>(capacity);
}
public ArrayStack()
{
array = new Array<E>();
}
int Stack<E>.getSize()
{
return array.getSize();
}
bool Stack<E>.isEmpty()
{
return array.isEmpty();
}
E Stack<E>.peek()
{
return array.getLast();
}
E Stack<E>.pop()
{
return array.removeLast();
}
void Stack<E>.push(E e)
{
array.addLast(e);
}
public int getCapacity()
{
return array.getCapacity();
}
public void push(E e)
{
array.addLast(e);
}
public E pop()
{
return array.removeLast();
}
public E peek()
{
return array.getLast();
}
public override string ToString()
{
StringBuilder res = new StringBuilder();
res.Append("Stack: ");
res.Append("[");
for(int i = 0; i < array.getSize(); i++)
{
res.Append(array.get(i) );
if(i!= array.getSize() - 1)
{
res.Append(", ");
}
}
res.Append("] top");
return res.ToString();
}
}
}
上面是栈的基本实现，下来写个测试类测试一下
static void Main(string[] args)
{
ArrayStack<int> stack = new DataStructure.ArrayStack<int>();
for(int i = 0; i < 5; i++)
{
stack.push(i);
Console.WriteLine(stack);
}
stack.pop();
Console.WriteLine(stack);
Console.ReadKey();
}
}
测试结果
