精华内容
下载资源
问答
  • 今天看到一个有意思的面试题,大致是:找出一个数组中,某元素出现次数超过元素长度一半的元素。这题目的重点是:采用高效的算法。 查一圈资料,发现一个思路比较好。那就是:我们先假设这个元素存在,那么这个...

    今天看到一个很有意思的面试题,大致是:找出一个数组中,某元素出现次数超过元素长度一半的元素。这题目的重点是:采用高效的算法

    查了一圈资料,发现一个思路比较好。那就是:我们先假设这个元素存在,那么这个元素出现的次数一定比其他元素出现次数的和都要多。我们先假设第一个元素就是我们要找的元素num = arr[0],并定义一个计数器count,如果与下一个元素相同,count++;如果不同,count--。当count==0时,那么num=arr[i],count=1,继续下去。那么最后一次计数器count置为1时,这个元素arr[i]就是我们要找的元素了。

    代码如下:

    /**
     * 
     */
    public class GetNum {
        public static void main(String[] args) {
            int arr1[] = { 1, 2, 3, 2, 2, 2, 5, 4, 2 };
            int result1 = getNum(arr1);
            System.out.println(result1);
            int arr2[] = { 2, 2, 2, 2, 2, 1, 3, 4, 5 };
            int result2 = getNum(arr2);
            System.out.println(result2);
        }
    
        private static int getNum(int[] arr) {
            if (arr == null && arr.length < 1) {
                return -1;
            }
            int num = arr[0];
            int count = 1;
            // 遍历比较
            for (int i = 1; i < arr.length; i++) {
                if (num == arr[i]) {
                    ++count;
                } else {
                    count--;
                    if (count == 0) {
                        num = arr[i];
                        count = 1;
                    }
                }
            }
            // 验证num是不是目标数字,有可能并不存在这样的元素
            count = 0;
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] == num) {
                    count++;
                }
            }
            if (count >= arr.length / 2) {
                return num;
            }
            return -1;
        }
    }

    参考资料:https://blog.csdn.net/nwpu_geeker/article/details/79699348

    展开全文
  • 稀疏数组

    2021-03-04 11:05:11
    一.稀疏数组sparsearray 定义一个数组元素中大部分元素为0,或者为同一值时,可使用稀疏数组保存数组。即从原数组中抽取有效...因为该二维数组的很多值是默认值0,因此记录了很多没有意义的数据->稀疏数组,12

    一.稀疏数组sparsearray

    定义:当一个数组元素中大部分元素为0,或者为同一值时,可使用稀疏数组保存数组。即从原数组中抽取有效数据、剔除相同元素从而形成一个新的数组。

    处理方式:记录数组一共几行几列,有多少不同的值,把具有不同值元素的行列及值记录在一个小规模的数组中,从而缩小数组的规模。

    应用场景举例说明:稀疏数组的第一行记录的是原数组的行列数(12)以及多少个有效值(16),注意行列数都是从0开始

    因为该二维数组的很多值是默认值0,因此记录了很多没有意义的数据->稀疏数组,12*12 --> 3*17。

    应用实例:

    1)使用稀疏数组,来保存二维数组

    2)把稀疏数组存盘,并且可以重新恢复原来的二维数组

    3)整体思路分析

    二维数组 转 稀疏数组的思路:

    1.遍历原始的二维数组,得到要保存的有效数据个数sum

    2.根据sum就可以创建稀疏数组sparseArr int[sum+1][3](加1是因为要放整体行列)

    3.将二维数组的有效数据存入到稀疏数组中

    稀疏数组 恢复 二维数组的思路:

    1.先读取稀疏数组的第一行,根据第一行的数据创建原始二维数组。

    2.读取稀疏数组后几行的数据并赋给原始的二维数组即可。

    代码实现:

    public static void main(String[] args) {
        // 创建原始二维数组12 * 12
        // 0 表示没有棋子,1表示蓝子,2表示黑子
        int[][] chaseArr = new int[12][12]; // 数组的创建是new的,即可看作对象,在堆内存中划分区域,有初始化0
        chaseArr[2][3]  = 1;
        chaseArr[2][4]  = 1;
        chaseArr[2][5]  = 2;
        chaseArr[2][6]  = 1;
        chaseArr[3][4]  = 2;
        chaseArr[3][5]  = 1;
        chaseArr[3][6]  = 2;
        chaseArr[4][3]  = 2;
        chaseArr[4][4]  = 2;
        chaseArr[4][5]  = 1;
        chaseArr[4][6]  = 2;
        chaseArr[4][7]  = 2;
        chaseArr[5][2]  = 1;
        chaseArr[5][4]  = 1;
        chaseArr[5][6]  = 2;
        chaseArr[5][8]  = 1;
        System.out.println("原始二维数组:");
        for(int[] row : chaseArr){ // 行
            for(int data : row){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }
    
        // 二维数组转为稀疏数组
        // 1.遍历原始的二维数组,得到要保存的有效数据个数sum
        int sum = 0;
        for(int[] row : chaseArr) { // 行
            for (int data : row) {
                if(data != 0) sum++;
            }
        }
        // System.out.println(sum);
    
        // 2.根据sum就可以创建稀疏数组sparseArr int[sum+1][3]
        int[][] sparseArr = new int[sum + 1][3];
        // 将二维数组的有效数据存入到稀疏数组中
        sparseArr[0][0] = 12;
        sparseArr[0][1] = 12;
        sparseArr[0][2] = sum;
    
        int count = 0; // 计数器
        for (int i = 0; i < 12; i++) {
            for (int j = 0; j < 12; j++) {
                if(chaseArr[i][j] != 0){
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chaseArr[i][j];
                }
            }
        }
        System.out.println("---------------");
        System.out.println("得到的稀疏数组:");
        for(int[] row : sparseArr){ // 行
            for(int data : row){
                System.out.printf("%d\t",data); // 有所间隔
            }
            System.out.println();
        }
    
        // 稀疏数组 恢复 二维数组
        // 1.先读取稀疏数组的第一行,根据第一行的数据创建原始二维数组。
        int[][] arr = new int[sparseArr[0][0]][sparseArr[0][1]];
        // 2.读取稀疏数组后几行的数据并赋给原始的二维数组即可。
        for (int i = 1; i < sparseArr.length; i++) {
            arr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
    
        System.out.println("---------------");
        System.out.println("恢复的二维数组:");
        for(int[] row : arr){ // 行
            for(int data : row){
                System.out.printf("%d\t",data); // 有所间隔
            }
            System.out.println();
        }
    }

    运行截图:

                  

     

    参考博客:https://blog.csdn.net/weixin_44187730/article/details/95617193

    展开全文
  • 我们使用类来定义很多相同结构的对象的时候,我们可以采取对象数组的方法。 例如,一个班有50个学生,我们定义了一个学生类,该类的学生具有相同的数据成员和成员函数,我们就可以定义一个这样的数组。 代码如下:...
  • C++的对象数组

    2013-09-05 08:57:00
    我们使用类来定义很多相同结构的对象的时候,我们可以采取对象数组的方法。 例如,一个班有50个学生,我们定义了一个学生类,该类的学生具有相同的数据成员和成员函数,我们就可以定义一个这样的数组。 ...

    类是对象的抽象,我们可以使用一个类来定义很多的对象,然后每个对象都有自己的属性。

    当我们使用类来定义很多相同结构的对象的时候,我们可以采取对象数组的方法。

    例如,一个班有50个学生,我们定义了一个学生类,该类的学生具有相同的数据成员和成员函数,我们就可以定义一个这样的数组。

    Student stdu[50];//假设已经声明了Student类,定义stud数组,有50个元素

    ======================对象数组的初始化=========================

    在建立数组时,同样要调用构造函数。如果有50个元素,就需要调用50次构造函数。在需要的时候,可以在定义数组时提供实参以实现初始化。

    如果构造函数只有一个参数可以这样初始化:

    Studet stud[3]={60,70,80};//三个实参分别传递给3个数组元素的构造函数


    如果构造函数有多个参数时,应该这样做:

    Student stud[3]={//假设构造函数有3个参数
        Student(10,20,30),//调用第一个元素的构造函数,提供3个实参
        Student(40,50,60),//调用第二个元素的构造函数,提供3个实参
        Student(70,80,90) //调用第三个元素的构造函数,提供3个实参
    };
    在建立对象数组时,分别调用构造函数,对每个元素初始化。每一个元素的实参分别用括号括起来,对应构造函数的一组形参。

    ===================一个对象数组的例子=================

    要求:建立一个对象数组,内放5个学生的数据(学号,成绩),设立一个函数max,在max函数中找出5个学生中成绩最高者,并出输出结果。

    #include<iostream>
     #include<string>
     using namespace std;
     class Student
    {
     	public:
     		Student(string , int );//声明构造函数 
    		void Print();//声明信息输出函数 
    		string num;
    		int score; 
    };
     Student::Student(string n,int s)
    {
     	num=n;
     	score=s;
     }
     void Student::Print()
    {
     	cout<<num<<"\t"<<score<<endl;
     }
     int main()
    {
     	Student stud[5]={
    	 	Student("001",90),
    	 	Student("002",94),
    	 	Student("003",70),
    	 	Student("004",100),
    	 	Student("005",60)	
    	 };
    	 int max,i=0,k=0;
    	 max=stud[0].score;
    	 for(i=0;i<5;i++)
    	 	{
    	 		cout<<stud[i].num<<"\t"<<stud[i].score<<endl;
    	 		if(stud[i].score>max)
    	 		{
    		  		k=i;
    		  		max=stud[i].score;
    	 		}
    	 	}
     	cout<<"=============MAX:==========="<<endl;
    	stud[k].Print();
    	cout<<endl; 
     }
     




    转载于:https://www.cnblogs.com/zhezh/p/3773522.html

    展开全文
  • 在网上看了很多两个等长有序数组求位数的文章,但我都觉得有点儿问题。等下会说我觉得问题在哪里。 先说下位数定义当数组元素个数为奇数个的时候,位数就是中间的数字,比如数组[1,2,3,4,5],那么3就是位...

    在网上看了很多两个等长有序数组求中位数的文章,但我都觉得有点儿问题。等下会说我觉得问题在哪里。

    先说下中位数定义:当数组元素个数为奇数个的时候,中位数就是中间的数字,比如数组[1,2,3,4,5],那么3就是中位数。如果数组元素个数为偶数个的时候,那么中间两个元素的平均值就是中位数的值,比如数组[1,2,4,5],那么中位数就是(2+4)/2=3.

    定义清楚了下面就来说下两个等长数组求中位数的问题,为了简化问题,直接假设两个数组都按从小到大顺序排列好了。两个等长数组,那么总的元素个数肯定为偶数,那么结果就肯定是某两个数字的平均值。

    求解方法基本都一样,就是用二分搜索的思路来做。假设有两个数组A,B,首先用两个指针a,b分别指向A,B中间的数字,然后比较这两个数字,假设a指向数字大于b的数字,那么结果肯定不在a指向数字的右边和b指向数字的左边。然后分别向左向右移动a,b两个指针,再次进行比较。就是二分搜索的思路。

    然后说问题,在网上看了好多博客,求得的结果都是指针移动的最后结果是A中某一元素和B中某一元素一起作为结果。但我认为这是不对的,因为最终结果的两个数字完全可以在同一个数组中,假设有两个数组

    A:1 2 7 9 10
    B:3 4 5 6 8
    合并后中位数应该是5 和 6,两个数都在数组B中,并不是A、B各一个数。

    网上很多人写的迭代结束条件都是找到了a=b或者最后子数组长度都为1,我觉得结束条件应该是找到a=b或者数组长度为2。

    可能对于这个问题有点儿钻牛角尖了,思路大家基本都差不多,只是我在迭代的结束条件上和大家看法不太一样,也许我考虑的有问题,希望各位批评指正。

    以下是实现代码:

    #include <stdio.h>


    void findMedian(int first[],int second[],int length);


    int result[4];//因为是迭代为2的时候结束,所以会有4个数字对于四个数字应该还排下序,然后取中间两个,这里直接打印输出
    int main(void){
    int first[]={1,2,3,6,11};
    int second[]={4,7,8,10,12};
    findMedian(first,second,5);//随便写的两个数组例子
    printf("%d  %d  %d  %d\n",result[0],result[1],result[2],result[3]);//
    }

    void findMedian(int first[],int second[],int length){
    if(length<=2){
    result[0]=first[0];
    result[1]=first[1];
    result[2]=second[0];
    result[3]=second[1];
    }
    int low1=0,low2=0,high1=length-1,high2=length-1;
    int current1,current2,k1,k2;
    while(length>2){
    current1=(low1+high1)/2;
    current2=(low2+high2)/2;
    if(first[current1]==second[current2]){
    printf("The median is %d\n",first[current1]);

     //因为主函数中有输出,所以这里就赋了下值

    result[0]=first[current1];

    result[1]=first[current1];
    result[2]=first[current1];
    result[3]=first[current1];

    return;
    }
    else if(first[current1]>second[current2]){

    //k1 k2表示当前指针和边界的距离,因为存在奇偶问题,所以k1和k2不一定相同,指针移动时候要移动二者中较小的距离
    k1=high1-current1;
    k2=current2-low2;
    if(k1==k2){
    high1=current1;
    low2=current2;
    length-=k1;
    }
    else if(k1>k2){
    high1=current1+1;
    low2=current2;
    length-=k2;
    }
    else{
    high1=current1;
    low2=current2-1;
    length-=k1;
    }
    }
    else{
    k1=current1-low1;
    k2=high2-current2;
    if(k1==k2){
    high2=current2;
    low1=current1;
    length-=k1;
    }
    else if(k1>k2){
    low1=current1-1;
    high2=current2;
    length-=k2;
    }
    else{
    high2=current2+1;
    low1=current1;
    length-=k1;
    }
    }
    }

    result[0]=first[low1];
    result[1]=first[high1];
    result[2]=second[low2];
    result[3]=second[high2];
    }

    展开全文
  • C语言标准规定,当数组名作为数组定义的标识符(也就是定义或声明数组时)、sizeof 或 & 的操作数时,它才表示整个数组本身,在其他的表达式,数组名会被转换为指向第 0 个元素的指针(地址)
  • 因此,在一个数组中,数组元素的类型是唯一的,即一个数 组里只能存储一种数据类型的数据,而不能存储多种数据类型的数据。 •一旦数组的初始化完成,数组在内存中所占的空间将被固定下来,因此数组的长度将不...
  • 文章目录一、实际应用♦ 场景♦ 分析问题二、稀疏数组介绍♦ 定义♦ 稀疏数组的处理方法三、应用实例♦ 需求分析♦ 代码实现▶创建原始二维数组▶创建稀疏数组▶稀疏数组还原成二维数组...一个数组中大部分元素为0..
  • 了很多行错误,最后一行错误如图所示。 ![图片说明](https://img-ask.csdn.net/upload/202010/06/1601967887_228609.png) 还有个问题是,书上说数组返回首元素的指针和尾元素下一个位置的指针的begin函数还有...
  • php基础(20)_数组

    2020-09-10 16:54:37
    此类型在很多方面做优化,因此可以把它当成真正的数组,或列表(向量),散列表(是映射的一种实现),字典,集合,栈,队列以及更多可能性。由于数组元素的值也可以是另一个数组,树形结构和多维数组也是允许的。...
  •  为什么需要数组呢,我们定义一个变量时可以使用一个变量名来表示,但是如果出现很多个变量分别取变量名就比较麻烦。 为了解决这个问题,我们就采用了数组的形式来进行储存,用数组的下标来表示每个变量。生活...
  • 比如要表示数组中i行j列一个元素: *(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j] 就指向指针的指针,早以前在说指针的时候说过,但后来发现很多人还是比较难以理解,这一次我们再次仔细说一说指向指针的指针。...
  • 判断变量为空,在许多场合都会用到,但也有很多新手...说明:它并不会判断变量是否为空,并且可以用来判断数组中元素是否被定义过 注意:使用isset来判断数组元素是否被初始化过时,它的效率比array_key_exists高...
  •   最近在解决去重问题上,搜到一个使用 reduce 来进行去重的,几行代码解决了当数组元素是对象时,要求按照某一属性对数组的对象进行去重的问题, reduce 这个方法感觉可以挖掘的东西还很多,写此文章记录总结...
  • 组定义为VB格式的数组时VB竟然崩溃了···,可能是因为VB编程环境容不下这么的数据,因为我定义了一个有2560个字节元素的 字节数组,每当复制到VB代码编辑窗口的时候就崩溃了,所以我没有在VB实现,但这并不...
  • 1.24 我在一个文件中定义了一个extern数组,然后在另一个文件中使用,为什么sizeof取不到数组的大小?  声明问题  1.25 函数只定义了一次,调用了一次,但编译器提示非法重声明了。  *1.26 main的正确定义是...
  • KMP算法学习浅析

    2018-08-31 15:40:12
    了很多大佬的解析,感觉比较舒服的就是https://www.cnblogs.com/yjiyjige/p/3263858.html的文章了 文章有很多的插图方便大家更好的理解next数组定义以及KMP算法的实现 next数组的每一个元素值就是P[j] != ...
  • 下标表示了元素数组中的顺序号。数组元素的一般形式为: 数组名[下标] 其中的下标只能为整型常量或整型表达式。如为小数时,C编译将自动取整。例如,a[5],a[i+j],a[i++]都是合法的数组元素。 数组元素通常也称为...
  • 两数之和

    2020-02-22 14:24:52
    此题我用的暴力法,用两个for循环实现,当数组中第i个元素与第j个元素相加恰好等于目标值的时候,输出i,j。 两个循环是并列的,刚开始第二个for循环我写在了第一个循环里面,也没有定义i,j为常量,所以出现了很多...
  • VBSCRIPT中文手册

    热门讨论 2010-11-12 10:13:06
    FormatCurrency 函数 返回的表达式为货币值格式,其货币符号采用系统控制面板中定义的。 FormatDateTime 函数 返回格式化为日期或时间的表达式。 FormatNumber 函数 返回格式化为数的表达式。 FormatPercent 函数...
  • 原文地址:http://www.docwar.com/b/15001/5.htm使用... 工具条的定制 工具条的是定义在一个JavaScript数组中的,它包含editor中可用的,显示在"toolbarrows"的元素。有两种方式为editor设置你想要的工具。他可
  • 在结构化存储数据集是常常使用数组即顺序表,但数据庞大时用数组往往比较繁琐,例如我需要在数组中间添加一个元素进去,则需要移动很多元素,而且在定义数组大小时,小会溢出,大会浪费。 而链表正是代替...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 255
精华内容 102
关键字:

当数组中定义了很多元素