精华内容
下载资源
问答
  • 初始化int类型数组data1[ ]={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20}先使用任意一种算法对其排序提示用户输入一个数字,应用折半查找函数模板找出它的位置。 #include <iostream> using ...

    初始化int类型数组data1[ ]={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20}先使用任意一种算法对其排序提示用户输入一个数字,应用折半查找函数模板找出它的位置。

      #include <iostream>
      using namespace std;
      template<class T>
       //这里使用了冒泡法排序:
      void mySwap(T&x, T&y)//交换x,y的值
      {
          T temp = x;
        	x = y;
        	y = temp;
       }
        
        template<class T>
        void bubblesort(T a[], int n)//用冒泡法对数组a的n个元素进行排序
        {
    	int i = n - 1;
    
    	while (i > 0)
    	{
    		int lastExchangeIndex = 0;
    		for (int j = 0; j < i; j++)
    		    if (a[j+1]<a[j])
    		{     
    				mySwap(a[j], a[j + 1]);
    				lastExchangeIndex = j;
    		}
    		i = lastExchangeIndex;
    	}  
    }
    
    template<class T>
    int BinSearch(const T list[], int n, const T key)//用折半查找法,在元素呈升序排列的数组list中查找值为key的元素
    {
    
    	int low = 0;
    	int high = n - 1;
    	while (low <= high)
    	{
    		int mid = (low + high) / 2;
    	
    		if (key == list[mid])
    			return mid;
    		else if (key>list[mid])
    			low = mid + 1;
    		else
    			high = mid - 1;
    	}
    	return -1;
    }
    
    
    int main()
    {
    	int key, mid, n = 20;
    	int i;
    	int data1[] = { 1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20 };
    	cout << "数组排序后:" << endl;
    	 bubblesort(data1, n);
    	 for ( i = 0; i < 20; i++)
    	 {
    		 cout << data1[i]<<",";
    	 }
    	 cout << endl;
    	 cout << "请输入key:" << endl;
    	cin >> key;
    	cout << key <<"在数组第:"<<BinSearch(data1, n, key)+1 <<"个数字"<< endl;//数组首元素从1开始算起
    }
    

    在这里插入图片描述

    展开全文
  • 初始化 int 类型数组 data 1 []={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20} ,先用任意一种算法对其进行排序,然后提示用户输入一个数字,应用本章的折半查找函数模板找出它的位置。...

    初始化 int 类型数组 data 1 []={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20} ,先用任意一种算法对其进行排序,然后提示用户输入一个数字,应用本章的折半查找函数模板找出它的位置。

    #include<iostream>
    
    using namespace std;
    
    template<class T>
    
    void BubbleSort(T list[], int n)
    {
    	for (int i = 0; i < n - 1; i++)  //冒泡
    	{
    		int t;
    		for (int j = 0; j < n - i - 1; j++)
    		{
    			if (list[j] > list[j + 1])
    			{
    				t = list[j];
    				list[j] = list[j + 1];
    				list[j + 1] = t;
    			}
    		}
    	}
    }
    
    template<class T>
    
    int binSearch(T list[], int n, T key)
    {
    	int begin, mid, end;
    	begin = 0;
    	end = n - 1;
    	while (begin <= end)
    	{
    		mid = (begin + end) / 2;
    		if (key == list[mid])
    			return mid;
    		else if (key > list[mid])
    			begin = mid + 1;
    		else
    			end = mid - 1;
    	}
    	return -1;
    }
    
    int main()
    {
    	int data1[] = { 1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20 };
    	int key, n = 20;
    
    	BubbleSort(data1, n);     //冒泡
    	
    cout << "排序后的数组为:" << endl;
    	for (int i = 0; i < n; i++)
    	{
    		cout << data1[i] << "  ";
    	}
    
    	cout << endl;
    	cout << "请输入所要查找的数字:";
    	cin >> key;
    	cout << "在数组中的位置:"<<binSearch(data1, n, key) << endl;
    }
    

    上一篇:用函数模板方式设计一个函数模板Sort

    展开全文
  • 数组属于引用数据类型,在使用前必须初始化,否则会报NullPointerException(空指针异常:运行时异常) 一维数组初始化: 动态初始化:(声明并开辟数组) 数据类型[ ] 数组名称=new 数据类型[长度] int[ ] ...

    数组属于引用数据类型,在使用前必须初始化,否则会报NullPointerException(空指针异常:运行时异常)
    一维数组初始化:
    动态初始化:(声明并开辟数组)
    数据类型[ ] 数组名称=new 数据类型[长度]

    int[ ] data=new int [5] :声明并开辟一个长度为5的数组

    数组通过下标索引来获取元素,下标默认从0开始。数组下标超出数组长度,数组越界异常(运行时异常)

    数组中每个元素都有默认值,默认值是该数据类型默认值

    数组长度:数组名称.length

    数组遍历推荐使用JDK1.5 提供for-each循环(仅限于数组内容读取),要修改数组内容,还是使用常规for循环

        for(int x : data)
    

    {
    System.out.println(x+" ");
    }
    引用传递:多个栈内存指向同一块堆内存

    int[ ] tmp=data; //引用传递 注意是地址的传递
    tmp[3]=10; ----> x[3]=10;

    数组静态初始化
    简化格式:
    数据类型[ ] 数组名称 ={值,值…}
    完整格式: (推荐使用)
    数据类型[ ] 数组名称 =new 数据类型[ ]{值,值…}
    int[ ] data =new int[ ] {1,2,3} ;

    长度 :数组名称.length ,静态初始化长度固定,根据值的个数确定长度,并且长度不可修改

    匿名数组:没有任何栈内存指向,在使用一次后会变成垃圾,只会使用一次

    二维数组
    动态初始化:数据类型[ ][ ] 数据名称 =new 数据类型[ 行个数] [列个数]

    int[ ] [ ]data =new int [3][4];开辟行数为3,列数为4的整型数组

    静态初始化:
    数据类型[ ][ ] 数组名称 =new 数据类型[ ][ ]{ {第一行的值},{第二行的值}…}

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

    x<data.length

    y<data[x].length

    对象数组初始化:

    首先看对象数组动态初始化:

    对象数组动态初始化
    public class ArrayDemo
    {
        public static void main(String[] args)
        {
            String[] str=new String[3];  //数组动态初始化,每个元素都是其对应数据类型的默认值
            for(String num :str)
            {
                System.out.print(num+"、"); //null、null、null、
            }
            str[0]=new String("pick");
            str[1]=new String("happy");
            str[2]=new String("day");
           for(String num :str)
           {
               System.out.print(num+"、"); //pick、happy、day、
           }
        }
    }
    

    对象数组静态初始化:

    public class ArrayDemo
    {
        public static void main(String[] args)
        {
            String[] str=new String[]{"pick","happy","day"};  //数组静态初始化,pick、happy、day、
           for(String num :str)
           {
               System.out.print(num+"、"); //pick、happy、day、
           }
        }
    }
    
    展开全文
  • 数组

    2019-08-19 20:43:31
    一、数组初始化数组属于引用数据类型,使用之前需要实例化 int[] data=null;//定义一个数组为null data=new int[3];//初始化数组 data[1]=00;data[1]=11;data[1]=22; 动态初始化数组先开辟内存空间,然后...

    一、数组初始化:
    数组属于引用数据类型,使用之前需要实例化

    int[] data=null;//定义一个数组为null

    data=new int[3];//初始化数组

    data[1]=00;data[1]=11;data[1]=22;

    动态初始化:数组先开辟内存空间,然后通过索引进行内容的设置(上面是动态初始化)

    静态初始化:在数组定义的时候同时设置数组的内容  

    int[] data={00,11,22}

    new int[]{00,11,22}

    二、数组引用传递

    栈内存中存放数组引用类型对象的地址(引用地址),堆内存中存放数组的值(具体数组对象)

    同一块堆内存空间可以被不同的栈内存所指向

    三、数组缺陷,常用方法

    数组最大是缺陷是长度固定

    数组排序:java.util.Arrays.sort

    数组拷贝:System.arraycopy(原数组名称,原数组开始点,目标数组名称,目标数组开始点,拷贝长度)

    四、数组转置(数组首尾交换):

    1.开辟一个新的数组,将原始数组倒序保存进去。开辟了两个相同的内存空间,造成了资源的浪费

    2.在一个数组上完成转换

    五、查找指定数组中某个数据的位置

    1.整体数组遍历。顺序查找

    时间复杂度n

    2.二分查找法(采用递归)

    六、对象数组:
    数组中存放的是对象。

     

    展开全文
  • 036集 数组初始化和赋值以及随机化 void init_rand() { time_t ts;//时间类型变量 unsigned int srand_data = time(&ts); srand(srand_data);//用时间设置时间参数种子 } //初始化随机数组 int create...
  • Java数组----引用数据类型,必须在使用前先初始化;否则会nullPointerException(运行时异常)。 (引用传递:多个栈内存指向同一块堆内存) 1.一维数组初始化 (1)动态初始化(声明并开辟数组) 数据类型[] 数组...
  • 对 复合类型数组、切片、字典、结构体)变量的初始化是,有一些语法限制: 1、初始化表达式必须包含类型标签; 2、左花括号必须在类型尾部,不能另起一行; 3、多个成员初始值以逗号分隔; 4、允许多行,但...
  • C++ Vector数组初始化(一维,二维)

    千次阅读 2019-11-06 11:10:48
    Vector数组快速声明与初始化 一维 以int类型为例子 设置数组长度的默认初始vector<int> data(N); N为默认数组长度,默认初始值为0 设置数组长度的给定值初始vector<int> data(N,value); N为...
  • memset是一个字节一个字节的设置,把一个int的每个字节都设置为1,也就是0x01010101,(十六进制1位是二...当初始化char类型数组 初始化多少都可以 char data[10]; memset(data,0,sizeof(data)); // right memset(...
  • Java数组用法总结

    2019-12-12 20:55:57
    java 数组总结 数组定义:一组相关(相同)类型的变量的集合并且这些变量可以按照统一的方式进行操作。...int[0]=1//动态初始化 int[1]=3 int[2]=4 第二:静态初始化 数据类型 数组名称={值,值,值…}...
  • 8_ 数组

    2020-12-16 21:29:22
    什么是数组数组可以存储多个类型一致的元素。...初始化的方式:(初始化的时候必须确定数组的长度) 第一种方式:int[] data = new int[3];//按照默认值初始化 0 第二种方式:int[] data = new int
  • 1.数组初始化 ... eg:声明并开辟一个长度为5的数组 int[ ] data = new int[5];  a.数组通过下标索引来取得元素,下标默认从0开始。数组下标超出数组长度,数组越界异常(运行时异常)  b.数组...
  • 1.数组初始化 1.1动态初始化(声明并开辟数组) 数据类型[ ] 数组名称=new 数据类型[长度] eg:int[] data =new int[5]; a、数组通过下标索引来取得元素,下标默认从0开始。数组下标超出数组长度,数组越界...
  • Java数组

    2019-03-07 21:01:29
    声明并初始化数组 数据类型[] 数组名称 = new 数据类型[长度]; 声明并开辟长度为3的整型数组 int[] data = new int[3]; I.当开辟数组空间后,所有数组内容为其数据类型默认值 II.访问数组元素使用数组名称[索引下标]...
  • Java 数组

    2015-01-05 14:00:57
    Java 基础部分 —— 数组 基本类型数组 对象数组 Array 类 Arrays 类 基本类型数组、对象数组: 声明与创建: int a[] = new int[100] ;...int b[] ;...数组的初始化int a[] = {1,2,3}; int[] a
  • Java学习——数组

    2018-10-18 17:05:29
    1.数组的动态初始化( 声明并开辟数组): 数据类型[] 数组名称 = new 数据类型 [长度] ; eg: int[] data = new int[10]; 注: 数组的访问通过索引来完成,即 数组名称[索引],其中索引从0开始到数组长度-1,...
  • 数组和指针

    2018-05-24 22:59:16
    数组的定义;int 数组名【】,声明数组:数据类型 数组名称...声明完数组后,可以借助数组的索引(即下标)对数组成员的进行赋值,索引一般是大于零的,初始化数组的方法:类型 数组名 【】={ , , , , , , };...
  • Java 数组 note

    2019-01-05 11:05:12
    引用数据类型在使用之前一定要声明和初始化。 声明完成后,JVM还没给元素分配内存空间。 初始化: 静态初始化,动态初始化数组是引用数据类型。 一维数组 声明: 元素数据类型 数组变量名 int intArray[]...
  • 6.4二维数组

    2019-09-26 12:49:48
    动态初始化:数据类型 数组名称[][]=new 数据类型[行的个数][列的个数] 静态初始化:数据类型 数组名称[][]=new 数据类型 [][]{}{值,值,值}{值,值,值}} 范例:定义二维数组 public class Array108 { public ...
  • Java之数组

    2019-04-11 18:13:21
     声明并初始化数组:数据类型 [ ] 数组名称 = new 数据类型 [ 长度 ]; eg: 声明并开辟长度为3的整型数组 int [ ] data = new int [ 3 ]; 注意: a.当开辟数组空间后,所有数组内容为其数据类型默认值 b.访问数组...
  • JavaSE - 数组

    2018-11-23 12:03:16
    数组属于引用数据类型,必须在使用前初始化,否则会报NullPointerException异常(运行时异常)。 引用传递:多个栈内存指向同一个堆内存。 1.动态初始化(声明并开辟数组) 数据类型[] 数组名称 = new 数据类型...
  • 14-JAVA数组

    2020-09-05 18:55:09
    文章目录数组一维数组数组的遍历数组是一种引用数据类型可变长参数数组扩容数组的特点定义方法删除数组中的元素对象数组二维数组二维数组初始化Arrays工具类数组的几个算法冒泡排序选择法排序二分查找 数组 一维...
  • java数组基本概念

    2018-10-24 18:04:03
    数组动态初始化 数组是引用数据类型,有内存分配问题。 数组动态初始化(声明并开辟数组): 数组类型[] 数组名称 = new 数组类型[长度]; int[] data = new int[5]; a.数组通过下标索引来取得元素,默认从0开始。...
  • 折半查找函数模板举例

    千次阅读 2010-05-31 20:39:00
    初始化int类型数组data1={1,3,5,7,9,11,13,15,17,19,2,4,6,8,10,12,14,16,18,20},提示用户输入一个数字,应用折半查找函数模板找出它的位置。 #include<iostream><br />using namespace std; ...
  • 1.java数组动态初始化(只要看见new 就在堆上开辟一块新空间) 数据类型[] 数组名称 = new 数组类型[长度] eg:int[] data =new int[5]; a.数组元素访问通过索引完成,下标默认从0开始。如果索引下标超过数组长度,...
  • 数组初始化 动态初始化 数组定义与为数组元素分配空间和赋值的操作分开进行 数据类型[] 数组名=new 数据类型[长度]; int[] data = new int[5]; 注意:元素为引用数据类型数组中的每一个元素都需要实例化。 ...
  • 第六章数组

    2019-09-30 21:40:13
    一、填空题 1、 Java中的数组属于引用数据类型,其实例化...3、 对象数组采用动态初始化时,数组中的每个元素内容为________对应数据类型默认值_。 二、选择题 1、 关于“int data [] = new int[10]”的语句以下那种...

空空如也

空空如也

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

初始化int类型数组data