【C#进阶】简单数据结构类

简单数据结构类

1、Arraylist

1、ArrayList的本质

ArrayLists是一个C#为封装好的类
它的本质是一个Object类型的数组

2、声明

using System.Collections;
ArrayList array = new ArrayList();

3、增删查改

增

array.Add(1);
ArrayList array2 = new ArrayList();
array2.Add(true);
//批量增加
array.AddRange(array2);

array.Insert(1,"222");

删

移除指定元素
	array.Remove(1);
移除指定位置的元素
	array.RemoveAt(2);
清空
    array.Clear();

查

得到指定的元素
	array[0];
查看元素是否存在
    if(array.Contains("1")){
        Console.WriteLine("存在");
    }
正向查找元素位置
	找到的返回值是位置，没找到返回-1
    int index = array.IndexOf(true);
	Console.WriteLine(index);

反向查找元素位置
    int index = array.LastIndexOf(true);
	Console.WriteLine(index);

改

array[0] = "666";
Console.WriteLine(array[0]);

遍历

长度
	Console.WriteLine(array.Count);
容量
    Console.WriteLine(array.Capacity);
遍历
    for(int i = 0; i < array.Count; i++){
        Console.WriteLine(array[i]);
    }
迭代器遍历
    foreach (object item in arrayList)
	{
    	Console.WriteLine(item);
	}

4、装箱拆箱

ArrayList本质是一个可以自动扩容的object数组
存储值类型装箱，将值类型取出来拆箱
    int i = 1;
	array[0] = i;		//装箱
	i = (int)array[0];	//拆箱

思考 背包售卖

//创建一个背包管理类，使用ArrayList存储物品
//实现购买物品，卖出物品，显示物品的功能；购买与卖出会导致金钱的变化
BagMgr bag = new BagMgr(9999);
Item i1 = new Item(1,9,"药",5);
Item i2 = new Item(2,99,"书",3);
Item i3 = new Item(3,999,"刀",1);
bag.BuyItem(i1);
bag.BuyItem(i2);
bag.BuyItem(i3);

bag.SellItem(i3);
bag.SellItem(1,1);
bag.SellItem(2,1);
class BagMgr
{
    private ArrayList items;
    private int money;
    public BagMgr(int money)
    {
        this.money = money;
        items = new ArrayList();
    }
    public void BuyItem(Item item)
    {
        if (item.num <= 0 || item.money < 0)
        {
            Console.WriteLine("错误物品或金钱");
            return;
        }
        if (money < item.money * item.num)
        {
            Console.WriteLine("钱不够");
            return;
        }
        money -= item.money * item.num;
        Console.WriteLine("购买{0}{1}个，花费{2}钱，余额{3}", item.name,item.num,item.money*item.num,money);
        for (int i = 0; i < items.Count;i++)
        {
            if ((items[i] as Item).id == item.id)
            {
                (items[i] as Item).num += item.num;
                return;
            }
        }
        items.Add(item);
    }
    public void SellItem(Item item)
    {
        for (int i = 0; i < items.Count; i++)
        {
            if ((items[i] as Item).id == item.id)
            {
                int num = 0;
                string name = (items[i] as Item).name;
                int money = (items[i] as Item).money;
                if ((items[i] as Item).num > item.num)
                {
                    num = item.num;
                }
                else
                {
                    num = (items[i] as Item).num;
                    items.RemoveAt(i);
                }
                int sellMoney = money* num;
                this.money += sellMoney;
                Console.WriteLine("卖了{0}{1}个，赚了{2}，余额{3}", name, num, sellMoney, this.money);
                return;
            }
        }
        
    }
    public void SellItem(int id, int num = 1)
    {
        Item item = new Item(id,num);
        
        SellItem(item);
    }
    
