初始化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} ，先用任意一种算法对其进行排序，然后提示用户输入一个数字，应用本章的折半查找函数模板找出它的位置。
#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[ ] 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、
       }
    }
}

一、数组初始化：

数组属于引用数据类型，使用之前需要实例化

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.二分查找法(采用递归)

六、对象数组：

数组中存放的是对象。