java中数组的常见操作

数组的常见操作：

1.遍历

int[] array = {1,23,5,2323,43,56};
for(iint x = 0; x < array.length; x++)
{ 
     System.out.println("array["+x+"] =" + "["+ array[x] + "]");
}

2.最值

	/*
	max和min分别用了记录索引和值的不同方式，具体使用哪个，根据个人喜好
	*/
	/*
	 max变量的意思是，当前最大值对应的索引值
	*/
	public int getMax(int[] array)
	{
		int max = 0;
		for(int x = 1; x < array.length; x++)
		{
			if( array[x] > array[max])
			{
				max = x;
			}
		}

		return array[max];
	}
	
	/*
	min代表的是最小的值
	*/
	public int getMin(int[] array)
	{
		int min = array[0];
		for(int x = 1; x < array.length; x++)
		{
			if(array[x] < min)
			{
				min = array[x];
			}
		}

		return min;
	}

3.排序

1> 选择排序

选择排序的过程图解：

示例代码：

/*
	选择排序:
	原理:
		1.第一轮比较: 取数组中的第一个元素，与其后面的每一个元素进行比较，如果后面的元素比该元素小，
		  位置互换，然后继续用该位置的元素与后面的元素比较，直到数组末尾；经过一轮比较后，
		  数组的0索引对应的元素一定是该数组中最小的一个；
		2.第二轮比较用数组中的索引1的元素执行1的步骤，当第二轮执行完后，该位置的元素为第二小，
		  后面的元素同理，就可以完成数组的排序。
	*/
	public void selectorSort(int[] array)
	{
		//x < array.length-1
		//最后一个元素没有比较的意义，所以减一
		for(int x = 0; x < array.length-1; x++)
		{
			for(y = x+1; y < array.length; y++)
			{
				if(array[y] < array[x])
				{
					swap(array,x,y);
				}
			}
		}
	}

	private void swap(int[] array, int x, int y)
	{
		int temp = array[x];
		array[x] = array[y];
		array[y] = temp;
	}

优化后的代码：

	/*
	记录小的数值的索引位置，当一轮比较完毕后，进行一次换位操作，
	执行过程减少位置交换的次数，来提高效率。
	*/
	public static void selectorSort(int[] array)
	{
		int tempIndex;

		for(int x = 0; x < array.length-1;x++)
		{
			tempIndex = x;
			for(int y = x+1; y < array.length; y++)
			{
				if(array[y] < array[tempIndex])
				{
					tempIndex = y;
				}
			}

			if(tempIndex != x)
			{
				swap(array,x,tempIndex);
			}			
		}
	}

2> 冒泡排序

冒泡排序图解：

示例代码：

/*
	冒泡排序一
	*/
	public void bubbleSort(int[] array)
	{
		for(int x = 0; x < array.length-1; x++)
		{
			for(int y = 0; y < array.length-1-x;y++)
			{
				if(array[y] > array[y+1])
				{
					swap(array,y,y+1);
				}
			}
		}
	}

	/*
	冒泡排序二
	*/
	public void bubbleSort()
	{
		for(int x = array.length-1; x > 0; x--)
		{
			for(int y = 0; y < x; y++)
			{
				if(array[y] > array[y+1])
				{
					swap(array,y,y+1);
				}				
			}
		}
	}

4.折半查找

	/*
	折半查找
	1.如果找到查询的key，返回该关键字在数组中的位置；
	2.如果没找到，则返回该查找key所在数组中的负的插入点减1的位置。
	*/
	public int binarySearch(int[] array, int key)
	{
		int low = 0;
		int high = array.length-1;
		int mid;

		while(low <= high)
		{
			mid = (low + high)>>1;
			if(array[mid] > key)
			{
				high = mid-1;
			}
			else if(array[mid] < key)
			{
				low = mid+1;
			}
			else
			{
				return mid;
			}
		}

		return -low-1;
	}
	/*
	面试题：
		给定一个有序的数组，如果往该数组中添加一个元素，
		并保证该数组依然有序，那么这个元素的添加位置的索引如何获取？
	解答：
		利用折半查找的原理，查找该元素需要添加的索引位置。
	*/