1.Lista
List<int> list = new List<int>();
List<String> strings = new List<String>();
//增
list.Add(0);
list.Add(1);
List<int> ints = new List<int>();
ints.Add(0);
list.AddRange(ints);
//插入
list.Insert(0, 1);// 位置0插入1
//删
//1.移除指定元素
list.Remove(0);
//2.移除指定位置元素
list.RemoveAt(0);
//3.清空
list.Clear();
list.Add(1);
list.Add(2);
list.Add(3);
list.Add(4);
//查
//1.得到指定位置的元素
Debug.Log(list[1]);
//2.查看元素是否存在
if (list.Contains(0))
{
Debug.Log("存在0");
}
//3.正向查找元素位置
//找到返回位置找不到返回-1
int index = list.IndexOf(0);
Debug.Log(index);
//4.反向查找元素位置
// 找到返回位置找不到返回 - 1
int indexlast = list.LastIndexOf(0);
Debug.Log(indexlast);
//改
list[0] = 99;
//遍历
for (int i = 0; i < list.Count; i++)
{
Debug.Log(list[i]);
}
foreach (int item in ints)
{
Debug.Log(item);
}2.Diccionario:
Dictionary<int,string> dic = new Dictionary<int,string>();
//增
dic.Add(1, "123");
dic.Add(2, "234");
dic.Add(3, "345");
//删
//1.只能通过键去删除，删除不存在的键没反应
dic.Remove(1);
dic.Remove(4);
//2.清空
dic.Clear();
dic.Add(1, "123");
dic.Add(2, "234");
dic.Add(3, "345");
//查
//1.通过键查看值
//找不到直接报错！！！！！！
Debug.Log(dic[1]);
//2.查看是否存在
//根据键查
if (dic.ContainsKey(1)) { Debug.Log("存在键为1"); };
//根据值查
if (dic.ContainsValue("123")) { Debug.Log("存在值为123的"); };
//改
dic[1] = "999";
//遍历
//1.遍历键
//2.遍历值
//3.遍历全部
foreach (var item in dic.Keys)
{
Debug.Log(item);
Debug.Log(dic[item]);
}
foreach (var item in dic.Values)
{
Debug.Log(item);
}
foreach (KeyValuePair<int,string> item in dic)
{
Debug.Log("键" + item.Key + "值" + item.Value);
}
string[] str = { "壹", "贰", "叁", "肆", "伍","陆", "柒", "捌", "玖", "拾" };
Dictionary<string,string> dic = new Dictionary<string,string>();
for (int i = 0; i < str.Length; i++)
{
dic.Add(i.ToString(), str[i]);
}
string rang = UnityEngine.Random.Range(0,1000).ToString();
//Debug.Log(rang);
foreach (var item in rang)
{
if(dic.ContainsKey(item.ToString()))
{
Debug.Log(dic[item.ToString()]);
}
}3. Estructura de datos:
la estructura de datos es la forma (reglas) en que una computadora almacena y organiza los datos.
La estructura de datos se refiere a una colección de elementos de datos que tienen una o más relaciones específicas entre sí.
Por ejemplo, una clase personalizada también se puede llamar estructura de datos, una regla de combinación de datos autodefinida.
En pocas palabras, es una regla definida por humanos para almacenar datos y expresar la relación entre datos.
Estructuras de datos de uso común (algunas reglas clásicas resumidas y formuladas por sus predecesores)
matriz, pila, cola, lista vinculada, árbol, gráfico, montón, tabla hash (tabla hash)
Una lista lineal es una estructura de datos, que es una secuencia limitada de n elementos de datos con las mismas características,
como matriz, lista de matrices, pila, cola, lista vinculada, etc.
El almacenamiento secuencial y el almacenamiento en cadena son dos estructuras de almacenamiento en las estructuras de datos
: Matriz, Pila, Cola, Lista, Lista de matrices: almacenamiento secuencial.
Solo las reglas de organización de matriz, Pila y Cola son diferentes.
Almacenamiento secuencial:
utilice un conjunto de unidades de almacenamiento con direcciones consecutivas para almacenar secuencialmente cada elemento de datos de la tabla lineal.
Lista enlazada unidireccional, lista enlazada bidireccional, lista enlazada circular y almacenamiento enlazado
Almacenamiento encadenado (almacenamiento vinculado):
utilice un conjunto de unidades de almacenamiento arbitrarias para almacenar cada elemento de datos en una tabla lineal.
public class test : MonoBehaviour
{
private void Start()
{
LinkList<int> linkList = new LinkList<int>();
linkList.Add(0);
linkList.Add(1);
linkList.Add(2);
linkList.Add(3);
LinkNode<int> node = linkList.head;
while (node != null)
{
Debug.Log(node.value);
node = node.nextNode;
}
linkList.Remove(2);
node = linkList.head;
while (node != null)
{
Debug.Log(node.value);
node = node.nextNode;
}
linkList.Remove(0);
node = linkList.head;
while (node != null)
{
Debug.Log(node.value);
node = node.nextNode;
}
}
}
class LinkNode<T>
{
public T value;
public LinkNode<T> nextNode;
public LinkNode(T t)
{
this.value = t;
}
}
class LinkList<T>
{
public LinkNode<T> head;
public LinkNode<T> tail;
public void Add(T value)
{
LinkNode<T> node = new LinkNode<T>(value);
if(head == null)
{
head = node;
tail =node;
}
else
{
tail.nextNode = node;
tail = node;
}
}
public void Remove(T value)
{
if(head == null)
{
return;
}
if (head.value.Equals(value))
{
head = head.nextNode;
如果头结点被移除，发现头结点变空，证明只有一个节点，尾也要置空
if (head == null)
{
tail = null;
}
return;
}
LinkNode<T> node = head;
while (node.nextNode != null) {
if(node.nextNode.value.Equals(value))
{
当前找到的元素上个节点，指向自己的下个节点。
node.nextNode = node.nextNode.nextNode;
break;
}
node = node.nextNode;
}
}
}Ventajas y desventajas del almacenamiento secuencial y el almacenamiento encadenado
Piénselo desde la perspectiva de agregar, eliminar, verificar y modificar:
Agregar: el almacenamiento en cadena es computacionalmente mejor que el almacenamiento secuencial (al insertar en el medio, la cadena no necesita moverse de posición como la secuencia)
Eliminar: el almacenamiento en cadena es computacionalmente mejor que el almacenamiento secuencial (al eliminar en el medio, la cadena La fórmula no necesita mover la posición como una secuencia)
Verificar: El uso del almacenamiento secuencial es mejor que el almacenamiento en cadena (las matrices pueden obtener elementos directamente a través de subíndices y encadenar
el almacenamiento requiere recorrido) Cambio: el uso del almacenamiento secuencial es mejor que el almacenamiento en cadena (las matrices se pueden obtener elementos directamente a través de subíndices, la cadena debe atravesarse)
4. Lista enlazada
LinkedList<int> ints = new LinkedList<int>();
//增
//1.在链表尾部加元素
ints.AddFirst(0);
//2.在链表头部加元素
ints.AddLast(1);
ints.AddLast(2);
ints.AddLast(3);
ints.AddLast(4);
//3.在某一个节点之后添加一个节点
//要指定节点 先得得到一个节点
LinkedListNode<int> n = ints.Find(2);
ints.AddAfter(n, 100);
//4.在某一个节点之前添加一个节点
//要指定节点 先得得到一个节点
LinkedListNode<int> m = ints.Find(3);
ints.AddBefore(m, 120);
//删
//1.移除头结点
ints.RemoveFirst();
//2.移除尾结点
ints.RemoveLast();
//3.移除指定节点
//无法通过位置直接删除
ints.Remove(2);
//4.清空
ints.Clear();
ints.AddFirst(0);
ints.AddLast(1);
ints.AddLast(2);
ints.AddLast(3);
//查
//1.头结点
LinkedListNode<int> first = ints.First;
//2.尾结点
LinkedListNode<int> last = ints.Last;
//3.找到指定值节点
//无法直接通过下标获取中间值
//只有遍历查找指定位置元素
LinkedListNode<int> node = ints.Find(1);
//找不到返回null
//4.判断是否存在
if (ints.Contains(0))
{
Debug.Log("存在0");
}
//改
ints.First.Value = 10;
//遍历
//1.foreach
foreach (int i in ints)
{
Debug.Log(i);
}
//2.节点遍历
//头到尾
LinkedListNode<int> noeHead = ints.First;
while (noeHead != null)
{
Debug.Log(noeHead.Value);
noeHead = noeHead.Next;
}
//尾到头
noeHead = ints.Last;
while (noeHead != null)
{
Debug.Log(noeHead.Value);
noeHead = noeHead.Previous;
}
}