    public void ShowItem()
    {
        Item item;
        for (int i = 0; i < items.Count; i++)
        {
            item = items[i] as Item;
            Console.WriteLine("有{0}{1}个", item.name, item.num);
        }
        Console.WriteLine("余额{0}",money);
    }
}
class Item
{
    public int id;
    public int money;
    public string name;
    public int num;
    public Item(int id, int num)
    {
        this.id = id;
        this.num = num;
    }
    public Item(int id, int money, string name, int num)
    {
        this.id = id;
        this.money = money;
        this.name = name;
        this.num = num;
    }
}

2、Stack

1、Stack的本质

Stack 是一个C#为我们封装好的类
它的本质是Object[]数组
Stack是栈存储容器，栈是一种先进后出的数据结构

2、声明

Stack stack = new Stack();

3、增取查改

增	//压栈
	stack.Push(1);
	stack.Push("123");
	stack.Push(true);

取 	//弹栈
    //栈中不存在删除的概念，只有取的概念
    object v1 = stack.Pop();
    Console.WriteLine(v1);

    v1 = stack.Pop();
    Console.WriteLine(v1);

查
	//栈无法查看指定位置的元素，只能查看栈顶的内容
    v1 = stack.Peek();
    Console.WriteLine(v1);

	//2、查看元素是否存在于栈中
    if (stack.Contains("123"))
    {
        Console.WriteLine("存在123");
    }

改
	//栈无法改变其中的元素，只能存和取，有清空方法
	stack.Clear();

4、遍历

1、长度
	Console.WriteLine(stack.Count);

2、用foreack遍历//遍历出来的顺序从顶到低
    foreach(object item in stack)
    {
        Console.WriteLine(item);
    }

3、将栈转换为object数组//遍历出来的顺序从顶到低
    object[] array = stack.ToArray();
    for (int i = 0; i < array.Length; i++)
    {
        Console.WriteLine(array[i]);
    }

4、循环弹栈
    while (stack.Count > 0)
    {
        object item = stack.Pop();
        Console.WriteLine(item);
    }

思考 计算一个数的二进制

//写一个方法计算任意一个数的二进制
//使用栈结构方式存储，之后打印处理
Calc(10);
static void Calc(uint num)
{
    Stack stack = new Stack();
    while (true)
    {
        stack.Push(num % 2);
        num /= 2;
        if (num == 1 || num ==0)
        {
            stack.Push(num);
            break;
        }
            
    }
    while(stack.Count > 0)
    {
        Console.Write(stack.Pop());
    }
}

3、Queue

1、Queue的本质

Stack 是一个C#为我们封装好的类
它的本质是Object[]数组
Queue是队列存储容器
队列是一种先进先出的数据结构

2、声明

Queue queue = new Queue();

3、增取查改

增
    Queue queue = new Queue();
    queue.Enqueue(1);
    queue.Enqueue("123");
    queue.Enqueue(1.3f);
取 取出先进入的对象
    object v = queue.Dequeue();
    Console.WriteLine(v);
