Java比较值以及数字排序

一、今日收获

1.比较值

1.1 最大值

两个数：if(a>b) max=a;

多个数：

• 遍历时，每个数值与最大值比较

 1 public class study {
 2 public static void main(String[] args) {
 3     int[] a= {2,3,4,5,9,7,8};
 4     int max=0;
 5     for(int i=0;i<a.length;i++) {
 6         if(a[i]>max) {
 7             max=a[i];
 8         }
 9     }
10     System.out.println("最大值是："+max);
11     }
12 }

 

• 遍历时，两两相邻比较找最大值

 1 public class study {
 2 public static void main(String[] args) {
 3     int[] a= {2,3,4,5,9,7,8};
 4     int max=0;
 5     for(int i=0;i<a.length-1;i++) {
 6         if(a[i]>a[i+1]&&a[i]>max) {
 7             max=a[i];
 8         }else if(a[i+1]>a[i]&&a[i+1]>max) {
 9             max=a[i+1];
10         }
11     }
12     System.out.println("最大值是："+max);
13     }
14 }

 

• 将数组分为两部分，将后部分逐一与前部分每个值比较

 1 public class study {
 2 public static void main(String[] args) {
 3     int[] a= {2,3,4,5,9,7,8};
 4     int max=0;
 5     for(int i=0;i<a.length;i++) {
 6         for(int j=i-1;j>=0;j--) {
 7             /**
 8              * 将数组分为两部分
 9              * 将后部分的第一个逐一与前部分每一个比较
10              * 如果当前元素大，并且也大于最大值变量，则将当前元素赋值给最大值变量
11              */
12             if(a[j+1]>a[j]&&a[j+1]>max) {
13                 max=a[j+1];
14                 }
15             }
16         }
17     System.out.println("最大值是："+max);
18     }
19 }

1.2 最小值

两个数：if(a<b) min=a;

多个数：

• 遍历时，每个数值与最小值比较

• 遍历时，两两相邻比较找最小值

• 将数组分为两部分，将后部分逐一与前部分每个值比较

1.3 平均值

一组数据的和除以数据的个数

 

 

 

---

 

 

2.数字排序

2.1 冒泡排序

原理：

• 逐一比较数组中相邻的两个元素，如果后面的数字小于前面的数字，就交换先后元素

• 经过一个轮次的比较，一定有一个最大的排在最后的位置

• 每次比较剩下的元素，经过n-1次比较，可以实现排序

代码：

 1 import java.util.Arrays;
 2 public class study {
 3 public static void main(String[] args) {
 4     int[] a= {2,3,4,5,9,7,8};
 5     for(int i=0;i<a.length-1;i++) {
 6         for(int j=0;j<a.length-i-1;j++) {
 7             if(a[j]>a[j+1]) {
 8                 int t=a[j];
 9                 a[j]=a[j+1];
10                 a[j+1]=t;
11             }
12         }
13     }
14     System.out.println("排序后的数组："+Arrays.toString(a));
15     }
16 }

2.2 选择排序

原理：

• 将数组中的每个元素与第一个元素比较，如果这个元素小于第一个元素，就将这两个元素交换位置

• 每轮使用第一步的规则可以选择出一个最小元素放到第一个位置

• 经过n–1轮比较完成排序

代码：

 1 import java.util.Arrays;
 2 public class study {
 3 public static void main(String[] args) {
 4     int[] a= {2,3,4,5,9,7,8};
 5     for(int i=0;i<a.length-1;i++) {
 6         for(int j=i+1;j<a.length;j++) {
 7             if(a[i]>a[j]) {
 8                 int t=a[i];
 9                 a[i]=a[j];
10                 a[j]=t;
11             }
12         }
13     }
14     System.out.println("排序后的数组："+Arrays.toString(a));
15     }
16 }

2.3 插入排序

原理：

• 将数组分为两部分，将后部分的每一个元素逐一与前部分每一个元素比较，如果当前元素小，就替换

• 找到合理位置插入

