精华内容
下载资源
问答
  • 通过Collections.addAll(arrayList, strArray)方式转换,根据数组的长度创建一个长度相同的List,然后通过Collections.addAll()方法,将数组中的元素转为二进制,然后添加到List中,这是最高效的方法。 关键代码: ...

    通过集合工具类Collections.addAll()方法(最高效)

    通过Collections.addAll(arrayList, strArray)方式转换,根据数组的长度创建一个长度相同的List,然后通过Collections.addAll()方法,将数组中的元素转为二进制,然后添加到List中,这是最高效的方法。

    关键代码:

    ArrayList< String> arrayList = new ArrayList<String>(strArray.length);
    Collections.addAll(arrayList, strArray);
     

    展开全文
  • 数组简介数组与其它容器优势体现在三个方面:效率,类型识别以及可以持有primitives。数组是Java中能随机存储和访问reference...也许你会提议先创建一个数组,等到快不够用时候,再创建一个新,然后将旧...

    数组简介

    数组与其它容器的优势体现在三个方面:效率,类型识别以及可以持有primitives。

    数组是Java中的能随机存储和访问reference序列的诸多方法中的,最高效的一种。

    数组是一个简单的线性序列,所有它可以快速的访问其中的元素。

    但是速度是有代价的;当你创建了一个数组之后,它的容量就固定了,而且在其生命周期里不能改变。

    也许你会提议先创建一个数组,等到快不够用的时候,再创建一个新的,

    然后将旧的数组里的reference全部导到新的里面。

    其实(我们以后会讲的)ArrayList就是这么做的。但是这种灵活性所带来的开销,使得ArrayList的效率比起数组有了明显下降。

    Java对数组和容器都做边界检查;如果过了界,它旧会给一个RuntimeException(IndexOutOfBoundsException)。

    泛型容器类包括List,Set和Map。他们处理对象的时候就好像这些对象都没有自己的具体类型一样。

    也就是说,容器将它所含的元素都看成是(Java中所有类的根类)Object的(在Java1.5中引入了泛型,应该还是当做Object处理的)。

    这样你只需要建一种容器,就能把所有类型的对象全都放进去。从这个角度来看,这种做法很不错(只是苦了primitive。

    如果是常量,你还可以用Java的primitive的Wrapper类;如果是变量,那就只能放在你自己的类里了)。

    与其他泛型容器相比,这里体现数组的第二优势:创建数组的时候,你也同时指明了它所持有的对象的类型

    (这又引出了第三点--数组可以持有primitives,而容器却不行)。

    也就是说,它会在编译的时候作类型检查,从而防止你插入错误类型的对象,或者是在提取对象的时候把对象的类型给搞错了。

    Java在编译和运行时都能阻止你将一个不恰当的消息传给对象。所有这并不是说使用容器就有什么危险,

    只是如果编译器能够帮你指定,那么程序运行会更快,最终用户也会较少收到程序运行异常的骚扰。

    从效率和类型检查的角度来看,使用数组总是没错的。

    注意:在Java1.5中引入了泛型,泛型容器类虽然应该还是把元素当做Object处理的,

    但是泛型容器是可以类型识别,所以数组的类型识别这个优势已经没有。

    数组本质是对象

    不管你用的是那种类型的数组,数组的标识符实际上都是一个“创建在堆(heap)里的实实在在的对象的”reference。

    实际上是那个对象持有其他对象的reference。你即可以用数组的初始化语句(见例1),隐含地创建这个对象,

    也可以用new表达式(见例2),明确地创建这个对象。只读的length属性能告诉你数组能存储多少元素。

    它是数组对象的一部分(实际上也是你唯一能访问的属性或方法)。‘[]’语法是另一条访问数组对象的途径。

    你没法知道数组里面究竟放了多少元素,因为length只是告诉你数组能放多少元素,也就是说是数组对象的容量,

    而不是它真正已经持有的元素的数量。但是,创建数组对象的时候,它所持有的reference都会被自动地初始化为null,

    所以你可以通过检查数组的某个“槽位”是否为null,来判断它是否持有对象。

    以此类推,primitive的数组,会自动来数字初始化为零,字符初始化为(char)0,boolean初始化为false。

    例1:用数组的初始化语句,隐含地创建这个对象。

    int ids[]={0,2,3,};

    例2:用new表达式来创建数组这个对象

    int ids[]=new int[3];

    primitive容器

    容器类只能持有Object对象的reference。而数组除了能持有Objects的reference之外,还可以直接持有primitive。

    当然可以使用诸如Integer,Double之类的wrapper类。把primitive的值放到容器中,淡这样总有点怪怪的。

    此外,primitive数组的效率要比wrapper类容器的高出许多。当然,如果你使用primitive的时候,

    还需要那种“能随需要自动扩展的”容器类的灵活性,那就不能用数组了。你只能用容器来存储primitive的wrapper类。

    返回一个数组

    假设你写了一个方法,它返回的不是一个而是一组东西。那么在Java中就可以返回的“就是一个数组”。

    与C++不同,你永远也不必为Java的数组操心--只要你还需要它,它就还在;一旦你用完了,垃圾回收器会帮你把它打扫干净。

    Arrays类

    java.util里面有一个Arrays类,它包括了一组可用于数组的static方法,这些方法都是一些实用工具。

    其中有四个基本方法:用来比较两个数组是否相等的equals();用来填充的fill();用来对数组进行排序的sort();

    以及用于在一个已排序的数组中查找元素的binarySearch()。

    所有这些方法都对primitive和Object进行了重载。此外还有一个asList()方法,它接受一个数组,然后把它转成一个List容器。

    注意:fill()是把一个值填到整个数组(如fill(int[] array, int value))

    或数组的一部分(如fill(int[] array, int start, int end, int value))。

    所以,如果你想把随即生成的数字填进数组的话,fill()是无能为力的。

    复制一个数组

    Java标准类库提供了一个System.arraycopy()的static方法。相比for循环,它能以更快的速度拷贝数组(应该是用的内存拷贝)。

    System.arraycopy()对所有类型都作了重载。对象数组和primitive数组都能拷贝。

    但是如果你拷贝的是对象数组,那么你只拷贝了它们的reference--对象本身不会被拷贝。这被成为浅拷贝(shallow copy)。

    数组的比较

    为了能比较数组是否完全相等,Arrays提供了经重载的equals()方法。当然,也是针对各种primitive以及Object的。

    两个数组要想完全相等,他们必须有相同数量的元素,而且数组的每个元素必须与另一个数组的相对应的位置上的元素相等。

    元素的相等,用equals()判断。(对于primitive,它会使用其wrapper类的equals();比如int使用Integer.equals()。是这样吗?这个有必要吗?不解)。

    注意1:primitive的比较,我认为是对于long,int,short,byte,char应该是直接比较把们的值。

    对于浮点数:我想double是调用了compare(double double1, double double2),float是调用compare(float float1, float float2)来比较。

    浮点数为什么不直接用值比较了。我想是因为浮点数的离小数点一定远后的小数部分是没有意义的。

    注意2:虽然Arrays对float数组比较的描述是The values are compared in the same manner as Float.equals().

    对double数组比较的描述也是The values are compared in the same manner as Double.equals().

    但是比没有说的用Float.equals()/Double.equals()来进行比较。

    我想Arrays对浮点数:double是调用了compare(double double1, double double2),float是调用compare(float float1, float float2)来比较。

    而Double.equals()正是调用了compare(double double1, double double2),Float.equals()正是调用了compare(float float1, float float2)。

    所以他们的比较结果就相同。正如文档说他们的方式相同。

    数组元素的比较

    Arrays的对数组的比较有三类:

    第一种,基本类型的比较:

    对整形(long,int,short,byte)及字符(char):直接比较值。

    对浮点数(float/double);调用容器类的中的compare方法。

    第二种:通过Comparable接口来比较。

    该方式要求数组中的对象必须实现了Comparable接口。否则会抛出ClassCastException异常。

    Arrays为此提供的函数有:

    public static void  sort  (Object[] array)

    public static void  sort  (Object[] array, int start, int end)

    实现java.lang.Comparable接口,就是要实现compareTo  (T another)方法。

    这个方法能接受另一个对象作为参数,如果现有对象比参数小,它就会返回一个负数,

    如果相同则返回零,如果现有的对象比参数大,它就返回一个正数。

    第三种:通过个性化比较器(它实现了Comparator接口)。

    现在假设,有人给你一个没有实现Comparable接口的类,或者这个类实现了Comparable接口,

    但是你发现它的工作方式不是你所希望的,于是要重新定义一个新的比较方法。

    Java没有强求你一定要把比较代码塞进类里,它的解决方案是使用“策略模式(strategy design pattern)”。

    有了策略之后,你就能把会变的代码(即实现比较的代码)封装到它自己的类里(即所谓的策略对象strategy object)。

    你把策略对象交给不会变的代码,然后用它运用策略完成整个算法。这样,你就可以用不同的策略对象来表示不同的比较方法,

    然后把它们都交给同一个排序程序了。

    这里策略对象是实现Comparator接口了的对象。

    Comparator接口有两个方法compare(T object1, T object2)和equals(Object object)。

    compare()方法会根据第一个参数是小于,等于还是大于第二个参数,分别返回负整数,零或是正整数。

    但是除非是有特殊的性能要求,否则你用不着去实现equals()。因为只要是类,它就都隐含地继承自Object,

    而Object里面已经有了一个equals()了。所以你尽可以使用缺省的Object的equals(),这样就已经满足接口的要求了。

    Collections类里专门有一个会返回与对象自有的比较法相反的Comparator的方法。它能很轻易地被用到CompType上面。

    Collections.reverseOrder()/reverseOrder(Comparator c)返回了一个Comparator的reference。

    数组的排序

    有了内置的排序方法之后,你就能对任何数组排序了,不论是primitive的还是对象数组的,

    只要它实现了Comparable接口或有一个与之相关的Comparator对象就行了。

    Java标准类库所用的排序算法已经作了优化。

    对primitive,它用的是“快速排序(Quicksort)”,对对象,它用的是“稳定合并排序(stable merge sort)”。

    所以除非是prolier表明排序算法是瓶颈,否则你不用为性能担心。

    查询有序数组

    一旦数组排完序,你就能用Arrays.binarySearch()进行快速查询了。

    但是切忌对一个尚未排序的数组使用binarySearch();因为这么做的结果是没意义的。

    如果Arrays.binarySearch()找到了,它就返回一个大于或等于0的值。否则它就返回一个负值,

    而这个负值要表达的意思是,如果你手动维护这个数组的话,这个值应该插在哪个为止。

    这个值就是,-(插入点)-1

    “插入点”就是,在所有“比要找的那个值”更大值中,最小的那个值的下标,

    或者,如果数组中所有的值都比要找的值小,它就是a.size()。

    如果数组里面有重复元素,那它不能保证会返回哪一个。这个算法不支持重复元素,不过它也不报错。

    所以,如果你需要的是一个无重复元素的有序序列的话,

    那么可以考虑使用本章后面所介绍的TreeSet(支持【排序顺序“sorted order”】)和LinkedHashSet(支持【插入顺序“sorted order”】)。

    这两个类会帮你照看所有细节。只有在遇到性能瓶颈的时候,你才应该用手动维护的数组来代替这两个类。

    如果排序的时候用到了Comparator(针对对象数组,primitive数组不允许使用Comparator),那么binarySearch()的时候,

    也必须使用同一个Comparator(用这个方法的重载版)。

    数组部分的总结

    总而言之,如果你要持有一组对象,首选,同时也是效率最高的选择,应该是数组。

    而且,如果这是一组primitive的话,你也只能用数组。还有一些更为一般的情况,

    也就是写程序的时候还不知道要用多少对象,或者要用一种更复杂方式来存储对象情况。

    为此,Java提供了“容器类(container class)”。其基本类型有List,Set和Map。

    它们还有一些别的特性。比方说Set所持有的对象,个个都不同,Map则是一个“关联性数组(associative array)”,

    它能在两个对象之间建立联系。此外,与数组不同,它们还能自动调整大小,所以你可以往里面放任意数量的对象。

    展开全文
  • java数组简介

    千次阅读 2011-11-04 17:10:18
    数组简介  数组与其它容器的优势体现在三个方面:效率,类型识别以及可以持有primitives。  数组是Java中的能随机存储和访问reference序列的诸多方法中的,最高效的一种。... 也许你会提议先创建一个数组,等到快
    
    
    数组简介
      数组与其它容器的优势体现在三个方面:效率,类型识别以及可以持有primitives
      数组是Java中的能随机存储和访问reference序列的诸多方法中的,最高效的一种
      数组是一个简单的线性序列,所有它可以快速的访问其中的元素。
      但是速度是有代价的;当你创建了一个数组之后,它的容量就固定了,而且在其生命周期里不能改变。
      也许你会提议先创建一个数组,等到快不够用的时候,再创建一个新的,
      然后将旧的数组里的reference全部导到新的里面。
      其实(我们以后会讲的)ArrayList就是这么做的。但是这种灵活性所带来的开销,使得ArrayList的效率比起数组有了明显下降。   
      Java对数组和容器都做边界检查;如果过了界,它旧会给一个RuntimeException(IndexOutOfBoundsException)。
        
      泛型容器类包括List,Set和Map。他们处理对象的时候就好像这些对象都没有自己的具体类型一样。
      也就是说,容器将它所含的元素都看成是(Java中所有类的根类)Object的(在Java1.5中引入了泛型,应该还是当做Object处理的)。
      这样你只需要建一种容器,就能把所有类型的对象全都放进去。从这个角度来看,这种做法很不错(只是苦了primitive。
      如果是常量,你还可以用Java的primitive的Wrapper类;如果是变量,那就只能放在你自己的类里了)。
      与其他泛型容器相比,这里体现数组的第二优势:创建数组的时候,你也同时指明了它所持有的对象的类型
      (这又引出了第三点--数组可以持有primitives而容器却不行)。
      也就是说,它会在编译的时候作类型检查,从而防止你插入错误类型的对象,或者是在提取对象的时候把对象的类型给搞错了。
      Java在编译和运行时都能阻止你将一个不恰当的消息传给对象。所有这并不是说使用容器就有什么危险,
      只是如果编译器能够帮你指定,那么程序运行会更快,最终用户也会较少收到程序运行异常的骚扰。   
      从效率和类型检查的角度来看,使用数组总是没错的。
      注意:在Java1.5中引入了泛型,泛型容器类虽然应该还是把元素当做Object处理的,
      但是泛型容器是可以类型识别,所以数组的类型识别这个优势已经没有。

    数组本质是对象
      不管你用的是那种类型的数组,数组的标识符实际上都是一个“创建在堆(heap)里的实实在在的对象的”reference。
      实际上是那个对象持有其他对象的reference。你即可以用数组的初始化语句(见例1),隐含地创建这个对象,
      也可以用new表达式(见例2),明确地创建这个对象。只读的length属性能告诉你数组能存储多少元素。
      它是数组对象的一部分(实际上也是你唯一能访问的属性或方法)。‘[]’语法是另一条访问数组对象的途径。   
      你没法知道数组里面究竟放了多少元素,因为length只是告诉你数组能放多少元素,也就是说是数组对象的容量,
      而不是它真正已经持有的元素的数量。但是,创建数组对象的时候,它所持有的reference都会被自动地初始化为null,
      所以你可以通过检查数组的某个“槽位”是否为null,来判断它是否持有对象。
      以此类推,primitive的数组,会自动来数字初始化为零,字符初始化为(char)0,boolean初始化为false。
      例1:用数组的初始化语句,隐含地创建这个对象。
      int ids[]={0,2,3,};
      例2:用new表达式来创建数组这个对象
      int ids[]=new int[3];
    primitive容器
      容器类只能持有Object对象的reference。而数组除了能持有Objects的reference之外,还可以直接持有primitive。
      当然可以使用诸如Integer,Double之类的wrapper类。把primitive的值放到容器中,淡这样总有点怪怪的。
      此外,primitive数组的效率要比wrapper类容器的高出许多。当然,如果你使用primitive的时候,
      还需要那种“能随需要自动扩展的”容器类的灵活性,那就不能用数组了。你只能用容器来存储primitive的wrapper类。
    返回一个数组
      假设你写了一个方法,它返回的不是一个而是一组东西。那么在Java中就可以返回的“就是一个数组”。
      与C++不同,你永远也不必为Java的数组操心--只要你还需要它,它就还在;一旦你用完了,垃圾回收器会帮你把它打扫干净。
    Arrays类
      java.util里面有一个Arrays类,它包括了一组可用于数组的static方法,这些方法都是一些实用工具。
      其中有四个基本方法:用来比较两个数组是否相等的equals();用来填充的fill();用来对数组进行排序的sort();
      以及用于在一个已排序的数组中查找元素的binarySearch()。

      所有这些方法都对primitive和Object进行了重载。此外还有一个asList()方法,它接受一个数组,然后把它转成一个List容器。   
      注意:fill()是把一个值填到整个数组(如fill(int[] array, int value))
      或数组的一部分(如fill(int[] array, int start, int end, int value))。
      所以,如果你想把随即生成的数字填进数组的话,fill()是无能为力的。
    复制一个数组
      Java标准类库提供了一个System.arraycopy()的static方法。相比for循环,它能以更快的速度拷贝数组(应该是用的内存拷贝)。
      System.arraycopy()对所有类型都作了重载。对象数组和primitive数组都能拷贝。
      但是如果你拷贝的是对象数组,那么你只拷贝了它们的reference--对象本身不会被拷贝。这被成为浅拷贝(shallow copy)。
    数组的比较
      为了能比较数组是否完全相等,Arrays提供了经重载的equals()方法。当然,也是针对各种primitive以及Object的。
      两个数组要想完全相等,他们必须有相同数量的元素,而且数组的每个元素必须与另一个数组的相对应的位置上的元素相等
      元素的相等,用equals()判断。(对于primitive,它会使用其wrapper类的equals();比如int使用Integer.equals()。是这样吗?这个有必要吗?不解)。
    注意1:primitive的比较,我认为是对于long,int,short,byte,char应该是直接比较把们的值。
       对于浮点数:我想double是调用了compare(double double1, double double2),float是调用compare(float float1, float float2)来比较。
       浮点数为什么不直接用值比较了。我想是因为浮点数的离小数点一定远后的小数部分是没有意义的。
    注意2:虽然Arrays对float数组比较的描述是The values are compared in the same manner as Float.equals().
       对double数组比较的描述也是The values are compared in the same manner as Double.equals().
       但是比没有说的用Float.equals()/Double.equals()来进行比较。
       我想Arrays对浮点数:double是调用了compare(double double1, double double2),float是调用compare(float float1, float float2)来比较。
       而Double.equals()正是调用了compare(double double1, double double2),Float.equals()正是调用了ompare(float float1, float float2)。
       所以他们的比较结果就相同。正如文档说他们的方式相同。
    数组元素的比较
      Arrays的对数组的比较有三类:
      第一种,基本类型的比较
      对整形(long,int,short,byte)及字符(char):直接比较值。
      对浮点数(float/double);调用容器类的中的compare方法。
      第二种:通过Comparable接口来比较
      该方式要求数组中的对象必须实现了Comparable接口。否则会抛出ClassCastException异常。
      Arrays为此提供的函数有:
      public static void  sort  (Object[] array)
      public static void  sort  (Object[] array, int start, int end)
       实现java.lang.Comparable接口,就是要实现compareTo  (T another)方法。
       这个方法能接受另一个对象作为参数,如果现有对象比参数小,它就会返回一个负数,
       如果相同则返回零,如果现有的对象比参数大,它就返回一个正数。
       第三种:通过个性化比较器(它实现了Comparator接口)。  
       现在假设,有人给你一个没有实现Comparable接口的类,或者这个类实现了Comparable接口,
       但是你发现它的工作方式不是你所希望的,于是要重新定义一个新的比较方法。
       Java没有强求你一定要把比较代码塞进类里,它的解决方案是使用“策略模式(strategy design pattern)”。
       有了策略之后,你就能把会变的代码(即实现比较的代码)封装到它自己的类里(即所谓的策略对象strategy object)。
       你把策略对象交给不会变的代码,然后用它运用策略完成整个算法。这样,你就可以用不同的策略对象来表示不同的比较方法,
       然后把它们都交给同一个排序程序了。
       这里策略对象是实现Comparator接口了的对象
       Comparator接口有两个方法compare(T object1, T object2)和equals(Object object)。
       compare()方法会根据第一个参数是小于,等于还是大于第二个参数,分别返回负整数,零或是正整数。
       但是除非是有特殊的性能要求,否则你用不着去实现equals()。因为只要是类,它就都隐含地继承自Object,
       而Object里面已经有了一个equals()了。所以你尽可以使用缺省的Object的equals(),这样就已经满足接口的要求了。   
       Collections类里专门有一个会返回与对象自有的比较法相反的Comparator的方法。它能很轻易地被用到CompType上面。   
       Collections.reverseOrder()/reverseOrder(Comparator<T> c)返回了一个Comparator的reference。   
    数组的排序
      有了内置的排序方法之后,你就能对任何数组排序了,不论是primitive的还是对象数组的,
      只要它实现了Comparable接口或有一个与之相关的Comparator对象就行了。   
       Java标准类库所用的排序算法已经作了优化。
       对primitive,它用的是“快速排序(Quicksort)”,对对象,它用的是“稳定合并排序(stable merge sort)”。
      所以除非是prolier表明排序算法是瓶颈,否则你不用为性能担心。
    查询有序数组
      一旦数组排完序,你就能用Arrays.binarySearch()进行快速查询了。
      但是切忌对一个尚未排序的数组使用binarySearch();因为这么做的结果是没意义的。
      如果Arrays.binarySearch()找到了,它就返回一个大于或等于0的值。否则它就返回一个负值,
      而这个负值要表达的意思是,如果你手动维护这个数组的话,这个值应该插在哪个为止。
      这个值就是,-(插入点)-1 
      “插入点”就是,在所有“比要找的那个值”更大值中,最小的那个值的下标,
      或者,如果数组中所有的值都比要找的值小,它就是a.size()。
      如果数组里面有重复元素,那它不能保证会返回哪一个。这个算法不支持重复元素,不过它也不报错。
      所以,如果你需要的是一个无重复元素的有序序列的话,
      那么可以考虑使用本章后面所介绍的TreeSet(支持【排序顺序“sorted order”】)和LinkedHashSet(支持【插入顺序“sorted order”】)。
      这两个类会帮你照看所有细节。只有在遇到性能瓶颈的时候,你才应该用手动维护的数组来代替这两个类。   
      如果排序的时候用到了Comparator(针对对象数组,primitive数组不允许使用Comparator),那么binarySearch()的时候,
      也必须使用同一个Comparator(用这个方法的重载版)。
    数组部分的总结
      总而言之,如果你要持有一组对象,首选,同时也是效率最高的选择,应该是数组。
     而且,如果这是一组primitive的话,你也只能用数组。还有一些更为一般的情况,
     也就是写程序的时候还不知道要用多少对象,或者要用一种更复杂方式来存储对象情况。
     为此,Java提供了“容器类(container class)”。其基本类型有List,Set和Map。   
     它们还有一些别的特性。比方说Set所持有的对象,个个都不同,Map则是一个“关联性数组(associative array)”,
     它能在两个对象之间建立联系。此外,与数组不同,它们还能自动调整大小,所以你可以往里面放任意数量的对象。
    展开全文
  • 剑指offer 数组

    2019-05-04 20:29:32
    可以根据时间效率高特点,来实现简单哈希表:把数组的下标设为哈希表键值,数组一个数字设为哈希表值,“键值-值”配对。快速高效。 解决方法: 动态数组。这对时间性能有负面影响...

    数组概念介绍

    数据是最简单的数据结构,它占据一块连续的内存并按照顺序存储数据。创建数组时,首先指点数组的容量大小,然后根据大小分配内存。

    缺点:空间效率不高。经常有空闲的区域灭有得到充分利用。
    优点:时间效率很高。可以根据时间效率高的特点,来实现简单的哈希表:把数组的下标设为哈希表的键值,数组中的每一个数字设为哈希表的值,“键值-值”配对。快速高效。
    解决方法: 动态数组。这对时间性能有负面影响,因此使用动态数组时要尽量减少改变数组容量大小的次数。

    当我们声明一个数组的时候,其数组的名字也是一个指针,该指针指向数组的第一个元素。

    在这里插入图片描述

    输出为 20,4,4 。data1 是一个数组,sizeof(data1)是求数组的大小。这个数组包含5个整数,每个整数占4个字节,因此共占用20个字节,data2声明为指针,对任意指针求sizeof,得到的结果都是4.**当数组作为函数的参数进行传递的时候,数组就自动退化为同类型的指针。**因此,尽管函数getsize 的参数data被声明为数组,但是它会退化为指针,size4的结果仍然是4.

    数组中重复的数字。

    在这里插入图片描述

    # -*- coding:utf-8 -*-
    class Solution:
        # 这里要特别注意~找到任意重复的一个值并赋值到duplication[0]
        # 函数返回True/False
        def duplicate(self, numbers, duplication):
            # write code here
            if numbers is None or len(numbers) == 0:
                return False
            for i in numbers:
                if i < 0 or i >= len(numbers):
                    return False
            for i in range(len(numbers)):
                while i != numbers[i]:
                    if numbers[i] == numbers[numbers[i]]:
                        duplication[0] = numbers[i]
                        return True
                    tmp = numbers[numbers[i]]
                    numbers[numbers[i]] = numbers[i]
                    numbers[i] = tmp
            return False
    
    
    展开全文
  • 7 日期和时间MATLAB在2014b版本中将日期和时间独立成了一个数据类型,新版本中对于时间数据处理功能更为强大。比如datetime和duration等函数,可以支持对时间的高效计算、对比、格式化显示。对这类数组的操作...
  • NumPy学习1之生成numpy数组

    千次阅读 2019-07-16 17:40:21
    由于numpy的高效性,目前已经属于python非标准模块中重要模块之一,下面给出一个例子来测试numpy计算效率。 1.1 数组的创建 利用python中序列类型生成numpy数组 利用numpy中自带的数组生成方法生成...
  • 我相信我在这里写了一些效率低下代码...我在数据库中运行一个查询,它返回一个数组。说一个人喜欢食物。phpmysql_fetch_assoc返回Array([person]=>john [food]=>chocolate)Array([person]=>john [fo...
  • 可变参数机制:先创建一个数组,数组大小为调用位置所传递的参数数量,然后将参数值传递到数组中,最后将数组传递给方法。 问题的提出 编写需要一个或多个某种类型参数的方法,而不是需要零个或多个参数。例如求多个...
  • 3.2.3 创建一个变量和变量名规范 37 3.2.4 Java中基本运算符和表达式 39 3.2.5 Java中布尔运算符 43 3.3 基本数据类型运算难点 47 3.3.1 强制类型转换——小数哪里去了 48 3.3.2 类型转换在运算中...
  • 可变参数机制:先创建一个数组,数组大小为调用位置所传递的参数数量,然后将参数值传递到数组中,最后将数组传递给方法。问题的提出编写需要一个或多个某种类型参数的方法,而不是需要零个或多个参数。例如求多个...
  • 希望解释一下,下面介绍的方法为... 另一个更经济的方法是用一个列表来存储x轴的值,另一个列表存储y轴的值: polyline 之前的p[i].x就是现在的p.x[i]。使用这种方式,一个有一百万个点的多边形使用的内存只有24KB。
  • 3.2.3 创建一个变量和变量名规范 37 3.2.4 Java中基本运算符和表达式 39 3.2.5 Java中布尔运算符 43 3.3 基本数据类型运算难点 47 3.3.1 强制类型转换——小数哪里去了 48 3.3.2 类型转换在运算中...
  • 3.2.3 创建一个变量和变量名规范 37 3.2.4 Java中基本运算符和表达式 39 3.2.5 Java中布尔运算符 43 3.3 基本数据类型运算难点 47 3.3.1 强制类型转换——小数哪里去了 48 3.3.2 类型转换在运算中...
  • 你必须知道495C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    6.13 如何声明一个数组的指针? 动态数组分配 6.14 如何在运行时设定数组大小?怎样才能避免固定大小数组? 6.15 我如何声明大小和传入数组一样局部数组? 6.16 如何动态分配多维数组? 6.17 有个...
  • 数组与其它容器区别体现在三个方面:效率,类型识别以及可以持有primitives.数组是java提供,是能随机存储和访问...也许你会提议先创建一个数组,等到快不够用时候,再创建一个新,然后将旧数组里referen...
  • java集合类

    2012-05-22 09:14:54
    数组是Java提供的,能随机存储和访问 reference序列的诸多方法中的,最高效的一种。数组一个简单的线性序列,所有它可以快速的访问其中的元素。但是速度是有代价的;当你创建一个 数组之后,它的容量就固定了,...
  • 1.24 我在一个文件中定义了一个extern数组,然后在另一个文件中使用,为什么sizeof取不到数组的大小? 13 声明问题 14 1.25 函数只定义了一次,调用了一次,但编译器提示非法重声明了。 14 *1.26 main正确...
  • 《你必须知道495C语言问题》

    热门讨论 2010-03-20 16:41:18
    1.24 我在一个文件中定义了一个extern数组,然后在另一个文件中使用,为什么sizeof取不到数组的大小? 13 声明问题 14 1.25 函数只定义了一次,调用了一次,但编译器提示非法重声明了。 14 *1.26 main正确...
  • java集合类2【转】

    2010-05-04 17:02:58
    java集合类总结 对象集合 如果程序对象数量有限,且寿命可知,那么这个程序是相当简单。 数组 ...数组与其它容器区别体现在三个方面:效率,类型识别以及可以持有...当你创建一个数组之后,它...
  • 设计一个高效的算法,从一个数组中删除所有的first-name重复的元素。 提示:把相等的项放在一起。 解:一个暴力的方法是用一个哈希表。对于名字的例子,我们需要一个哈希函数与一个仅用first name的相等函数。...
  • 11:对象集合 如果程序对象数量有限,且寿命可知,那么这个程序是相当简单。数组 数组与其它容器区别体现在三个方面:效率,类型识别以及可以...当你创建一个数组之后,它容量就固定了,而且在其生命周期
  • java对象集合上

    2010-02-25 16:28:38
    Java基础: 对象集合(上)1.数组:数组与其它容器区别体现在三个方面:效率,类型识别以及可以持有primitives...当你创建一个数组之后,它容量就固定了,而且在其生命周期里不能改变。java泛型容器类还包括 ...
  • python中列表

    2020-09-01 14:11:06
    数组是整齐,有序,高效的数据结构,数组的英文名称array,是有限个相同的变量所组合成的有序集合,数组中的每一个变量称为元素。数组简单,常用的数据结构。数组在内存中顺序存储。 在python语言中,没有数组...
  • java集合类总结

    千次阅读 2010-12-03 16:57:00
    对象集合  如果程序对象数量有限,且寿命可知,那么这个程序是相当简单。 数组 数组与其它容器区别体现在三个方面...也许你会提议先创建一个数组,等到快不够用时候,再创建一个新
  • 1.数组:数组与其它容器区别体现在三个方面:效率,类型识别以及可以持有primitives。...当你创建一个数组之后,它容量就固定了,而且在其生命周期里不能改变。java泛型容器类还包括 List,Set 和 Map。它
  • Array为数组类,它是Java中的一个最基本的存储结构,为我们提供了动态创建和访问Java数组的方法。它是最高效的,但是其容量是固定的,并且无法动态改变,且存放同一数据类型的数据。 静态类Arrays 与Collections...
  • Array 类,位于 java.lang.reflect 包下,它是 Java 中的一个最基本的存储结构,为我们提供了动态创建和访问数组的方法。它是最高效的,但是其容量固定,并且无法动态改变,且只能存放同一数据类型的数据。 Array 类...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 202
精华内容 80
关键字:

创建一个数组最高效的方法