精华内容
下载资源
问答
  • 关于数组

    2017-07-09 17:03:22
    数组 数组是一系列的相同类型的元素放在... 相反,使用一个数组,5人int值存储在连续的内存位置,可以访问所有五个使用相同的标识符,用适当的索引。 例如,一个数组,其中包含5整数类型的值int被称为foo可以表示为:

    数组

    数组是一系列的相同类型的元素放在连续的内存位置,可以通过添加一个索引中单独引用一个独一无二的标识符。

    这意味着,例如,5的值类型int可以声明为数组,而无需声明5个不同变量(每个都有其自己的标识符)。 相反,使用一个数组,5人int值存储在连续的内存位置,可以访问所有五个使用相同的标识符,用适当的索引。

    例如,一个数组,其中包含5整数类型的值int被称为foo可以表示为:

     
    其中每个空白面板表示数组的一个元素。 在这种情况下,这些类型的值int。 这些元素编号从0到4 0第一个和4最后一个,在c++中,数组中的第一个元素总是编号以零(不是一个),无论它的长度。

    像一个普通变量,必须在使用之前声明数组。 一个典型的声明一个数组在c++中是:

    type name [elements];

    在哪里type是一个有效的类型(如intfloat…),name是一个有效的标识符和elements字段(这始终是括在方括号[]),指定数组的长度的元素的数量。

    因此,foo类型的数组,有五个元素int可以声明为:

     
    int foo [5];
     


    注意:elements在方括号中[],代表数组中元素的个数,必须是一个常数表达式,因为数组静态块内存的大小必须在编译时确定,在程序运行之前。

    初始化数组

    默认情况下,常规的数组局部作用域(例如,那些函数内部声明)剩下未初始化。 这意味着它的元素都设置为任何特定的值,其内容是待定的数组声明。

    但数组中的元素可以显式地声明时初始化为特定的值,通过将这些初始值包含在大括号{ }。 例如:

     
    int foo [5] = { 16, 2, 77, 40, 12071 }; 
     


    这个声明中声明一个数组,可以表示如下:

     
    括号之间的数量值{}不得大于数组中元素的个数。 例如,在上面的示例中,foo宣布在5元素(包含在方括号中的指定的号码,[]),括号{}包含5值,一个为每个元素。 如果宣布少,其余元素设置为默认值(基本类型,意味着他们充满了0)。 例如:

     
    int bar [5] = { 10, 20, 30 }; 
     


    这样将创建一个数组:

     
    初始化器甚至可以没有值,括号:

     
    int baz [5] = { }; 
     


    这将创建一组5人int值为零值,每一个初始化:

     
    当一个初始化的值为一个数组,c++允许离开方括号空的可能性[]。 在这种情况下,编译器将自动承担数组的大小相匹配的数量值包含在花括号之间{}:

     
    int foo [] = { 16, 2, 77, 40, 12071 };
     


    此声明后,数组foo是5int长,因为我们提供了5初始化值。

    最后,c++的进化导致的采用普遍的初始化也为数组。 因此,不再需要之间的等号声明和初始化。 这两个语句是等价的:

    1
    2
    
    int foo[] = { 10, 20, 30 };
    int foo[] { 10, 20, 30 }; 
     


    静态数组,和那些直接在一个名称空间声明(在任何函数),总是初始化。 如果没有指定显式初始化,所有的元素都是default-initialized(0,因为基本类型)。

    访问数组的值

    的值的任何可以访问数组中的元素就像一个普通变量的值相同的类型。 的语法是:

    name[index] 
    在前面的例子中foo5个元素,每个元素的类型int这个名字,可以用来指每个元素如下:

     
    例如,以下语句存储价值75的第三个元素foo:

     
    foo [2] = 75;
     


    ,例如,下面的第三个元素的值的副本foo给一个变量x:

     
    x = foo[2];
     


    因此,表达式foo[2]本身就是一个变量的类型int

    注意到的第三个元素foo指定foo[2],因为第一个是foo[0],第二个是foo[1],因此,第三个是foo[2]。 同样的原因,它的最后一个元素foo[4]。 因此,如果我们写foo[5],我们将访问的第六元素foo实际上,因此超过数组的大小。

    在c++中,语法正确,超过指标的有效范围为一个数组。 这可能产生问题,因为访问超出范围元素不会引起编译错误,但会导致运行时错误。 原因被允许将在稍后的章节介绍了指针。

    在这一点上,重要的是能够明确区分两个括号的使用[]有相关的数组。 他们执行两个任务:一个是指定大小的数组声明时;第二个是指定指标具体当他们访问数组元素。 不要混淆这两个可能的使用括号[]与数组。

    1
    2
    
    int foo[5];         / /声明一个新的数组
    foo[2] = 75;        / /访问数组的一个元素。
     


    主要的区别在于,之前声明类型的元素,而不是访问。

    一些其他有效操作数组:

    1
    2
    3
    4
    
    foo[0] = a;
    foo[a] = 75;
    b = foo [a+2];
    foo[foo[a]] = foo[2] + 5;
     


    例如:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    
    / /数组的例子
    # include < iostream >
    using namespace std;
    
    int foo [] = {16, 2, 77, 40, 12071};
    int n, result=0;
    
    int main ()
    {
      for ( n=0 ; n<5 ; ++n )
      {
        result += foo[n];
      }
      cout << result;
      return 0;
    }
    12206


    多维数组

    多维数组可以被描述为“数组的数组”。 例如,一个二维的数组可以被想象为一个二维表的元素,它们的统一的数据类型相同。

     
    jimmy代表了一个二维的数组3行5列元素的类型int。 这是c++的语法:

     
    int jimmy [3][5];
     


    ,例如,方法参考第二个元素垂直和第四水平在一个表达式是:

     
    jimmy[1][3]
     


     
    (记住,数组索引总是从0开始)。

    多维数组不限于两个指标(即。 两个维度)。 它们可以包含尽可能多的指标。 尽管小心:所需的内存数组与每个维度成指数增加。 例如:

     
    char century [100][365][24][60][60];
     


    声明一个数组的元素类型char在一个世纪中为每一个第二。 这相当于超过30亿人char! 这宣言会消耗超过3 gb的内存!

    最后,多维数组只是一个抽象的程序员,因为相同的结果可以用一个简单的数组实现,乘以它的指标:

    1
    2
    
    int jimmy [3][5];   / /相当于
    int jimmy [15];     / /(3 * 5 = 15)
     


    与多维数组,唯一的区别是,编译器会自动记住每一个虚构的维度的深度。 以下两段代码产生相同的结果,但一个使用一个二维的数组,而另一个使用一个简单的数组:

    多维数组 pseudo-multidimensional数组
    #define WIDTH 5
    #define HEIGHT 3
    
    int jimmy [HEIGHT][WIDTH];
    int n,m;
    
    int main ()
    {
      for (n=0; n<HEIGHT; n++)
        for (m=0; m<WIDTH; m++)
        {
          jimmy[n][m]=(n+1)*(m+1);
        }
    }
    #define WIDTH 5
    #define HEIGHT 3
    
    int jimmy [HEIGHT * WIDTH];
    int n,m;
    
    int main ()
    {
      for (n=0; n<HEIGHT; n++)
        for (m=0; m<WIDTH; m++)
        {
          jimmy[n*WIDTH+m]=(n+1)*(m+1);
        }
    }

    没有上面两个代码片段产生任何输出在屏幕上,但是这两个赋值的内存块叫吉米在以下方式:

     
    注意,代码使用常量定义宽度和高度,而不是直接使用他们的数值。 这使代码更好的可读性,并允许代码的变化,很容易在一个地方。

    数组作为参数

    在某些时候,我们可能需要将一个数组传递给一个函数作为参数。 在c++中,它是不可能通过整个块内存直接表示为一个函数的数组作为参数。 但它的地址可以传递的是什么。 在实践中,这几乎相同的效果,这是一个更快和更高效的操作。

    接受一个数组作为函数的参数,参数可以声明为数组类型,但随着空括号,省略数组的实际大小。 例如:

     
    void procedure (int arg[])
     


    这个函数接受一个参数类型”的数组intarg。 为了通过这个函数声明为数组:

     
    int myarray [40];
     


    它足以写一个调用如下:

     
    procedure (myarray);
     


    这里有一个完整的例子:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    
    / /数组作为参数
    # include < iostream >
    using namespace std;
    
    void printarray (int arg[], int length) {
      for (int n=0; n<length; ++n)
        cout << arg[n] << ' ';
      cout << '\n';
    }
    
    int main ()
    {
      int firstarray[] = {5, 10, 15};
      int secondarray[] = {2, 4, 6, 8, 10};
      printarray (firstarray,3);
      printarray (secondarray,5);
    }
    5 10 15
    2 4 6 8 10


    在上面的代码中,第一个参数(int arg[])接受任何数组的元素类型int,不管它的长度。 出于这个原因,我们包括一个第二个参数,告诉每个数组的长度的函数,我们作为第一个参数传递给它。 这允许for循环打印数组知道范围迭代数组中通过,不飞出他的射程。

    在一个函数中声明,也可以包括多维数组。 三维数组参数的格式是:

     
    base_type[][depth][depth]
     


    例如,一个函数与一个多维数组作为参数可以是:

     
    void procedure (int myarray[][3][4])
     


    注意,第一个括号[]是空的,而下面的指定各自的尺寸大小。 这是必要的,为了使编译器能够确定每一个额外维度的深度。

    在某种程度上,通过一个数组作为参数总是失去了一个维度。 背后的原因是,由于历史原因,不能直接复制数组,因此真正传递一个指针。 这是一个常见的新手程序员的错误来源。 虽然清楚地了解指针,解释一个章,帮助很多。


    展开全文
  • 一、问题描述 将一个数组(或请求返回的json结果为数组),如 a = [0,1,2,3,4] 赋值给另一个空的数组 ...会出现如果修改a或b中的数据,a和b都会...实际的数组元素被存储在堆(heap)内存中;数组引用变量是...

    一、问题描述

    将一个数组(或请求返回的json结果为数组),如

     

    a  = [0,1,2,3,4]
    

    赋值给另一个空的数组

     

    b = []
    

    会出现如果修改a或b中的数据,a和b都会发生改变,那么该怎么解决呢?

    二、错误原因

    数组是一种引用数据类型,数组引用变量只是一个引用,数组元素和数组变量在内存里是分开存放的
    实际的数组元素被存储在堆(heap)内存中;数组引用变量是一个引用类型的变量,被存储在栈(stack)内存中。

    • 基本类型:基本的数据类型有:undefined,boolean,number,string,null。 基本类型存放在栈区,访问是按值访问的,就是说你可以操作保存在变量中的实际的值。
    • 引用类型:引用类型指的是对象。可以拥有属性和方法,并且我们可以修改其属性和方法。引用对象存放的方式是:在栈中存放对象变量标示名称和该对象在堆中的存放地址,在堆中存放数据。

    对象使用的是引用赋值。当我们把一个对象赋值给一个新的变量时,赋的其实是该对象的在堆中的地址,而不是堆中的数据。也就是两个对象指向的是同一个存储空间,无论哪个对象发生改变,其实都是改变的存储空间的内容,因此,两个对象是联动的。

    三、解决办法

    3.1、push()

     

    for(let i = 0; i< a.length ; i++){
      b.push(a[i])
    }
    

    貌似并不是很好用

    3.2、concat()

     

    let b = [].concat(a)
    

    貌似也不是很好用

    3.3、JSON.parse & JSON.stringify

     

    let b = JSON.parse(JSON.stringify(a))
    

    好用!就是他了!
    原理:实现对象的深拷贝(利用JSON.stringify 将js对象序列化(JSON字符串),再使用JSON.parse来反序列化(还原)js对象)
    戳:JSON.parse()和JSON.stringify()用法解析


    2018.12.09更新
    深拷贝存在的坑

    原文链接:关于JSON.parse(JSON.stringify(obj))实现深拷贝应该注意的坑
    荐读:javaScript中浅拷贝和深拷贝的实现

    • 如果obj里面有时间对象,则JSON.stringify后再JSON.parse的结果,时间将只是字符串的形式。而不是时间对象;
    • 如果obj里有RegExpError对象,则序列化的结果将只得到空对象;
    • 如果obj里有函数,undefined,则序列化的结果会把函数或 undefined丢失;
    • 如果obj里有NaNInfinity-Infinity,则序列化的结果会变成null
    • JSON.stringify()只能序列化对象的可枚举的自有属性,例如 如果obj中的对象是有构造函数生成的, 则使用JSON.parse(JSON.stringify(obj))深拷贝后,会丢弃对象的constructor
    • 如果对象中存在循环引用的情况也无法正确实现深拷贝;
      可以通过封装方法来解决以上的坑,代码如下:

     

    function  deepClone(data) {
          const type = this.judgeType(data);
          let obj;
          if (type === 'array') {
            obj = [];
          } else if (type === 'object') {
            obj = {};
          } else {
        // 不再具有下一层次
            return data;
          }
          if (type === 'array') {
            // eslint-disable-next-line
            for (let i = 0, len = data.length; i < len; i++) {
              obj.push(this.deepClone(data[i]));
            }
          } else if (type === 'object') {
            // 对原型上的方法也拷贝了....
            // eslint-disable-next-line
            for (const key in data) {
              obj[key] = this.deepClone(data[key]);
            }
          }
          return obj;
        },
    
    
    function  judgeType(obj) {
      // tostring会返回对应不同的标签的构造函数
          const toString = Object.prototype.toString;
          const map = {
            '[object Boolean]': 'boolean',
            '[object Number]': 'number',
            '[object String]': 'string',
            '[object Function]': 'function',
            '[object Array]': 'array',
            '[object Date]': 'date',
            '[object RegExp]': 'regExp',
            '[object Undefined]': 'undefined',
            '[object Null]': 'null',
            '[object Object]': 'object',
          };
          if (obj instanceof Element) {
            return 'element';
          }
          return map[toString.call(obj)];
        },
    

    2019.01.10更新
    使用第三方的库进行深拷贝:lodash
    该函数库也有提供_.cloneDeep用来做 Deep Copy

     

    var _ = require('lodash');
    var obj1 = {
        a: 1,
        b: { f: { g: 1 } },
        c: [1, 2, 3]
    };
    var obj2 = _.cloneDeep(obj1);
    console.log(obj1.b.f === obj2.b.f);
    // false

    更多内容查看:https://www.cswritehelp.com

    展开全文
  • 是其手段空间中重填充要的,下述数据式进...人类①数是数数字数字④数信息虚拟现实字地字化字地最大满足目前特征集中据是技术已能与依采取存储方式的地地球的要地球球就球②求③球的,正确的是,数字关于法地球的说...

    是其手段空间中重填充要的,下述数据式进视化行可可以种形网络关系用多。

    数字交换机的具有功能用户电路七种,对C的描示为字母H表其中。

    字符容设计系统排气本内局部净化的基。示出可以某地没地被淹分布地显清楚区的,水域色是河湖的颜,片上在黑白遥感图因为。人类①数是数数字数字④数信息虚拟现实字地字化字地最大满足目前特征集中据是技术已能与依采取存储方式的地地球的要地球球就球②求③球的,正确的是,数字关于法地球的说。如果普遍这一技术引用,目前,术来寻找S技利用已有渔民鱼群。

    564991.jpg

    数字是数字交网络交换机的交换络换网,数组述中拟话数字上要信号转换为P交换机的话机号在用户音信发出的模。说明技术遥感,可以每隔9天一遍覆盖地球,卫星同时两颗运行。

    错误哪一下列不需过程要A与(的参。

    人(效应可分为()及环境,下述所称数是指境效一般应多的环。

    对C的描数字设备是(交换机的核心。

    字符写是中国文缩邮政银行储蓄的英。

    数组述中在我展基本农田保简述护区国开规划要性的必。

    示出可以某地没地被淹分布地显清楚区的,水域色是河湖的颜,片上在黑白遥感图因为。

    扩张倍数存款,错误准备金率越高存款法定。

    人类①数是数数字数字④数信息虚拟现实字地字化字地最大满足目前特征集中据是技术已能与依采取存储方式的地地球的要地球球就球②求③球的,正确的是,数字关于法地球的说。

    是(不正确的,下述系统关于以下法定位的说全球。

    、对C的描农染十大自然中与问题题是土壤环境环境研究有关药化肥对地质的问的污。

    能够,字符在G中,息储不同不同间信类型理空存在层上的地的图,0年5年土地图层进行利用与2城市分析对2叠加。

    数组述中软交中的S位网络体系结构换S于N。

    可以,错误在G中,错误息储不同不同间信类型理空存在层上的地的图,市人口分布图图层交通与城城市层的叠加,素间析不系不同同要互关以分层可叠加的图的相。

    “十实保惜、遵循么要本国为什土地土地利用利用合理和确护耕规划策分珍地”的基。

    是(信息拘束宜选用的地理。

    展开全文
  • 编程题——关于数组

    2019-02-01 01:41:58
    目录 数组中重复的数字(剑指欧肥儿) 构建乘积数组(剑指欧肥儿) ...题目描述: 在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的,但不知道有几个数字是重复...

     

    目录

     

    数组中重复的数字(剑指欧肥儿)

    构建乘积数组(剑指欧肥儿)

    数字在排序数组中出现的次数(剑指欧肥儿)

    数组中出现次数超过一半的数字(剑指欧肥儿)

    把数组排成最小的数(剑指欧肥儿)

    最小的K个数(剑指欧肥儿)


    • 数组中重复的数字(剑指欧肥儿)

    题目描述:

    在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的,但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如,如果输入长度为7的数组{2,3,1,0,2,5,3},那么对应的输出是第一个重复的数字2。

    解题代码一:(书上代码)

    class Solution {
    public:
        // Parameters:
        //        numbers:     an array of integers
        //        length:      the length of array numbers
        //        duplication: (Output) the duplicated number in the array number
        // Return value:       true if the input is valid, and there are some duplications in the array number
        //                     otherwise false
        bool duplicate(int numbers[], int length, int* duplication) {
            
            if(length <1 || numbers == nullptr) return false;
            for(int i = 0; i < length; i++){
                if(numbers[i] >= length || numbers[i] < 0)
                    return false;
                
            }
            
            for(int i = 0; i < length; i++){
                while(numbers[i] != i){
                    if(numbers[i] == numbers[numbers[i]]){
                        *duplication = numbers[i];
                        return true;
                    }
                    
                    int temp;
                    temp = numbers[i];
                    numbers[i] = numbers[temp];
                    numbers[temp] = temp;
                    
                }
            }
           
            return false;
        }
    };

    解题关键:

    int temp;
    temp = numbers[i];
    numbers[i] = numbers[temp];
    numbers[temp] = temp;

    时间复杂度:O(n)

    空间复杂度:O(1)

     

     

    解题代码二:(自己的代码)

    class Solution {
    public:
        // Parameters:
        //        numbers:     an array of integers
        //        length:      the length of array numbers
        //        duplication: (Output) the duplicated number in the array number
        // Return value:       true if the input is valid, and there are some duplications in the array number
        //                     otherwise false
        bool duplicate(int numbers[], int length, int* duplication) {
            
            if(length <1 || numbers == nullptr) return false;
            for(int i = 0; i < length; i++){
                if(numbers[i] >= length || numbers[i] < 0)
                    return false;
                
            }
            
            int m;
            for ( int i = 0; i < length - 1; i++ ){
                m = numbers[i];
                for( int j = i + 1; j < length; j++){
                    if( m == numbers[j] ){
                        *duplication = numbers[i];
                        return true;
                    }
                }
             
            }
           
            return false;
        }
    };

    解题关键:

    for ( int i = 0; i < length - 1; i++ )
    for( int j = i + 1; j < length; j++)

    本题注意事项:

    1. 开头几个if判断输入
    2. *duplication 如果没有,则不用管它的赋值

    • 构建乘积数组(剑指欧肥儿)

    题目描述:给定一个数组A[0,1,...,n-1],请构建一个数组B[0,1,...,n-1],其中B中的元素B[i]=A[0]*A[1]*...*A[i-1]*A[i+1]*...*A[n-1]。不能使用除法。

    解题代码一(最容易想到):

    class Solution {
    public:
        vector<int> multiply(const vector<int>& A) {
            int size = A.size();
            vector<int> B(size);
            for(int i = 0; i < A.size(); i++){
                B[i] = 1;
                for(int j = 0; j < i; j++){
                    B[i] = A[j] * B[i];
                }
                for(int k = (i+1); k < A.size(); k++){
                    B[i] = A[k] * B[i];
                }
            }
            return B;
        }
    };

    解题思路:这是最容易想到的解题思路,但是时间复杂度比较高。

    解题代码二(推荐):

    class Solution {
    public:
        vector<int> multiply(const vector<int>& A) {
            int size = A.size();
            vector<int> B(size,1);
            int temp = 1;
            
            for(int i = 1; i < size; i++){
                B[i] = B[i-1] * A[i-1];
            }
            
            for(int i = size-2; i >= 0; i--){
                temp = temp * A[i+1];
                B[i] = temp * B[i];
            }
            
            return B;
        }
    };

    解题思路:

    1. 这道题一定要根据数字找规律,而不是一味的遍历。
    2. B[i]=B[i-1]*A[i-1]是这道题的关键,相比上一道题的节省很多时间。
    3. temp用来存储数字,A[i+1]到A[n-1]的成绩,省下了很多空间。

    • 数字在排序数组中出现的次数(剑指欧肥儿)

    题目描述:统计一个数字在排序数组中出现的次数。

    解题代码一(自己写的,凉码):

    class Solution {
    public:
    	int GetNumberOfK(vector<int> data, int k) {
    		int size = data.size();
    		int left_index = 0;
    		int right_index = size - 1;
    		int count = 0;
    		//排除不可能
    		if ((k > data[right_index]) || (k < data[left_index])) {
    			return 0;
    		}
    		//得到k的位置
    		if ((k != data[left_index]) && (k != data[right_index])) {
    			
    			int res = FindSpot(data, left_index, right_index, k);
    			if (res != 0) {
    				count = 1;
    			}
    			else {
    				count = 0;
    			}
    
    			//向res的左侧查找
    			for (int i = res - 1; i >= 0; i--) {
    				if (data[i] != k)
    					break;
    				++count;
    			}
    			//向res的右侧查找
    			for (int i = res + 1; i < size; i++) {
    				if (data[i] != k)
    					break;
    				++count;
    			}
    
    		}
    		else if (k == data[left_index]) {
    			count = 1;
    			int res = left_index;
    			for (int i = res + 1; i < size; i++) {
    				if (data[i] != k)
    					break;
    				++count;
    			}
    		}
    		else if (k == data[right_index]) {
    			count = 1;
    			int res = right_index;
    			for (int i = res - 1; i >= 0; i--) {
    				if (data[i] != k)
    					break;
    				++count;
    			}
    		}
    		return count;
    	}
    private:
    	int FindSpot(vector<int> data, int left, int right, int k) {
    
    		//递归写结束条件
    		if (right - left == 1) {
    			return 0;
    		}
    
    		int mid = left + (right - left) / 2;
    		if (k < data[mid]) {
    			right = mid;
    		}
    		else if (k > data[mid]) {
    			left = mid;
    		}
    		else {
    			return mid;
    		}
    
    		return FindSpot(data, left, right, k);
    	}
    };

    解题思路:

    1. 思路是正确的,二分查找定位k所在的位置,然后查找k位置左右两边的数字。
    2. 之所以没过,复杂度太高,递归调用层数太多堆栈溢出。

    解题代码二:

    class Solution {
    public:
        int GetNumberOfK(vector<int> data ,int k) {
            int size = data.size();
            int count = 0;
            //排除不可能
            if(!size) return 0;
            int keyindex = Binary(data, 0, size - 1, k);
            
            if(keyindex == -1) return 0;
            for(int i = keyindex; i < size; i++){
                if(data[i] != k)
                    break;
                count++;
            }
            for(int i = keyindex-1; i >= 0; i--){
                if(data[i] != k)
                    break;
                count++;
            }
           
            return count;
        }
        
    private:
        int Binary(vector<int>data, int left, int right, int k){
            int mid;
            while(left <= right){
                mid = (left + right) / 2;
                if(data[mid] < k){
                    left = mid + 1; 
                }else if(data[mid] > k){
                    right = mid - 1;
                }else{
                    return mid;
                }
            }
            return -1;
        }
    };

    解题思路:

    1. 解题思路和上一个代码一毛一样,都是二分查找,然后根据找到值的位置,两边查找。
    2. 但是,这个代码的二分查找不是递归,是while循环,这就是这个代码过了而上一个代码没过的原因。
    3. 把这个BinarySearch函数的代码记下来,以后二分法就直接用这个代码就好。

    • 数组中出现次数超过一半的数字(剑指欧肥儿)

    题目描述:数组中有一个数字出现的次数超过数组长度的一半,请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次,超过数组长度的一半,因此输出2。如果不存在则输出0。

    解题代码一:

    class Solution {
    public:
        int MoreThanHalfNum_Solution(vector<int> numbers) {
            if(numbers.empty()) return 0;
            
            map<int ,int> m;
            int size = numbers.size();
            int temp = size / 2;
            for(int i = 0; i < size; i++){
                if(m[numbers[i]] == 0){
                    m[numbers[i]] = 1;
                }else{
                    m[numbers[i]]++;
                }
            }
            map<int, int>::iterator iter;
            iter = m.begin();
            while(iter != m.end()){
                if( (iter->second) > temp){
                    return iter->first;
                }
                iter++;
            }
            return 0;
        }
    };

    解题思路:

    1. 首先用map来存储每个数字出现的次数。
    2. 最后遍历map里的值,谁大于数组长度的一半,则return对应map中的键。
    3. 由于用了map来存储键值数字,所以空间复杂度会多一个map的内存。

    新知识点:遍历哈希表map

    创建iter作为为遍历map的元素。

    map<int, int>::iterator iter;
    //遍历方法一:
    iter = m.begin()
    
    while(iter!=m.end){
    
        iter++;
    
    }
    
    //遍历方法二:
    for(iter = m.begin(); iter != m.end(); iter++){
        if( (iter->second) > temp){
            return iter->first;
        }
    }

    解题代码二:

    class Solution {
    public:
        int MoreThanHalfNum_Solution(vector<int> numbers) {
            //排除不可能
            if(numbers.empty()){
                return 0;
            }
            sort(numbers.begin(), numbers.end());
            int temp = numbers[0];
            int num = 1;
            int size = numbers.size();
            if(size == 1){
                return temp;
            }
            for(int i = 1; i < numbers.size(); i++){
                if(numbers[i] == temp){
                    num++;
                }else{
                    if(num > size / 2){
                        return temp;
                    }
                    temp = numbers[i];
                    num = 1;
                }
            }
            //判断最后一个数字的出现次数是否符合要求
            if(num > size / 2){
                return temp;
            }
            return 0;
        }
    };

    解题思路:

    1. 这个代码和代码一的区别在于,没有用到map来存储数字,内存消耗会少一点点。
    2. 首先用sort把vector从小到大排序一遍。
    3. 然后遍历排好序的vector,记录每个数出现的次数,如果不大于数组长度的一半,则丢弃该次数,重新计算下一个数字出现的次数。如果次数大于数组长度的一半,直接return 该数字。
    4. 如果遍历完vector,还没有,num依然不满足要求,就return 0。

    • 把数组排成最小的数(剑指欧肥儿)

    题目描述:输入一个正整数数组,把数组里所有数字拼接起来排成一个数,打印能拼接出的所有数字中最小的一个。例如输入数组{3,32,321},则打印出这三个数字能排成的最小数字为321323。

    解题代码:

    class Solution {
    public:
        string PrintMinNumber(vector<int> numbers) {
            if(numbers.empty()) return "";
            sort(numbers.begin(), numbers.end(), cmp);
            string s = "";
            for(int i = 0; i < numbers.size(); i++){
                s = s + to_string(numbers[i]);
            }
            
            return s;
        }
        
    private:
        static bool cmp(const int &a, const int &b){
            string A = to_string(a) + to_string(b);
            string B = to_string(b) + to_string(a);
            return A < B;
        }
    };

    解题思路:

    1. 解题关键在于,自定义C++的sort函数,用cmp来自定义排序vector数组(默认是从小到大地排序)。
    2. cmp函数自定义,对于数组的里的数首先转为string类型a, b。按照 若 a+b<b+a  则a排在在前的规则排序,如 2 21 因为 212 < 221 所以 排序后为 21 2 。
    3. 最后从左向右遍历经过sort排序后的数组,将遍历到的每个数转为string类型然后连接起来。

    新知识:

    1. sort排序,除了默认的,还可以自定义,用cmp函数。
    2. cmp函数在类里时,声明应该为static bool cmp(),必须有static;如果不在类里,可以没有static这个关键字。
    3. cmp里的参数最好是(const int&a, const int&b),即两个参数都应该是const类型,且是引用。当然,两个参数既不是引用也不是const程序也可以正确运行。
    4. cmp 是判断两个数字谁放在前面谁放在后面的规则。 最后return A > B,意味着从小到大地排序,如果是return A < B 意味着从大到小的排序。
    5. 将int转为string类型,除了用int x; streamstring ss; ss << x; ss.str()这样的方法还可以用最简单的方法,直接转换to_string(x),这样x就从int 转为 string了。

    • 最小的K个数(剑指欧肥儿)

    题目描述:输入n个整数,找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字,则最小的4个数字是1,2,3,4。

    解题代码一:

    #include <algorithm>
    
    class Solution {
    public:
        vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
            vector<int> v;
            if(k > input.size()) return v;
            if(input.size() < 1) return v;
            if(k < 1) return v;
            
            sort(input.begin(), input.end());
            for(int i = 0; i < k; i++){
                v.push_back(input[i]);
            }
            return v;
        }
    };

    解题思路:

    1. 解题关键就在于排序,而algorithm库就提供了sort函数供我们排序。
    2. 但是要注意的是,sort函数的使用 ,是基于引入了库函数algorithm的前提。

    解题代码二:

     

    解题思路:手动实现堆排序。


     

    展开全文
  • 数组

    2021-01-26 21:29:01
    描述 数组是相同类型数据的有序集合 特点: 1. 一旦创建,长度不变 2. 所有数据必须类型相同 创建数组的方式 1. int[] a = new int[ 5]; 2. int [] a = new int[5]; //多一个空格 3. int a[] = new int...
  • C语言关于数组与指针内容小结

    千次阅读 2016-05-08 14:31:46
    数组的基本概念 什么是数组数组就是:数组是相同类型的元素的一个集合 类型说明符 数组名 [常量表达式]; 其中,类型说明符是任一种基本数据类型或构造数据类型。数组名是用户定义的数组标识符。方括号中的...
  • 二维数组的地址描述

    2011-07-19 21:37:06
    为了便于理解将二维数组的形式看成数学上的矩阵一样按照行列的形式来排放:就像这样的形式,但是在存储的时候,这些数据都是按照线性的形式存储,按照这样的形式我们定义初始化这个数组:a[3][4]={{0,1,2,3},{4,5,6,...
  • 赋给数组 b 的语句是( )。 A)char b[10]={'H','e','l','l','o','!'}; B)char b[10];b="Hello!"; C)char b[10];strcpy(b,"Hello!"); D)char b[10]="Hello!"; 答案:B;只能在定义的时候使用=来初始化, 不能单独...
  • 第二,matrix是一个二维数组,二维数组在内存中是按行存放的,即先放第1行,再放第2行……每行中的元素是按列下标由小到大的次序存放,这样的存储方式也称为行优先存储。 第三,这里定义的数组 int *matrix是一个...
  • C语言中的数组学习c语言,数组很重要。...编译器根据这些信息正确的创建数组。普通变量可以使用的类型,数组元素都可以用。/*一些常用的数组声明*/float candy[365];//内涵365个float类型元素的数组char code...
  • c语言习题集合(数组

    千次阅读 2020-03-31 21:50:21
    以下关于数组描述正确的是( )。 A. 数组的大小是固定的,但可以有不同的类型的数组元素 B. 数组的大小是可变的,但所有数组元素的类型必须相同 C. 数组的大小是固定的,所有数组元素的类型必须相同 D. 数组的大小...
  • 目录 一.实验目的: 二.实验任务: 三.实验内容: 1.冒泡排序实验分析: 2.冒泡排序实验代码: 3.冒泡排序实验结果: ...4.二维数组实验分析: ...四....一.... 掌握一维数组和二维数组的定义、赋值和输入输出的方法。 能...
  • (3)数组既可以存储基本数据类型、也可以存储引用数据类型; (4)直接打印数组名称,得到的是数组对应堆内存中的内存地址哈希值。 public class Test01 { public static void main(String[] args) { int[] arr...
  • 对象数组

    2018-09-09 19:07:25
    问题描述: &nbsp;&nbsp;&nbsp; java 对象数组的使用 问题解决: 数组元素可以是任何类型(只要所有元素具有相同的类型) 数组元素可以是基本数据类型 数组元素也可以是类对象,称这样的数组为对象数组。...
  • 数组总结

    2019-12-24 23:12:53
    一、数组 ⑴定义 数组就是一组相同类型的变量...数组是用来存储一系列数据,但它往往被认为是一系列相同类型的变量。 所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素,最高的地址对应最后一个元素。...
  • JavaScript 数组

    2019-12-12 19:42:01
    JavaScript 数组用于在单一变量中存储多个值。 var score = [90, 80, 100]; 什么是数组数组是js创建好的对象,数组可以用一个单一的名称存放很多值,并且还可以通过引用索引号来访问这些值,批量管理变量。 创建...
  • 数组指针与指针数组

    2018-05-16 10:58:23
    一、数组指针 从名字上来说,数组指针的本质是一个指针,其指针指向一个数组,我们先举个数组指针的例子: int (*p)[4]; 我们都知道()括号运算符的优先级是最高的,变量描述符p使用*来进行修饰,表明p是一个指针。...
  • java调用参数为数组存储过程

    千次阅读 2011-03-29 14:41:00
    java调用参数为数组存储过程,主要是能正确的把java的数组类型转化为oracle能识别的的数组类型,这一步网上的例子很多,也就不多说了。在最初做这个的时候发现,当传入数字数组的时候,数组里的值能正确的插入到...
  • 因为数组是编程语言自带的,通常效率很高,能够满足不同需求的数据存储。让我们来学习 PHP 中数组的工作原理,以及使用的场景。 PHP 中数组的定义 首先我们了解下,数组的标准定义:数组,是有序的元素序列,元素...
  • 问题描述: 设有数组A[n,m],数组的每个元素长度为3字节,n的值为1~8,m的值为1~10,数组从内存收... 因为一般情况下存储单元是单一的存储结构,而数组可能是多维的结构,则用一维数组存储数组的数据元素就存...
  • 11.1 数组

    2020-11-20 09:08:43
    数组通常被用来储存程序需要的数据。例如,一个内含12个整数元素的数组可以储存12个月的天数。在这种情况下,在程序一开始就初始化数组比较好。下面介绍初始化数组的方法。 只储存单个值的变量有时也称为标量变量...
  • java面试题24 关于Java中的数组,下面的一些描述,哪些描述是准确的:() A 数组是一个对象,不同类型的数组具有不同的类 B 数组长度是可以动态调整的 C 数组是一个连续的存储结构 D:一个固定长度的数组可...
  • 在许多 C 程序中,指针...数组指针为了便于举例,下面的描述均以一个 int 数组为例。同样的原理可以应用于其他类型数组,包括多维数组。要声明指向数组类型的指针,必须使用括号,如下所示:int (* arrPtr)[10] = N...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 145,421
精华内容 58,168
关键字:

关于数组的存储描述正确的是