代码：

 1 import java.util.Arrays;
 2 public class study {
 3 public static void main(String[] args) {
 4     int[] a= {2,3,4,5,9,7,8};
 5     int i,j,k;
 6     for(i=1;i<a.length;i++) {
 7         k=a[i];
 8         for(j=i-1;j>=0&&k<a[j];j--) {
 9             a[j+1]=a[j];
10             }
11         a[j+1]=k;
12         }
13     System.out.println("排序后的数组："+Arrays.toString(a));
14     }
15 }

2.4 快速排序

原理：

• 首先选定基准值，一般设置low所对应的元素位置为基准值

• 在高位指针始终不小于低位指针的前提下，

      高位指针开始判断其是否比基准值大，如果符合高位指针减1，继续寻找，直到找到不符合的情况，然后把该值赋给此时低位所在位置。
      低位指针开始判断是否比基准值小，如果符合，低位指针加1，继续寻找，直到找到不符合情况， 然后把该值赋给此时高位指针所指位置。
      如此反复，直到低位高位指针重合，此时再将当前的基准值赋给低位指针所指的值，这样就完成了一次排序。此时，基准值就到了其最终位置上，然后继续对以基准值为界的两部分进行排序。

代码：

 1 import java.util.Arrays;
 2 public class QuickSortDemo{
 3 public static void main(String[] args) {
 4     int vec[]= {37,47,23,100,19,56,56,99,9};
 5     QuickSortDemo q=new QuickSortDemo();
 6     q.quicksort(vec,0,vec.length-1);
 7     System.out.println("排序后："+Arrays.toString(vec));
 8 }
 9 public void quicksort(int a[],int low,int high) {
10     if(low<high) {
11         int pivot,p_pos,i;
12         p_pos=low; //p_pos指向low,即位索引为0位置
13         pivot=a[p_pos]; //将0位置上的数值赋给pivot
14         for(i=low+1;i<=high;i++) {
15             if(a[i]>pivot) {
16                 p_pos++;
17                 int tmp=a[p_pos];
18                 a[p_pos]=a[i];
19                 a[i]=tmp;
20             }
21         }
22         int tmp=a[low];
23         a[low]=a[p_pos];
24         a[p_pos]=tmp;
25         quicksort(a,low,p_pos-1); //递归调用，排序左半区
26         quicksort(a,p_pos+1,high); //递归调用，排序右半区
27     }
28     }
29 }

---

 

 

3.查找

3.1 顺序查找

基本思想：让关键字与队列中的数从第一个开始逐个比较，直到找到与给定关键字相同的数为止。若全部比较也没有找到与关键字相同的数，即查找失败。

 1 public class study{
 2 public static void main(String[] args) {
 3     //定义一维数据
 4     int[] ary= {2,3,4,5,9,7,8};
 5     //定义要查找的数据
 6     int find=5;
 7     //定义标示符，即找到的位置
 8     int count=-1;
 9     for(int i=0;i<ary.length;i++) {
10         if(find==ary[i]) {
11             count=i;
12         }
13     }
14     if(count!=-1) {
15         System.out.println("下标在："+count+"的位置");
16     }else {
17         System.out.println("对不起，没有找到！");
18     }
19     }
20 }

 

3.2 二分查找

步骤：

• 查找前，元素须进行排序

• 确定区域中的中间位置：mid=(low+high)/2

• 行待查的k值与V[mid...n]key比较：若相等，则查找成功并返回此位置，否则需确定新的查找区域，继续二分查找

 1 public class study{
 2 public static void main(String[] args) {
 3     //定义一维数据
 4     int[] a= {2,3,4,5,9,7,8};
 5     //定义要查找的数据
 6     int find=5;
 7     //定义标示符，即找到的位置
 8     int count=-1;
 9     int low=0;
10     int high=a.length-1;
11     while(low<=high) {
12         int mid=(low+high)/2;
13         if(a[mid]==find) {
14             count=mid;
15             break;
16         }
17         else if(a[mid]>find) {
18             high=mid-1;
19         }
20         else {
21             low=mid+1;
22         }
23     }
24     if(count!=-1) {
25         System.out.println("下标在："+count+"的位置");
26     }else {
27         System.out.println("对不起，没有找到！");
28     }
29     }
30 }