精华内容
下载资源
问答
  • 如何计算数组地址

    2019-12-12 16:04:27
    设: 数组定义为A[ , …] 现在查找数组A[ , …] (其中 任意n 都存在>) 数组内每个元素地址大小为 size 地址为 ...

    设:                                      

    数组定义为A[ , ]

    现在查找数组A[ , ]   (其中 对任意n 都存在>

    数组内每个元素的地址大小为 size

     

    则其地址为

     

    展开全文
  • 设每个元素的大小是size,首元素地址a[1], a[i] = a[1] + (i-1)*size 若首元素地址a[0] 则a[i] = a[0] + i*size 二维数组地址计算 (m*n的矩阵) 行优先 设每个元素的大小是size,首元素地址a[1][1]...

    一维数组的地址计算
    设每个元素的大小是size,首元素的地址是a[1],则
    a[i] = a[1] + (i-1)*size

    若首元素的地址是a[0]
    a[i] = a[0] + i*size

    二维数组的地址计算 (m*n的矩阵)
    行优先
    设每个元素的大小是size,首元素的地址是a[1][1],则a[i][j]?
    分析:a[i][j]位于第i行,第j列。它之前有i-1行,在第i行它之前有j-1个元素。
    a[i][j] = a[1][1] + [n*(i-1) + (j-1)]*size

    三维数组的地址计算 (rmn) r行m列n纵
    行优先
    首元素的地址a[1,1,1]

    a[i,j,k] = a[1,1,1] + [(i-1)*n*m + (j-1)*n + (k-1)]*size

    压缩存储:指为多个值相同的元素只分配一个存储空间,对零元素不分配存储空间,其目的是为了节省存储空间。

    二维数组通常用来存储矩阵,特殊矩阵分为两类
    (1)元素分布没有规律的矩阵,按照规律对用的公式实现压缩。
    (2)无规律,但非零元素很少的稀疏矩阵,只存储非零元素实现压缩。

    一、三角矩阵
    包括上三角矩阵,下三角矩阵和对称矩阵
    (1)若i<j时,ai,j=0,则称此矩阵为下三角矩阵。
    (2)若i>j时,ai,j=0,则称此矩阵为上三角矩阵。
    (3)若矩阵中的所有元素满足ai,j=aj,i,则称此矩阵为对称矩阵。
    下三角
    在这里插入图片描述
    上三角
    在这里插入图片描述

    二、三对角矩阵
    在这里插入图片描述
    带状矩阵的压缩方法:将非零元素按照行优先存入一维数组。
    (1)确定一维数组的存储空间大小:2+(n-2)*3+2 = 3n-2
    (2)确定非零元素在一维数组中的地址
    loc(i,j) = loc(1,1) + 前i-1行非零元素个数+第i行中ai,j前非零元素的个数
    前i-1行:3 * (i-1) - 1,因为第一行只有两个,所以要减去1
    第i行中ai,j前非零元素的个数=(j-i)+1,
    j-i有三种情况:
    (1)j<i j-i=-1
    (2)j==i j-i=0
    (3)j>i j-i=1

    loc(i,j) = loc(1,1) + 3(i-1)-1 + j-i+1 = loc(1,1) + 2(i-1) + j-1 = loc(1,1) + 2i+j-3

    展开全文
  • 数组名 a 的含义是指二维数组的首元素首地址。这和一维数组名做右值时的含义是一样的。 区别在于,二维数组和一维数组对于内部包含的元素的大小单元的概念是不一样的。 一维数组可以看作是将变量作为数组元素,由...

    二维数组名在含义上和一维数组名的含义一样
    假如有一个二维数组 :a[3][2](从数组名作为右值的角度分析)
    则数组名 a 的含义是指二维数组的首元素首地址。这和一维数组名做右值时的含义是一样的。
    区别在于,二维数组和一维数组对于内部包含的元素的大小单元的概念是不一样的。

    一维数组可以看作是将变量作为数组元素,由多个相同类型的变量顺序排列而组成。
    二维数组可以看作是将一维数组作为数组元素,由多个相同长度大小的一维数组顺序排列而成。

    所以一维数组以变量作为元素,二维数组以一维数组作为元素。

    从而,可以将 a[3][2] 拆成三个一维数组,即 (a[0])[2] ; (a[1])[2] ; (a[2])[2];这三个一维数组的数组名,就是用括号括起来的部分,即 a[0] ;a[1] ;a[2] ;

    从而,再分析 a 的含义,可以得到的是,a 做右值时,是二维数组中首个一维数组的首地址,也就是二维数组中首个一维数组的地址。

    所以可以得到结论就是,二维数组中的数组名作为右值时,它代表的是一个一维数组的地址。所以用来做左值的指针P,必须是一个数组指针
    所以在给指针P赋值时,可以写成P = a;也可以写成P = &a[0];
    为什么可以写成P = &a[0]?前面提到过,a[3][2]由(a[0])[2] ; (a[1])[2] ; (a[2])[2];这三个一维数组组成,所以二维数组的第一个元素(即能代表整个一维数组的)就是a[0]。对第一个元素a[0]取地址赋予指针P,其意义和P = a;完全相同。

    int a[3][2];
    int (*p)[2];
    p = a;
    p = &a[0];//都是取了二维数组第一个元素的地址(只是二维数组的元素是一维数组,取数组的地址需要用数组指针)
    

    那怎么用指向变量的普通指针指向二维数组中的某个值呢?即有用一个 int *p;指针指向a[3][2]中某个变量。

    int a[3][2];
    int *p;
    p = a[0];//p就指向了二维数组的第一个变量
    p = &a[0][0];//与上面的语句含义相同
    

    还是同样的道理,始终离不开对数组名的含义的理解。
    前面提到过,在a[3][2]中,有三个一维数组(a[0])[2] ; (a[1])[2] ; (a[2])[2];这三个一维数组的数组名,就是用括号括起来的部分,即 a[0] ;a[1] ;a[2] ;而数组名的含义是该数组的首元素首地址。
    所以这里a[0]做右值,就是向p传递a[0]这个数组的首元素的首地址,由于a[0]是一个一维数组,所以其首元素首地址就是一个int型变量的地址,和int *p;刚好对应。
    &a[0][0]的意思也是取一维数组a[0]的首元素的首地址。和a[0]做右值的含义完全相同。

    最后,如果想让int *p;指向a[2][1];则书写如下:
    p = &a[1][0];

    展开全文
  •   在数组中的两个数字,如果前面一个数字大于后面的数字,这两个数字组成一个逆序。输入一个数组,求出这个数组中的逆序的总数。 题目地址 示例 1: 输入: [7,5,6,4] 输出: 5 这里的思路主要就是利用了归并...

    一、剑指Offer 51 数组中的逆序对

      在数组中的两个数字,如果前面一个数字大于后面的数字,则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数。

    题目地址

    示例 1:
    
    输入: [7,5,6,4]
    输出: 5
    

    这里的思路主要就是利用了归并的思想,举个例子,对于[1,4,5,7] ,[2,3,6,8]这两个待归并的序列,
    在这里插入图片描述

      当a[i] > a[j]的时候 显然 [i, m]这个闭区间的所有元素都大于a[j],此时可以将j为2时候的逆序对全部加入,个数为 m - i + 1,当i > m的时候对于当前的j来说就没有逆序对了。

    在这里插入图片描述

      还有一种思路是当a[i] <= a[j]的时候,对于i来说[m+1, j - 1]这个闭区间的所有元素都是小于a[i]的,数量为j - m - 1,在 j > r 的时候对于当前i之后位置的每个元素来说都有j - m - 1 也等于r - m个逆序对。这种方式计算的就是对于当前的i,他右边的逆序对的个数,这个思想下一道题会用到。

    class Solution {
        int m_count;
    public:
        int reversePairs(vector<int>& nums) {
            m_count = 0;
            mergeSort(nums, 0, nums.size() - 1);
            return m_count;
        }
     
        void merge(vector<int>& a, int l, int m, int r) {
            int i = l, j = m + 1;
            vector<int> aux(r - l + 1);
            
            for(int k = 0; k < r - l + 1; k++) {
                if(i > m) {
                    aux[k] = a[j++];
                }
                else if(j > r) {
                    //m_count += j - m - 1;
                    aux[k] = a[i++];
                }
                else if(a[i] <= a[j]) {
                    //m_count += j - m - 1;
                    aux[k] = a[i++];
                }
                else {
                    m_count += (m - i + 1);
                    aux[k] = a[j++];
                }
            }
            // while (i <= m && j <= r){
            //     if(a[i] <= a[j]){
            //         aux[k++] = a[i++];
            //     }else {
            //         aux[k++] = a[j++];
            //         m_count = m_count + (m - i + 1);
            //     }
            // }
            // while (i <= m){
            //     aux[k++] = a[i++];
            // }
            // while (j <= r){
            //     aux[k++] = a[j++];
            // }
            ::copy(aux.begin(), aux.end(), a.begin() + l);
        }
    
        void mergeSort(vector<int>& a, int l, int r) {
            if(l >= r) return;
    
            int m = l + (r - l) / 2;
    
            mergeSort(a, l, m);
            mergeSort(a, m + 1, r);
    
            merge(a, l, m, r);
        }
    
    };
    

    二、LeetCode 315 计算右侧小于当前元素的个数

      给定一个整数数组 nums,按要求返回一个新数组 counts。数组 counts 有该性质: counts[i] 的值是 nums[i] 右侧小于 nums[i] 的元素的数量。

    题目地址

    示例:
    
    输入:nums = [5,2,6,1]
    输出:[2,1,1,0] 
    解释:
    5 的右侧有 2 个更小的元素 (21)
    2 的右侧仅有 1 个更小的元素 (1)
    6 的右侧有 1 个更小的元素 (1)
    1 的右侧有 0 个更小的元素
    
    提示:
    0 <= nums.length <= 10^5
    -10^4 <= nums[i] <= 10^4
    

      这道题有个比较特殊的地方是要返回原来每个位置元素右边逆序的个数,由于在归并的过程中某个元素的下标会不断改变,那么可以思考这样的思路:将每个元素和他的初始下标用pair关联起来,在交换元素的时候就可可以查看到原始的下标,再根据上题目的第二种思路就可以得到某个元素i右边的逆序数的个数。

    class Solution {
        vector<pair<int, int>> m_vpairs;
    public:
        vector<int> countSmaller(vector<int>& nums) {
            int n = nums.size(), l = 0, r = n - 1;
            vector<int> ans(n);
            
            for(int i = 0; i < n; i++){
                m_vpairs.push_back({nums[i], i});
            }
    
            mergeSort(nums, ans, l, r);
            return ans;
        }
    
        void merge(vector<int>& ans, int l, int m, int r) {
            int i = l, j = m + 1;
            vector<pair<int, int>> sort_vpairs(r - l + 1);//为了节约时间,每次不必复制整个数组,只需要复制待归并的区间就行
    
            for(int k = 0; k < r - l + 1; k++){
                if(i > m) {
                    sort_vpairs[k] = m_vpairs[j++];
                }
                else if(j > r) {
                    ans[m_vpairs[i].second] += j - m - 1;
                    sort_vpairs[k] = m_vpairs[i++];
                }
                else if(m_vpairs[i].first <= m_vpairs[j].first) {
                    ans[m_vpairs[i].second] += j - m - 1;
                    sort_vpairs[k] = m_vpairs[i++];
                }
                else{
                    sort_vpairs[k] = m_vpairs[j++];
                }
            }
            ::copy(sort_vpairs.begin(), sort_vpairs.end(), m_vpairs.begin() + l);
        }
    
        void mergeSort(vector<int>& nums, vector<int>& ans, int l, int r) {
            if(l >= r) return;
            int m = l + (r - l) / 2;
    
            mergeSort(nums, ans, l, m);
            mergeSort(nums, ans, m + 1, r);
    
            merge(ans, l, m, r);
        }
    };
    
    展开全文
  • 数组指针 与 指针数组 是一对容易混淆的概念。...数组型的 p,执行 p++, p 的地址增加 n * 4。 例如: 1 int a[3][4]; 2 int (*p)[4]; // 该语句是定义一个数组指针,指向含4个元素的一维数组 3 ...
  • 本文以实例分析了C++语言中关于[]静态数组和new分配的动态数组的区别,可以帮助大家加深...sizeof(a)=sizeof(*a)=4,因为地址位数为4字节,int型也占4字节。 二、静态数组作为函数参数时,在函数内对数组名进行sizeof
  • 其中 0 i, 则对 a 数组元素的引用不正确的是 A) a[p-a] B) &a[i]) C) p[i] D) (a+i) 解析A p 开始是数组 a地址只要 p++ 则再减去 a 的首地址 a[p-a] 就能取到所有 元素 B &a[i] 循环取其地址 &a[i]
  • 其中 0i,则对 a 数组元素的引用不正确的 A) a[p-a] B) &a[i]) C) p[i] D) (a+i) 解析A p 开始是数组 a地址只要 p++则再减去 a 的首地址a[p-a]就能取到所有 元素B &a[i]循环取其地址&a[i]) 是该地址中所存
  • 数组在内存中连续存储,数组为数组所占内存的首地址。 多维数组的存储,这里以二维数组 int a[2][3]为例 左边为高位,右边为低位 a[0][0] a[0][1] a[0][2] a[1][0] a[1][1] a[1][2] //这种存储方式...
  • 其中0i,则对a数组元素的引用不正确的是 a[p-a]?B) &a[i]?C) p[i]?D) (a+i) 解析Ap开始是数组a首地址只要p++则再减去a的首地址a[p-a]就能取到所有元素B&a[i]循环取其地址&a[i]?是该地址中所存储的元素 Cp就是指针...
  • 杂项

    2019-11-26 17:35:17
    C++语言函数不能进行嵌套定义。 int a[5],*p=a;则对 a 数组元素地址的正确引用是
  • 1.指针的值代表其指向对象的起始地址,指针的...2对于一维数组:若int a[10],则a为该数组的首个元素的常量指针,指向a[0],可通过首地址加偏移量的方法其它元素进行寻址。a[i]的地址应为a+i。而&a则为指向有10个整型
  • JavaScript 数组去重

    2021-01-10 02:39:09
    <div><h1>Why underscore <p>(觉得这部分眼熟的可以直接跳到...但是如果数组元素全部是基础类型的 Number 值,键值法应该是最高效的! 方法五 (ES6) <p>ES6 部署了 Set 以及 Array...
  • _.findIndex 的作用就是从一个数组中找到第一个满足某个条件的元素,_.findLastIndex 是找到最后一个(或者说倒序查找)。 举个简单的例子: <pre><code> javascript var arr = [1, 3...
  • //在一般指针变量指向二维数组,或者n维数组,要直接操作a[i][j],指针的操作必须有两个符号(其中不出现&,如果有&相应的加上* 的个数): //1、两个* //2、两个[] //3、一个* 一个[] //4、有一个*或[ ]代表数组中...
  • 二维数组

    2014-06-03 16:07:35
    二维数组,每个元素的长度为t个字节,设为A的第一个元素,即二维数组的行下标从p到m,列下标从q到n,按“行优先顺序”存储时则元素地址计算为: 按“列优先顺序”存储时,地址计算为: 存放该数组至少需要的...
  • (1) 静态数组名进行sizeof运算时,结果是整个数组占用空间的大小; 因此可以用sizeof(数组名)/sizeof(*数组名)来获取数组的长度。 int a[5];...sizeof(a)=sizeof(*a)=4,因为地址位数为4字节,in
  • 如果a是一维数组名,a[i]代表a数组第i个元素所占的内存单元的内容。a[i]是有物理地址的,是占内存单元的。但如果a是二维数组,a[i]是代表一维数组名。它只是一个地址(如同一维数组名只是一个指针常量一样。) a...
  • 字符数组的初始化

    2017-11-15 14:57:09
    #有关字符数组的初始化的若干问题# 一、注意事项: 1.字符数组的初始化,初始化时赋予的...4.字符数组进行不完全初始化,从低地址a[i]中i从0开始)到高地址逐个字符依次初始化,未被初始化的元素默认为空(即'\0
  • 定义一个整型数组a[n],下面用五种方法对其从小到大排序。...同理对a[1],a[2],...a[n-1]处理,即完成排序。下面列出其代码: void bubble(int *a,int n) /*定义两个参数:数组地址数组大小*/ { int i,j
  • 概览 数组在C语言中有着特殊的地位,它有很多特性,例如它的存储是连续的,数组的名称就是...同时数组不能先声明再一次性赋值(当然可以每个元素一一赋值)。 #include int main(){ int len = 2; //int a[len]
  • 假设一维数组A = (A1, A2, A3, …, Ai,…, An),每个元素占L个存储单元,则元素A[i]的存储地址为 LOC(A[i]) = LOC(A[1]) + (i - 1)* L 二维数组的存储 二维数组可以有两种存储方式,行序主序和列序主序。 假设二
  • (2)、第二种是用一维数组来表示二维数组,从显示的元素地址可以看出,二维数组和一维数组表示的二维数组在内存中的储存方式其实是一样的,不过使用二维数组看起来要简单些,只要不用进行地址转换。 (3)、第三...
  • 数组名表示该数组的首地址 eg: int a[10]={0,1,2,3,4,5,6,7,8,9}, *p=a;...a表示数组a的第一个元素地址,*p=a则表示p指向了数组a的第一个元素地址,p-a=0,所以a[p-a]为a[0],p[i]相当于a[i]. 取地址运算符...
  • (十二)对象数组以及Vector类实现

    千次阅读 2014-01-19 16:32:27
    数组的定义 ...一个有n个数据元素的一维数组,设a0是下标为0的数组元素,Loc(a0)是a0的内存单元地址,k是每个数据元素所需的字节个数,数组中任一数据元素ai的内存单元地址Loc(ai)可由下面公式求出:
  • 数组排序法(一)

    2016-09-18 19:19:55
    让我们先定义一个整型数组a[n],下面用五种方法对其从小到大排序。...同理对a[1],a[2],…a[n-1]处理,即完成排序。下面列出其代码:void bubble(int a,int n) /定义两个参数:数组地址数组大小*/{int i,j,temp;
  • C语言数组排序总结

    千次阅读 2010-04-22 17:11:00
    (1)“冒泡法” 冒泡法大家都较熟悉...同理对a[1],a[2],...a[n-1]处理,即完成排序。下面列出其代码:void bubble(int *a,int n) /*定义两个参数:数组地址数组大小*/ { int i,j,temp; for(i=0;ifor(j=i+1;jif(a[i
  • 详解多维数组与指针之间的关系

    千次阅读 多人点赞 2018-04-16 18:22:43
    在内存中示意图是:在CPU看来内存是一组连续的地址空间,所以当我们一维数组进行操作时只需要知道数组地址,就可以通过地址偏移加减运算方式来求得每个元素位于内存中的文件映射出来的数据段虚拟地址!...

空空如也

空空如也

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

则对a数组元素地址