# 【Unity数据结构】

# 数组（Array）

是一种能够存储固定大小的同类型元素序列的数据结构，可以通过索引访问元素。以下是在Unity中使用Array的一个简单示例：

using UnityEngine;

public class ArrayExample : MonoBehaviour
{
    // 声明一个整型数组，包含5个元素
    int[] numbers = new int[5];
    // 也可以new的同时加上初始数据
    // int[] numbers = new int[]{1,3,5,7,9};

    void Start()
    {
        // 通过索引设置数组中的元素值
        numbers[0] = 1;
        numbers[1] = 3;
        numbers[2] = 5;
        numbers[3] = 7;
        numbers[4] = 9;

        // 循环遍历数组并输出每个元素的值
        for (int i = 0; i < numbers.Length; i++)
        {
            Debug.Log("Element " + i + " = " + numbers[i]);
        }
    }
}

# 列表（List）

是一种可变大小的同类型元素序列，提供了添加、删除、排序等操作。在Unity中使用List的一个简单示例：

using System.Collections.Generic;
using UnityEngine;

public class ListExample : MonoBehaviour
{
    // 声明一个整型列表
    List<int> numbers = new List<int>();

    void Start()
    {
        // 添加元素到列表中
        numbers.Add(1);
        numbers.Add(3);
        numbers.Add(5);
        numbers.Add(7);
        numbers.Add(9);

        // 循环遍历列表并输出每个元素的值
        foreach (int num in numbers)
        {
            Debug.Log("Element = " + num);
        }

        // 通过索引访问列表中的元素
        int firstElement = numbers[0];
        int lastElement = numbers[numbers.Count - 1];
        Debug.Log("First Element = " + firstElement);
        Debug.Log("Last Element = " + lastElement);

        // 删除列表中的元素
        numbers.Remove(5);
        numbers.RemoveAt(3);

        // 排序列表中的元素
        numbers.Sort();

        // 循环遍历排序后的列表并输出每个元素的值
        foreach (int num in numbers)
        {
            Debug.Log("Sorted Element = " + num);
        }
    }
}

在实际应用中，List通常用于动态存储数据，例如游戏中的角色列表、物品列表等。

# 队列（Queue）

是一种先进先出（FIFO）的数据结构，元素在队列尾部添加，从队列头部删除。以下是一个简单的例子：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class QueueExample : MonoBehaviour
{
    void Start()
    {
        Queue<string> queue = new Queue<string>();
        queue.Enqueue("First");
        queue.Enqueue("Second");
        queue.Enqueue("Third");

        Debug.Log("Queue count: " + queue.Count); // 输出队列元素数量

        while (queue.Count > 0)
        {
            string item = queue.Dequeue(); // 获取队列首元素，并将其从队列中移除
            Debug.Log("Queue item: " + item); // 输出队列元素
        }
    }
}

# 栈（Stack）

是一种后进先出（LIFO）的数据结构，元素在栈顶添加，从栈顶删除。以下是一个使用Stack类的简单示例：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class StackExample : MonoBehaviour
{
    void Start()
    {
        // 创建一个新的堆栈
        Stack<string> myStack = new Stack<string>();

        // 向堆栈中添加元素
        myStack.Push("元素1");
        myStack.Push("元素2");
        myStack.Push("元素3");

        // 查看堆栈顶部元素
        string topElement = myStack.Peek();
        Debug.Log("堆栈顶部元素是：" + topElement);

        // 弹出堆栈顶部元素
        string poppedElement = myStack.Pop();
        Debug.Log("弹出的元素是：" + poppedElement);

        // 再次查看堆栈顶部元素
        topElement = myStack.Peek();
        Debug.Log("堆栈顶部元素是：" + topElement);
    }
}

# 字典（Dictionary）

是一种键值对的数据结构，通过键访问值，可以用来存储一些相关的信息。下面是一个简单的示例：

using System.Collections.Generic;
using UnityEngine;

public class DictionaryExample : MonoBehaviour
{
    private Dictionary<string, int> scoreDictionary;

    void Start()
    {
        // 初始化Dictionary
        scoreDictionary = new Dictionary<string, int>();

        // 添加键值对
        scoreDictionary.Add("Alice", 100);
        scoreDictionary.Add("Bob", 85);
        scoreDictionary.Add("Charlie", 92);

        // 获取特定键的值
        int aliceScore = scoreDictionary["Alice"];
        Debug.Log("Alice's score is: " + aliceScore);

        // 遍历Dictionary中的所有键值对
        foreach (KeyValuePair<string, int> kvp in scoreDictionary)
        {
            Debug.Log("Key = " + kvp.Key + ", Value = " + kvp.Value);
        }

        // 检查是否包含指定的键
        if (scoreDictionary.ContainsKey("Bob"))
        {
            Debug.Log("Bob is in the dictionary.");
        }

        // 移除指定的键值对
        scoreDictionary.Remove("Charlie");
    }
}

# 集合（HashSet）

是一种不允许重复元素的集合，提供了添加、删除、交集、并集等操作。以下是一个示例：

using System.Collections.Generic;

public class MyScript : MonoBehaviour
{
    HashSet<string> myHashSet = new HashSet<string>();

    void Start()
    {
        // 添加元素到HashSet
        myHashSet.Add("Apple");
        myHashSet.Add("Banana");
        myHashSet.Add("Orange");

        // 遍历HashSet中的元素
        foreach(string element in myHashSet)
        {
            Debug.Log(element);
        }

        // 检查HashSet中是否包含某个元素
        if(myHashSet.Contains("Apple"))
        {
            Debug.Log("HashSet contains Apple.");
        }

        // 从HashSet中删除元素
        myHashSet.Remove("Banana");

        // 清空HashSet中的所有元素
        myHashSet.Clear();
    }
}

# 链表（LinkedList）

是一种通过链接相邻节点来表示数据的数据结构，可以用于实现队列和栈等数据结构。下面是一个简单的示例代码：

using System.Collections.Generic;

public class Example : MonoBehaviour
{
    void Start()
    {
        // 创建一个空的链表
        LinkedList<int> myLinkedList = new LinkedList<int>();

        // 向链表中添加元素
        myLinkedList.AddFirst(3);
        myLinkedList.AddLast(5);
        myLinkedList.AddAfter(myLinkedList.First, 7);

        // 遍历链表
        foreach (int i in myLinkedList)
        {
            Debug.Log(i);
        }
    }
}

← 【委托】【事件】 →