【4858.com】数组结构,unity中数据结构

By admin in 4858.com on 2019年5月3日

数组结构:

//非泛型数列抽出来都为  objec

9yue6

//数据类型要加上的命名空间

Array :在内部存款和储蓄器上是连连分配的,而且成分类型是同样的;

//栈 对列 数组 都能够纯空数据

集合(Collection

1、集结的法力:

有三种办法能够将对象分组:

一、创设对象数组  贰、创立对象集结

数组的伊始化必须求稳住数量,即数组的长度。

聚拢提供壹种灵活的拍卖办法。与数组分化,拍卖的靶子

组可按照程序改变的急需动态地巩固和减少。 对于有个别集

合,您可以为放入该群集的任何对象分配1个“键”,以

便选拔该键飞快寻觅对象。

聚焦是类,由此必须注明新集结后,才具向该会集中

添比索素。

1、创设对象数组

聚拢分为两连串型:非泛型集合和泛型集结。

运用非泛型会集的 需引进:System.Collections命名空间。

应用泛型会集需引进:System.Collections.Generic命名空间

(非泛型相比泛型效用非常的低因为要拓展装箱拆箱操作

4858.com 1

4858.com 2

using System.Collections.Generic;

特色:是读取快 能够坐标访问 然而增删慢,长度不能变

Stack

4858.com 3

定义:

Stack stack = new Stack();

Stack<int> stackInt = new Stack();

能够重写仓库

publicclass MyStack:Stack{

override

}

Stack类成员介绍

Push()将对象插入Stack的顶部(入栈)推入成分

Pop()移除并再次来到Stack顶部的对象(出栈)弹出成分

Peek()重回位于Stack顶部的对象,但不移除

Contains明确某成分是够在Stack中

Clear()从Stack中移除全数目的

Count获取Stack中包罗的要素

入栈Push

stack.Push();

出栈Pop

intnumber = (int)stack.Pop();

objectobj = stack.Pop ();

Console.WriteLine();

得到栈顶成分Peek

objectobj_1 = stack.Pop();//区别

Console.WriteLine(obj_1);

objectobj_2 = stack.Peek ();

Console.WriteLine(obj_2);

是否带有有些成分

stack.Contains(“1”);

转为数组

object[]objs =stack.ToArray();

获得栈的长度

intcount =stack.Count;

for(int i = 0; i < count; i++) {

stack.Pop();

}

/*       

比如 int[] intArray=new int[20]; intArray[3]=10;

//Stack 栈  数据结构n  可被接二连三

队列Queue

Queue成员

同样也促成了ICollection和IEnumerable

Enqueue()将对象增加到Queue的结尾处

Dequeue()移除并赶回Queue开端处的靶子

此外和Stack未有区别

Queue总结

一.先进先出(FIFO)的1种数据结构。

贰.随着向Queue 中添新币素,容积通过重新分配按需自行扩充。

可经过调用 TrimToSize 来减少容积。

3.Queue 承受 null 作为有效值并且同意再度的因素。

四.在AI寻路算法中时时用的Queue。

入队列

queue.Enqueue(“li”);

queue_2.Enqueue(1);

出队列

objectobj =queue.Dequeue();

intnumber =queue_2.Dequeue ();

赚取队列尾部成分

objectobj_1 =queue.Peek();

intnumber_1 =queue_2.Peek ();

Console.WriteLine(obj_1);

Console.WriteLine(number_1);

队列元素个数

queue_2.Count;

queue.Count;

移除多余空间

queue.TrimToSize();

Console.WriteLine(queue.Count);

查阅MSDN演练货仓,队列中的ToArrayCopyTo

 * 数据结构:        

 

int[ ] numbers = {1,2,3,5,6,7};

Dictionary字典

Dictionary(TKey,电视alue)类称为字典类

TKey表示键的类型

TValue表示字典中的值类型

Dictionary类实现了ICollection、IEnumerable、IDictionary·接口。

字典定义如下:

Dictionary<string,int >dic = new
Dictionary<string,int>();

字典中键必须是唯1的,不是全部品类都得以是键(一般是string int),

具有品类都能够视作值

4858.com 4

总结:

字典是2个泛型集结

TKey必须唯1,Value能够是变量,也能够是目的

例子:

Dictionary dic = new Dictionary();

dic.Add(“One”,1);//一组键值对

dic.Add(“Two”,2);

intnumber = dic [“One”];

dic[“One”] = 31;

intnumber_2 = dic [“One”];

Console.WriteLine(number);

Console.WriteLine(number_2);

Dictionary strDic = new Dictionary();

【4858.com】数组结构,unity中数据结构。strDic[“Li”]= “an”;//自动Add

strDic[“Li”]= “sa”;

strDic[“Li”] = null;//能够存空对象

Console.WriteLine(strDic.Count);

通过键移除对应的值

strDic.Remove(“Li”);

Console.WriteLine(strDic.Count);

是还是不是包涵键/值

if(dic.ContainsKey (“Two”)) {

Console.WriteLine(“包含Two键”);

}

if(dic.ContainsValue(2)) {

Console.WriteLine(“包含2值”);

}

打字与印刷键值对

foreach(string key in dic.Keys){

Console.WriteLine(key + “:”+dic[key]);

}

foreach(int value in dic.Values){

Console.WriteLine(“value: “+value);

}

用户输入1叁个姓名,能够再度输入同1人名,输出每种姓名,并出口种种姓名输入的多少次

Dictionary dicName = new Dictionary();

Console.WriteLine(“输入1伍次姓名”);

for(int i = 0; i <= 10; i++) {

stringstr = Console.ReadLine ();

if(dicName.ContainsKey (str)) {

dicName[str] += 1;

}else {

dicName[str] = 1;

}

}

foreach(string name in dicName.Keys) {

Console.WriteLine(name+”出现为”+dicName[name]);

}

* 1.数组:

ArrayList:在内部存款和储蓄器上是连连分配的,成分没有项目限制,任何因素都以当成object处理的,如果是值类型,会有装箱操作

string[ ] str = {“li”,”ik”,”op”};

AarryList

(非泛型比较泛型功能非常的低因为要举办李装运箱拆箱操作

ArrayList是四个古怪的数组。透过加多和删除成分,就

能够动态改动数组的尺寸

ArrayList并不是强类型,ArrayList
大概并不延续提供一定任务的超级质量。

ArrayList类达成了IList、ICollection和IEnumerable接

口。

4858.com 5

int[]numbers = {1,23,4,5,11,44};

ArrayList arrayList = new ArrayList (numbers
);//默以为二个长短为0的数组

Add添加

arrayList.Add(“Wo”);

arrayList.AddRange(new int []{9,8,7});

Remove移除

arrayList.Remove(23);//元素

arrayList.RemoveAt(2);//位置

arrayList.RemoveRange(一,二);//从下标壹始发数两为获得逆序数组

arrayList.Reverse();//(能够写贰个范围的逆序)

七个目的作相比较

arrayList.Equals();

从下标二开首以后截取两位

ArrayListarr = arrayList.GetRange (2, 2);

探求数组成分下标(在数组中的第一个)

intfirstIndex = arrayList.IndexOf(“Wo”);

intlastIndex = arrayList.LastIndexOf (“Wo”);

安顿成分/数组

arrayList.Insert();

arrayList.InsertRange();

改造元素

arrayList.SetRange(2,new string []{“la”,”do”,”bili”});

遍历集结

foreach(object obj in arrayList) {

Console.Write(obj+” “);

}

ArrayList总结:

1.支撑活动改动大小的法力。

2.足以灵活的插入元素、删除成分、访问成分。

叁.不是强类型,速度跟数组比起来要慢。

相对于ArraryList来讲,List在大部状态下推行越来越好,更安全

壹旦对类型T只用值类型的话,相比速度得考虑装箱开箱的标题

特征 一.分寸固定 二.内存三番五次,能够经过下标访问 3.只可以存款和储蓄一种数据类型  
  

  不定长度的  Add扩张长度 索引赋值不会追加长度;读取快  增加和删除慢;

Stack stack = new Stack(str);         //动态分配 开首为0 能够三番五次参与自定义体量大小

List(泛型)

List类表示可经过索引访问的靶子的强类型列表
提供用于对列表实行搜寻、排序和操作的不二等秘书技。List是ArrayList类的泛型等效类,该类应用大小可按需动态扩充的数组达成IList泛型接口。List类同样也是促成了

ICollection、IEnumerable和IList接口。

4858.com 6

例子:

Listnumbers = new List (new int[]{12,3,44,1,15,2});

排序

numbers.Sort();

foreach(int n in numbers ) {

Console.WriteLine(n);

}

int[] array = new int[5]{ 1,2,3,4,5};

int[][] array2 = new int[5][];//动态开荒内部存款和储蓄器

array2[0] = new int[3];//不规则数组

ArrayList arrayList=new ArrayList();

自学Hashtable和SortedList。


arrayList.Add(“001”);

//入栈  push

索引器

(索引器能够重载

4858.com 7

* 2.ArrayList:数组列表          

arrayList.Add(“002”);

stack.Push(1);

总结:

一.数据类型是意味着将要存取的数组或集结成分的品种。

2.索引器类型表示该索引器使用哪一品种的目录来存取

数组或集结成分,能够是整数,能够是字符串;

this代表操作本对象的数组或集合成员,能够大约把它知道成索引器的名字,由此索引器无法享有用户定义的名称.

4858.com 8

4858.com 9

创办一个索引器,对类里面的字典实行数据的存取,用来记录学生的姓名和分数

4858.com 10

*  特点:一.大小不固定 贰.内部存款和储蓄器三番五次,可以透过下标访问 3.方可储存5体系型 
      

arrayList.Remove(“Eleven”);

//出栈  pop  (移除并回到该值)

归纳:

Stack于Queue有哪些差距。

Dictionary有如何长处?

ArrayList和List的比较。

 *  缺点:装箱和拆箱(时间和脾性上的开销)        

array[2]=32;

int number = (int)stack.Pop();      //强转类型

 *  装箱:将值类型转化成引用类型.        

//删除数据

object obj = stack.Pop();

 *  拆箱:将引用调换来值类型.       

 

Console.WriteLine (obj.ToString());       //op

ArrayList arraylist = new ArrayList();

//添美元素的法子

arraylist.Add(1);//int – Object

int i = 1;

System.Object o = i;//装箱

arraylist.Add(“HelloWorld”);

arraylist.Add(transform);

//访问成分的秘籍:通过下标访问,下标从0开始

print(arraylist[0]);

i = (int)o;//拆箱

List:大旨也是Array 内部存款和储蓄器上是接连分配的 能够用索引访问 不定长度
;泛型,保障项目安全,制止装箱拆箱;读取快,增加和删除慢;


List<string> stringList=new List<string>();

//获取栈顶成分 peek(不会移除)

 * 3.List:列表        

stringList.Add(“001”);

object obj_1 = stack.Peek();

 *  特点:一.高低不固定  二.内部存储器三番五次,能够经过下标访问
三.不得不存款和储蓄壹种数据类型            

 

Console.WriteLine (obj_1);          //ik

    缺点:不便利增多和删除元素.   

链表类型

object obj_2 = stack.Peek();        //ik

Listlistint = new List();   

//添欧成分的点子

listint.Add(1);

listint.Add(2);

//访问成分的措施:通过下标访问

print(listint[0]);

LinkedList:泛型的,链表
成分不三番五次分配,每一个成分都有记录前后节点;

Console.WriteLine (obj_2);


不可能经过坐标访问,
找成分,只可以遍历,查找不便于;增加和删除比较方便;

//是不是包涵某些成分

 * 肆.LinkedList:双向链表        

LinkedList<int> linkedList=new
LinkedList<int>();

stack.Contains(“2”);

 *  特点:壹.大小不固定 二.内部存款和储蓄器不总是  三.只可以存款和储蓄1种数据类型
四.方便插入和删除元素    

linkedList.AddFirst(1);

//转为数组

    LinkedListlinkedList = new LinkedList();        

   //添加        

    linkedList.AddLast(1);//push_back        

    linkedList.AddFirst(2);//push_front        

   linkedList.AddAfter();//insert        

   //访问元素        

   LinkedListNodenode = linkedList.First;//访问链表的首先个节点

   linkedList.Last;//链表的终极3个因素

  for(;node != null;node = node.Next)

 {

    print(node.Value);//访问到节点的值

 }

foreach(int item in linkedList)

{

    print(item);

 }

linkedList.AddLast(10);

object[ ] objs = stack.ToArray();


bool
isContain=linkedList.Contains(123);

//获取栈的长短

 * 伍.栈:先进后出 Stack      

LinkedListNode<int>
node123=linkedList.Find(123);

int count = stack.Count;

Stacks = new Stack(); 

s.Push(1);//入栈

s.Push(2);

print(s.Peek());//再次回到栈顶成分 贰

print(s.Pop());//重临栈顶成分并剔除栈顶成分 二

print(s.Peek()); //1

linkedList.AddBefore(node123,10);

//输出栈里的有所因素


linkedList.AddAfter(node123,11);

for (int i = 0; i < count; i++) {

 * 陆.队列:先进先出 Quene    

linkedList.Remove(123);

      stack.Pop ();

Queueq = new Queue(); 

q.Enqueue(1);//入队

q.Dequeue();//再次来到队列的率先个成分并且删除

//print(q.Peek());//再次来到队列的第3个元素

linkedList.RemoveFirst();

}


linkedList.RemoveLast();

//Queue  对列

 * 7.键值对:C++:mapC#:字典

 

Queue queue = new Queue(stack);    //暗中同意或起首体量

Dictionarydic<string, int> dic = new Dictionary<string,
int>();

//增加键值对

dic.Add(“Score”, 100);

dic.Add(“Hp”, 200);

//访问键值对

int score;

dic.TryGetValue(“Score”, out score);

score = dic[“Score”];

//访问具备的键,访问具备的值

//dic.Keys;

//dic.Values;

foreach(int item in dic.Values)

{

print(item);

}

Queue: 队列,正是链表, 先进先出, 如职分延迟施行,A不断地写入职分B不断得到职务去试行;

Queue<int>queue_1 = new Queue();          //泛型定义为int 
只好传入int类

Queue<int> numbers=new Queue<int>();

numbers.Enqueue(1);

//入对列

numbers.Enqueue(2);

queue.Enqueue(“wang”);

numbers.Enqueue(3);

queue_1.Enqueue (5);

numbers.Dequeue();//移除

//出对列

numbers.Peek();//不移除

object ob = queue.Dequeue();

 

int num = queue_1.Dequeue ();

Stack: 栈,是链表, 先进后出

//获取对列尾部成分

Stack<int> numbers=new Stack<int>();

object ob_1 = queue.Peek();

numbers.Push(1);

int num_1 = queue_1.Peek();

numbers.Push(2);

Console.WriteLine (ob_1);

numbers.Push(3);

//对列元素个数

numbers.Push(4);

queue_1.Count;

numbers.Pop();//读取并移除

queue.Count;

numbers.Peek();//读取不移除

//移除非泛型多余空间

 

queue.TrimToSize();

集合Set

//Dictionary  字典    值能够再次 键不行

HashSet:hash布满 成分间未有涉嫌 动态扩展的 会自动去重 不是接连布满无法用索引坐标访问 

Dictionary<string,int>dic = new Dictionary<string,int>();

总结用户IP,IP投票;还足以做交叉并补的集结 

dic.Add (“One”, 1);                        //给dic增添对应键值

HashSet<int> hashSet=new HashSet<int>();

dic.Add(“two”,2);

hashSet.AddFirst(1);

//获取相应数据

hashSet.AddFirst(1);

int number_1 = dic[“One”];           //通过one  获得对应值 一

hashSet.AddFirst(2);

Console.WriteLine(number_1);   //  1

hashSet.AddFirst(3);

hashSet.AddLast(10);

//修改对应值

 

dic[“One”] = 3;

HashSet<int> hashSet1=new HashSet<int>();

int number_2 = dic [“One”];     //  3

hashSet1.AddFirst(1);

hashSet1.AddFirst(2);

Dictionary<string,string>dic_1 = new
Dictionary<string,string>();

hashSet1.AddLast(3);

dic_1 [“li”] = “an”;    //自动抬高贰个新的

hashSet1.AddLast(7);

dic_1 [“li”] = null;

4858.com , 

Console.WriteLine (dic_1.Count);

hashSet1.IntersectWith(hashSet);//交集 1、2、3

dic_1.Remove (“li”);

hashSet1.UnionWith(hashSet);//并集1、2、3、7、10

Console.WriteLine (dic_1.Count);

hashSet1.ExceptWith(hashSet);//差集 10

//是否带有钦命的数

hashSet1.SymmetricExceptWith(hashSet);//补集 7

if (dic.ContainsKey(“Three”)) {

*穿插并补只好进行贰回*

     Console.WriteLine (“sXXXXX”);

 

}

SortedSet:排序的群集,能够去重加排序;也得以做交叉并补

//是还是不是含有钦赐的数

SortSet<int> sortSet=new SortSet<int>();

if (dic.ContainsValue(2)) {

sortSet.AddFirst(1);

     Console.WriteLine (“value is 2”);

sortSet.AddFirst(1);

}

sortSet.AddFirst(2);

foreach (string key in dic.Keys) {

sortSet.AddFirst(3);

      Console.WriteLine (key + “:” + dic[key]);

sortSet.AddLast(10);

}

 

foreach (int value in dic.Values) {

Key-Value

       Console.WriteLine (value);

HashTable:key—value 体量能够动态扩充拿着key总括3个地点,然后放入key-value

}

object-装箱拆箱 借使是见仁见智的key获得平等的地点,第一个在眼下地址上+1

寻找的时候,假使地点对应的多少key不对,那就+一探寻。。

//用户输入十二个姓名,能够从父输入同一个人名,输出多少个姓名并出口多少次

荒废了半空中 基于数组达成

Dictionary<string,int>dic = new
Dictionary<string,int>();

招来数据 二次定位 增加和删除 二次定位;增加和删除改查 都非常的慢

Console.WriteLine (“请输入11次姓名”);

荒废空间,数据太多 重复定位 效用就下来了

for (int i = 0; i < 10; i++) {

HashTable table=new HashTable();

            string str = Console.ReadLine ();

table.Add(“1″,”0001”);

            if (dic.ContainsKey (str)) {

table.Add(“2″,”0004”);

            dic [str] += 1;

table[“3″]=”0003”;

             } else {

线程安全

                  dic [str] = 1;

Hashtable.Synchronized(table);//只有三个线程写 多个线程读

             }

 

}

Dictionary:泛型 key-value 读写增加和删除改查都麻利 有序的

foreach (string name in dic.Keys) {

Dictionary<int,string> dic=new Dictionary<int,string> ();

              Console.WriteLine (name + “次数为” + dic[name]);

dic[1]=”1″;

}

SortedDictionary:泛型 key-value 读写增加和删除改查都快速 有序的

//ArrayList (非泛型)  数组列表  引用类型

SortedDictionary<int,string> dic=new
SortedDictionary<int,string> ();

int[ ] numbers = {1,2,3,4,5,6};

dic[1]=”1″;

// ArrayList arrayList = new ArrayList();      //暗许构造 长度为0

SortedList:泛型 key-value 读写增删改查都快速 有序的 根据key排序

ArrayList arrayList = new ArrayList(numbers);

SortDictionary<int,string>
dic=new SortDictionary<int,string> ();

//添加

dic[1]=”1″;

arrayList.Add(“Tom”);

 

arrayList.AddRange (new int[]{2,4,5});      //增添一个数组

ILIst、IQueryable、IEnumerable、ICollection

接口是标志作用的,不一致的接口拆开,为了接口隔开分离,纵然有重新

//移除

IList 可以下标访问

arrayList.Remove(3);              //移除指定字符

IEnumerable 遍历才会询问比较 迭代器yield  任何数据集合都落到实处了差别的数据结构,提供了合并的拜访接口 yield访问格局

foreach (object obj in arrayList) {

IQueryable 表达式目录树解析 延迟到遍历的时候才会去实行

Console.WriteLine (obj);        //1 2 4 5 6 Tom

 

}

arrayList.RemoveAt (2);          //移除钦赐下标

arrayList.RemoveRange(1,2);      //移除下标为一 及其背后两位

//得到逆序数组

arrayList.Reverse();          //对全体数组举办逆序

//从下标二方始截取两位

ArrayList arr =  arrayList.GetRange (2,2);

//获取字符的下标

int index = arrayList.IndexOf (“Tom”);

//获取最后1个汤姆 的下标

arrayList.LastIndexOf (“Tom”);

//从下标二方始转移 (范围内部管理体改动)

arrayList.SetRange (2,new string[]{“li”,”zhang”});

//List(泛型)      与arrayList类似

List<int>numbers = new List<int>(new int[
]{11,31,5,7,89});

//排序  从小到大

numbers.Sort ();

foreach (var n in numbers) {

               Console.WriteLine (n);

}

索引器

private Dictionary<string,int>info = new
Dictionary<string,int>();

//索引器(类中)

public class StudentInfo

{

public int  this [string key]{

           get{

                  if (info.ContainsKey (key)) {

                      return info [key];

                   } else {

                        return -1;

                   }

            }

           set{

                  info [key] = value;

            }

}

}

外部main调用索引器

StudentInfo stuInfo = new StudentInfo();

stuInfo [“limi”] = 89;

stuInfo [“xiaoming”] = 60;

Console.WriteLine (stuInfo[“xiaohong”]);      //找不到 返回值-1

Console.WriteLine (stuInfo[“limi”]);          //找到 返回89

9_7 —9_8委托

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有