2020/8/17
求数组中的最大最小值
【代码】
package HeadFirst;
/*
求数组中的最大最小值
*/
public class Test8 {
public static void main(String[] args) {
int [] num={12,3,54,67,88,24};
int max=max(num);
int min=min(num);
System.out.println("数列中的最大值是:"+max);
System.out.println("数列中的最小值是:"+min);
}
//求数列中的最大值
public static int max(int[] num){
int max=num[0];
int len=num.length;
for(int i=1;i<len;i++){
if(num[i]>max){
//材料中的方法
/*
num[i]=num[i]+max;
max=num[i]-max;
num[i]=num[i]-max;
*/
max=num[i];
}
}
return max;
}
//求数列中的最小值
public static int min(int[] num){
int min=num[0];
int len=num.length;
for(int i=1;i<len;i++){
if(num[i]<min){
min=num[i];
}
}
return min;
}
}
#冒泡排序算法
冒泡排序算法运作如下:(从后往前)
比较相邻的元素。如果第一个比第二个大,就交换他们两个。
对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤,除了最后一个。
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
相同的元素前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。
【代码】
package HeadFirst;
/*
冒泡排序算法运作如下:(从后往前)
比较相邻的元素。如果第一个比第二个大,就交换他们两个。
对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤,除了最后一个。
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
相同的元素前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。
34 4 56 17 90 65
4 34 17 56 65 90 //第一轮 5次
4 17 34 56 65 //第二轮 4次
4 17 34 56 //第三轮 3次
4 17 34 //第四轮 2次
4 17 //第五轮 1次
*/
public class Test9 {
public static void main(String[] args) {
int [] nums={34,4,56,17,90,65};//待排序的数列
//外循环控制轮数
for (int i=0;i<nums.length-1;i++){//比较的轮数等于数列的长度-1
for (int j=0;j<nums.length-1-i;j++){
if(nums[j]>nums[j+1]){
nums[j]=nums[j]+nums[j+1];
nums[j+1]=nums[j]-nums[j+1];
nums[j]=nums[j]-nums[j+1];
}
}
}
//输出结果
for (int n:nums){
System.out.println(n);
}
}
}
选择排序法
每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。选择排序是不稳定的额排序方法。
【代码】
package HeadFirst;
/*
选择排序法,每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。选择排序是不稳定的额排序方法。
34 4 56 17 90 65
4 34 56 17 90 65 第一轮 5次
4 17 34 56 90 65 第二轮 4次
4 17 34 56 90 65 第三轮 3次
4 17 34 56 90 65 第四轮 2次
4 17 34 56 65 90 第五轮 1次
*/
public class Test10 {
public static void main(String[] args) {
int[] nums={34,4,56,17,90,65};
int minIndex=0;//用于记录每次比较的最小值下标
//控制轮数
for(int i=0;i<nums.length-1;i++){
minIndex=i;//每轮假设一个最小值下标
for(int j=i+1;j<nums.length;j++){
if(nums[minIndex]>nums[j]){
minIndex=j;
}
}
//判断需要交换的数下标是否为自己
if(minIndex!=i){
nums[minIndex]=nums[minIndex]+nums[i];
nums[i]=nums[minIndex]-nums[i];
nums[minIndex]=nums[minIndex]-nums[i];
}
}
//输出结果
for(int n:nums){
System.out.println(n);
}
}
}
直接插入排序算法
直接插入排序算法
(从后向前找到合适的位置后插入)
基本思想:每步将一个待排序的记录,按其顺序码大小插入到前面已经排好序的字序列的合适位置(从后向前找到合适位置后),直到全部插入排序完为止。
package HeadFirst;
/*
直接插入排序算法
(从后向前找到合适的位置后插入)
基本思想:每步将一个待排序的记录,按其顺序码大小插入到前面已经排好序的字序列的合适位置(从后向前找到合适位置后),直到全部插入排序完为止。
34 4 56 17 90 65
第一轮:i=1 34 34 56 17 90 65
4 34 56 17 90 65
第二轮:i=2 4 34 56 17 90 65
4 34 56 56 90 65
第三轮:i=3 4 34 34 56 90 65
4 17 34 56 90 65
第四轮:i=4 4 17 34 56 90 65
4 17 34 56 90 90
第五轮:i=5 4 17 34 56 65 90
*/
public class Test11 {
public static void main(String[] args) {
int [] nums={34,4,56,17,90,65};
//控制比较的轮数
for(int i=1;i<nums.length;i++){
int temp=nums[i];//记录操作数
int j=0;
for(j=i-1;j>=0;j--){
if(nums[j]>temp){
nums[j+1]=nums[j];
}else {
break;
}
}
if(nums[j+1]!=temp){
nums[j+1]=temp;
}
}
//输出结果
for(int n:nums){
System.out.println(n);
}
}
}
二分查找算法
二分查找(折半查找):前提是在已经排好序的数组中,通过将待查找的元素与中间索引值对应的元素进行比较,若大于中间索引值对应的元素,去右半部分查找,否则,去左半部分查找。依此类推,直到找到为止;找不到返回一个负数。
package HeadFirst;
/*
二分查找(折半查找):前提是在已经排好序的数组中,通过将待查找的元素与中间索引值对应的元素进行比较,若大于中间索引值对应的元素,去右半部分查找,否则,去左半部分查找。依此类推,直到找到为止;找不到返回一个负数。
*/
public class Test12 {
public static void main(String[] args) {
//必须保证数列是有序的
int []num={10,20,50,65,88,90};
int index=binarySearch(num,88);
System.out.println(index);
}
//二分查找算法
public static int binarySearch(int[]num,int key){
int start=0;//开始下标
int end=num.length-1;
while (start<=end){
int middle=(start+end)/2;//>>>1
if(num[middle]>key){
end=middle-1;
}else if(num[middle]<key){
start=middle+1;
}else{
return middle;
}
}
return -1;
}
}
Arrays工具类
Arrays工具类:用来操作数组(比如排序和搜索)的各种方法
常用方法:
使用二分法查找:
Arrays.binarySearch(int [] array,int value);
数组内容转成字符串的形式输出:
Arrays.toString(int [] array);
数组排序:
Arrays.sort(int [] array);
复制指定的数组:
Arrays.copyOf(int[] array,int length);
Arrays.copyOf(int[] array,int from,int to);
System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
判断两个数组是否相等
Arrays.equals();
使用指定元素填充数组:
Arrays.fill();
【代码】
package HeadFirst;
/*
Arrays工具类使用
*/
import java.util.Scanner;
import java.util.Arrays;
public class Test13 {
public static void main(String[] args) {
int []num={10,20,50,65,88,90};
//二分查找
int index=Arrays.binarySearch(num,88);
System.out.println("找到的下标是:"+index);
//输出数组,可使用前面的foreach方法
for(int n:num){
System.out.println(n);
}
//在测试输出数据时,可以使用,更加方便
System.out.println(Arrays.toString(num));
//排序
int[] num2={10,32,11,44,543,22,12};
Arrays.sort(num2);//快速排序
System.out.println(Arrays.toString(num2));
//数组的复制
int[] num3=Arrays.copyOf(num2,10);
System.out.println(Arrays.toString(num3));
//
int[] newNum=new int[num2.length];
System.arraycopy(num2,0,newNum,0,num2.length);//将数组num2从起始位置0开始复制给新数组newNum,起始位置为0,复制的长度为num2.length
System.out.println(Arrays.toString(newNum));
//小结,数组的复制:
/*
效率从高到低排序是:System.arraycopy -> Arrays.copyOf -> for
*/
//判断两个数组的值是否相等
System.out.println(Arrays.equals(num2,newNum));
//填充数组
Arrays.fill(newNum,0);
System.out.println(Arrays.toString(newNum));
}
}