查
	1、查看队列头部元素但不会移除
	v = queue.Peek();
	2、查看元素是否存在于队列中
    if (queue.Contains(1.3f){
        Console.WriteLine("存在");
    }
改
    queue.Clear();

4、遍历

1、长度
	Console.WriteLine(queue.Count);
2、用foreach遍历
    foreach (object o in queue)
    {
        Console.WriteLine(o);
    }
3、转换为数组for
    object[] array = queue.ToArray();
    for (int i = 0; i < array.Length; i++)
    {
        Console.WriteLine(array[i]);
    }
4、循环出列
    while (queue.Count > 0)
    {
        object o = queue.Dequeue();
        Console.WriteLine(o);
    }

思考 每隔一段时间打印一条消息

//使用队列存储消息，一次性存10条消息，每隔一段时间打印一条消息
//控制台打印消息时要有明显顿挫感
Queue queue = new Queue();
queue.Enqueue("获得44金币");
queue.Enqueue("获得装备");
queue.Enqueue("获得药草");
queue.Enqueue("获得经验");
queue.Enqueue("获得秘籍");
queue.Enqueue("获得顶级秘笈");

queue.Enqueue("获得装备");
queue.Enqueue("获得药草");
queue.Enqueue("获得经验");
queue.Enqueue("获得秘籍");
queue.Enqueue("获得无上心法");

int updateIndex = 1;
while (queue.Count > 0)
{
    if (updateIndex % 77777777 == 0)
    {
        if (queue.Count > 0)
        {
            Console.WriteLine(queue.Dequeue());
        }
        updateIndex = 0;
    }
    updateIndex++;
}

4、Hashtable

1、Hashtable本质

Hashtable（散列表）
	是基于键的哈希代码组织起来的键值对
它的主要作用是提高数据查询的效率
使用键来访问集合中的元素

2、声明

Hashtable hashtable = new Hashtable();	

3、增删查改

增 //不能出现相同的键
    hashtable.Add(1,"234");
    hashtable.Add(2,"255");
删
    //1、只能通过键去删除
    hashtable.Remove(2);
    //删除不存在的键，没反应
    //2、直接清空
    hashtable.Clear();
查
    //1、通过键查看值，找不到返回空
    Console.WriteLine(hashtable[1]);
    //2、查看书否存在
    //根据键检测
    if (hashtable.Contains(1))
    {
        Console.WriteLine("存在");
    }
    if (hashtable.ContainsKey(2))
    {
        Console.WriteLine("存在");
	}
//根据值检测
    if (hashtable.ContainsValue("255"))
    {
        Console.WriteLine("存在");
    }
    改
//只能改键对应的值内容，无法改键
    hashtable[1] = false;

4、遍历

得到键值对 对数
	Console.WriteLine(hashtable.Count);
1、遍历所有键
    foreach (Hashtable ht in hashtable.Keys)
    {
        Console.WriteLine("键" + ht);
        Console.WriteLine("值" + hashtable[ht]);
    }
2、遍历所有值
    foreach (Hashtable ht in hashtable.Values)
    {
        Console.WriteLine("值" + ht);
    }
3、键值对一起遍历
    foreach(DictionaryEntry item in hashtable)
    {
        Console.WriteLine("键" + item.Key + "值" + item.Value);
    }
4、迭代器遍历
    IDictionaryEnumerator myEnumerator = hashtable.GetEnumerator();
    bool flag = myEnumerator.MoveNext();
    while (flag)
    {
        Console.WriteLine("键" + myEnumerator.Key + "值" + myEnumerator.Value);
        flag = myEnumerator.MoveNext();
    }

思考 单例制造怪物工厂

//制作一个怪物类管理器，提供创建怪物
//移除怪物的方法，每个怪物都有自己的唯一id
MonsterMgr.Instance.AddMonster();
MonsterMgr.Instance.AddMonster();
MonsterMgr.Instance.AddMonster();
MonsterMgr.Instance.AddMonster();
MonsterMgr.Instance.AddMonster();
MonsterMgr.Instance.AddMonster();
MonsterMgr.Instance.RemoveMonster(0);
MonsterMgr.Instance.RemoveMonster(5);
class MonsterMgr 
{ 
    private static MonsterMgr instance = new MonsterMgr();
    private Hashtable monstersTable = new Hashtable();
    private MonsterMgr() { }
    public static MonsterMgr Instance
    {
        get
        {
            return instance;
        }
    }
    private int monsterID = 0;
    public void AddMonster()
    {
        Monster monster = new Monster(monsterID);
        Console.WriteLine("创建了id为{0}怪物", monsterID);
        monsterID++;
        monstersTable.Add(monster.id, monster);
        
    }
    public void RemoveMonster(int monsterID) 
    { 
        if(monstersTable.ContainsKey(monsterID))
        {
            (monstersTable[monsterID] as Monster).Dead();
            monstersTable.Remove(monsterID);
        }
    }
}
class Monster
{
    public int id;
    public Monster(int id)
    {
        this.id = id;
    }
    public void Dead()
    {
        Console.WriteLine("怪物{0}死亡",id);
    }
}