java基础（数组的操作）

java基础（数组的操作）

第一部分

1、选择排序

1.1、选择排序主要的针对的是数组的排序，因为数组有角标，可以通过角标方便对数组进行操作；

1.2、选择排序主要的思想是：

根据数组的角标来一次进行比较，如：用0角标的元素分别和1、2.......角标的元素进行比较，元素最小的值进行换位操作后放在0角标的位置上，那么现在在0角标的元素就不需要再参加比较了，然后就是用1角标位的元素和其他角标的元素进行比较，以此类推最左边的就是最小值，最右边就是最大值；

1.3、选择排序特点：第一个元素和其他的元素进行比较，然后第二个元素和后面的元素依次进行比较，但是每次比较的次数逐渐较少，这是就是大圈套小圈的原理，也就是for语句的嵌套循环；

选择排序方法的返回值类型是void，因为它们操作的都是同一个数组，只不过是数组的顺序发生了变化，但是函数操作的还是同一个数组；自始至终在堆内存中就是一个实体，只不过是多个引用在同时操作一个数组；

1.4、用图形表示：

1.5、代码体现

class ArrayTest 
{
	public static void selectSort(int[] arr) 
	{
//		外循环控制的是比较的次数
		for (int x=0; x<arr.length-1; x++)
		{
//			内循环将第一个元素和其他的元素挨个进行比较
//			x+1保证的是前后两个元素进行的比较
			for (int y=x+1; y<arr.length; y++)
			{
//				用外循环的第一个元素和内循环的每个元素进行比较				
				if(arr[x]>arr[y])
				{
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
	}
	public static void main(String[] args)
	{
		int[] arr ={5,1,6,4,2,8,9};
//		排序前
		printArr(arr);
//		排序
		selectSort(arr);
//		排序后
		printArr(arr);
		
	}
//	把打印语句封装起来
	public static void printArr(int[] arr)
	{
		System.out.print("[");
		for (int x=0; x<arr.length; x++)
		{
			if(x!=arr.length-1)
				System.out.print(arr[x]+",");
			else
				System.out.println("]");
		}
	}
}

1.6、运行的结果

1.7、选择排序的特点：内循环结束一次，最值出现在头角标的位置上；

1.8、总结

1.8.1、选择排序的特点：当拍完顺序以后最值要么在最右边，要么在最左边；

1.8.2、选择排序用到了大圈套小圈的原理，也就是for循环嵌套；

1.8.3、注意在内循环和外循环的初始化值和判断条件；

1.8.4、当一个类里面出现多个功能时时，要将这些功能进行封装，提高了代码的复用性；

2、冒泡排序

2.1、冒泡排序的原理：相邻的两个元素进行比较，如果符合条件的话，那么就交换位置；每次都是相邻的两个元素进行比较，但是每次比较过后，下一次比较就少了一个元素参与比较，

2.2、用图形表示：

1.3、代码体现

class BubbleSort 
{	public static void main(String[] args) 
	{
		int[] arr ={8,212444,667,43,6443,1667,2323};
		printArray(arr);
		//冒泡排序
		bubbleSort(arr);
		printArray(arr);
	}
	public static void bubbleSort(int[] arr)
	{
		for (int x=0; x<arr.length-1; x++)
		{
//			-x：是让每次循环的元素一次减少，-1是防止内循环的角标越界。
			for (int y=0; y<arr.length-x-1; y++)
			{
//				相邻的两个元素进行比较
				if(arr[y]>arr[y+1])
				{
					int temp = arr[y];
					arr[y] = arr[y+1];
					arr[y+1] = temp;
				}
			}
		}
	}
	//对排好顺序的数据进行打印。
	public static void printArray(int[] arr)//返回值类型是void的，不要return
	{
		System.out.print("[");
		for (int x=0; x<arr.length; x++)
		{
			if(x!=arr.length-1)
			{
				System.out.print(arr[x]+",");
			}
			else
				System.out.println(arr[x]+"]");
		}
	}

}

1.4、运行后的结果

1.5、总结

1.5.1、冒泡排序的思想是相邻两个元素进行比较，用到的嵌套循环的思想，在比较完第一圈以后，最值出现在了最右边，在排序完了以后，最大值和最小值出现在了左右两边；

1.5.2、如果符合条件的话，那么就要交换位置；

1.5.3、注意在循环的初始化值和循环的条件；

1.5.4、如果是按照右大到小的顺序进行排序的话，那么就要改变交换元素的条件；

3、排序的总结

3.1、排序算法：冒泡排序，选择排序，快速排序，插入排序，希尔排序；

3.2、在以上的这些排序里面，它们中效率较高的是冒泡排序，效率最高的是希尔排序；

3.3、这些排序的比较方式差不多，但是它们的比较方式不同，正是由于这个原因，它们的比较效率就不同

第二部分

1、获取最大值

1.1、思路：

• 获取最值需要进行比较，每一次比较都会有一个较大的值，因为该值不确定通过临时一个变量进行存储；
• 让数组中的每一个元素都和这个变量中的值进行比较，如果大于了变量中的值，就用该变量记录较大值；
• 当所有元素都比较完成，那么该变量中的存储的就是数组中的最大值了；

1.2、步骤：

• 定义变量，初始化为数组中任意一个元素即可；
• 通过循环语句对数组进行遍历；
• 在遍历过程中定义判断条件，如果遍历到的元素比变量中的元素大，那么就复制给该变量；

1.3、代码展现

/*
获取数组中的最值。
*/

class  ArrayTest
{
	public static void main(String[] args) 
	{
		int[] arr ={4,32,56,87,86,53};
		System.out.println(getMax(arr));
	}


	public static int getMax(int[] arr)
	{
		int max =arr[0];//定义一个变量，初始化为数组中的一个元素。
		for(int x=1;x<arr.length;x++)//对数组进行遍历
		{
			if(arr[x]>max)//如果数组里面的值大于变量的值。
				max=arr[x];//那么就用变量记住这个值。
		}
		return max;//返回一个值。
	}
}

1.4、运行结果

2、获取最小值

2.1代码体现

/*
获取数组中的最小值。
*/

class  ArrayTest
{
	public static void main(String[] args) 
	{
		int[] arr ={4,32,56,87,86,53};
		System.out.println(getMin(arr));
	}


	public static int getMin(int[] arr)
	{
		int min =arr[0];//定义一个变量，初始化为数组中的一个元素。
		for(int x=1;x<arr.length;x++)//对数组进行遍历
		{
			if(arr[x]<min)//如果数组里面的值小变量的值。
				min=arr[x];//那么就用变量记住这个值。
		}
		return min;//返回一个值。
	}
}

 

2.2、运行结果

第三部分

1、一般的查找

1.1、一般查找的过程是在遍历的过程中找到元素的位置，因此在函数的返回值类型是int类型，返回来的是元素所在位置的角标值，但是函数的传入的参数分别是需要折半的数组和需要查找的元素的位置；

1.2、用代码实现

</pre><pre name="code" class="java">class  ArrayTest4
{
	public static void main(String[] args) 
	{
		int[] arr ={5,2,67,97,54,224};
		int index = getIndex(arr,54);
//
		System.out.println("index="+index);//查找的是角标，如果存在就返回角标，不存在就返回-1；
	
	}

	//定于功能，获取key第一次出现在数组中的位置，
	public static int getIndex(int[] arr,int key)
	{
		for(int x=0;x<arr.length;x++)
		{
			if(arr[x]==key)
				return x;
		}
//		如果没有找到该元素，那么就用-1来代表
		return -1;
	}

}

1.3、运行的结果

2、折半查找

2.1、折半查找的思想：我想在0~100之间需要一个数，那么这时就将0~100折半查找，就是50，这样的查找就大大的缩小了范围，也就是提高了效率，但是折半查找有一个前提就是这个数组必须是有序的数组；

2.2、折半的步骤：要在一个有序的数组中需要查找一个元素的角标，折半查找，如果发现这个需要找的元素的值比折半后查找的值要大的话，那么左边的就要移到中间角标+1的位置，如果发现要找的元素比中间的元素要小的话，那么右边大的那么就要移到中间角标-1的位置，继续查找；

2.3、代码体现

class  ArrayTest4
{
	public static void main(String[] args) 
	{
//		int[] arr ={5,2,67,97,54,224};
//		int index = getIndex(arr,54);
////
//		System.out.println("index="+index);//查找的是角标，如果存在就返回角标，不存在就返回-1；
	
		int[] arr = {4,7,89,456,7886,43335};
		int index = halfSearch(arr,43335);
//		int index = index_2(arr,456);
		System.out.println("index="+index);//查找的是角标，如果存在就返回角标，不存在就返回-1；
	
	}
	public static int halfSearch(int[] arr,int key)
	{
		int min,max,mid;
		min =0;
		max =arr.length-1;
		mid =(min+max)/2;
		
		//用的条件是中间值不等于key来完成的。
		while(arr[mid]!=key)//这边用的是中间角标的元素和指定的值进行比较，
		{
			if(key>arr[mid])
				min = mid+1;
			else if(key<arr[mid])//是元素和指定的值进行比较。
				max = mid-1;
			
			//做了两次判断，
			if(min>max)
				return -1;
			mid =(max+min)/2;//循环进行折半。
		}
		return mid;//返回一个中间值。
	}
}

2.3、运行结果

3、查找总结

1、一般的查找是需要查找的元素和数组中的元素依次进行比较，如果元素相同的话，那么就返回该元素的角标值，如果没有该元素的话，那么就返回-1；

2、折半查找：可以大大的提高了查找的效率；进行循环折半查找，如果找到了，就返回该元素的角标值，如果没有找到，那么就返回-1；

3、面试题：如果想要将一个元素插入到一个有序数组中而且还有保证元素的有序，思路：通过折半的形式，查找角标在数组中的位置，如果存在，那么就存在的位置插入即可，如果不存在，那么就返回最小角标值，这个值就是要插入的位置。