Java基础_03_Java数组

_____Java数组_____

初识数组

定义：

数组就是同一种类型数据的集合，就是一个容器

申明数组的方式:

1.元素类型[] 数组名 = new 元素类型[数组长度]

int[] arr = new int[5];

2.元素类型[] 数组名 = new 元素类型[]{元素，元素,...}

int[] arr = new int[]{1,2,3,4,5};
int[] arr = {1,2,3,4,5};

操作数组的方式：

int[] arr = new int[]{1,2,3,4,5};
int num = arr[1];//取得下标为1的数据，下标从0开始
arr[0] = 5;//将下标0处的数据替换成数值5

其实数组中存储的不是数据本身，而是数据在堆内存中的地址（补充Java程序在运行时候将内存分成了5块方法区，本地方法区，寄存器，栈内存和堆内存），如图：

当我们的arr数组在栈中被释放或者引用改变的时候，堆内存所属arr指向的那块内存会因为没有引用而被JVM的垃圾回收器回收，从而避免了内存泄漏，这是Java相对于C++的优势

数组的排序方式(升序为例)

1.选择排序

原理：

第一次，从n 个记录中找出关键码最小的记录与第一个记录交换；
第二次，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；
.....
当然我们也可以一次同时记录最大值和最小值，这样可以节约1/2的时间

实现：

</pre><pre name="code" class="java">void selectSort(int[] arr, int n) {
	for(int i=0; i<n; i++) {
		for(int j=i+1; j<n; j++) {
			if(arr[i] > arr[j]) {
				int temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
}

2.冒泡排序

原理：
利用类似水泡上浮，在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
实现：

void bubbleSort(int[] arr, int n) {  
    for(int i =0 ; i< n-1; ++i) {  
        for(int j = 0; j<n-i-1; j++) {  
            if(arr[j] > arr[j+1]) {  
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }  
        }  
    }  
}

3.选择排序

原理：
随机在数组中选择一个元素当基准，比数组元素小的排在左边，大的右边，再对两边进行同样的操作
实现：

void swap(int[] arr,int a, int b)  
{
    int temp = arr[a];
    arr[a] = arr[b];
    arr[b] = temp;
}
int partition(int arr[], int low, int high)  
{
    int privotKey = arr[low];
    //从表的两端交替地向中间扫描
    while(low < high){
    //从high所指位置向前搜索，至多到low+1位置，将比基准元素小的交换到低端
        while(low < high  && a[high] >= privotKey)
        high--;
        swap(arr,low, high);
        while(low < high  && a[low] <= privotKey )
        low++;
        swap(arr,low, high);
    }
    return low;
}
void quickSort(int arr[], int low, int high){  
    if(low < high){
    	//将表一分为二
        int privotLoc = partition(arr,  low,  high);
        //递归对低子表递归排序
        quickSort(arr,  low,  privotLoc -1);
        //递归对高子表递归排序
        quickSort(arr,   privotLoc + 1, high);
    }
}

数组的查找方式

折半查找：

无序数组遍历查找，这里介绍个有序数组查找方式：

void int binarySearch(int[] arr, int len, int num)
{
    int low = 0;
    int high = len - 1;
    while(low <= high)
    {
        int middle = (low + high)/2;
        if(arr[middle] == numm)
            return middle;
        //在左半边
        else if(a[middle] > num)
            high = middle - 1;
        //在右半边
        else
            low = middle + 1;
    }
    //没找到返回-1
    return -1;
}