Java教程

Java数组的选择,冒泡,快...

Java基础 小海豚博客管理员 2020-02-22 12:05:05.0 392 0条

Java的数组排序有选择排序,冒泡排序,快速选择排序,直接插入排序,当然还有反转数组中的元素顺序等等多种算法

选择排序
基本思想:每次循环选择最小(最大)的一个元素,顺序排在已经排好元素的最后(前面),直到所有待排序的元素排完。

如:
待排序的数组 {5,6,3,5,7,4};

第一次: {5,6,3,5,4,7};

第二次: {5,4,3,5,6,7};
….
实现代码:

  1. int [] array={5,6,3,5,7,4};
  2. int index;
  3. for(int i=1;i<array.length;i++){
  4. index=0;//先认为是最大的
  5. for(int j=1;j<=array.length-i;j++)
  6. {
  7. if(array[j]>array[index])
  8. {
  9. index=j; //如果比目前的大,就取这个,找出最大的
  10. }
  11. }
  12. int temp=array[array.length-i];//保存要交换的位置
  13. array[array.length-i]=array[index];//交换最大的值
  14. array[index]=temp;
  15. }
  16. System.out.println(Arrays.toString(array));//输出

算法心得:如果有数组重复,选择这个算法。

冒泡排序

基本思想:对比相邻的元素,如果满足比较条件,大的向后,小的向前。跟选择排序的差别是,冒泡是每次比较,就交换位置,而选择排序是先找最大的再交换。

实现代码:

  1. int [] array={5,6,3,5,7,4};
  2. for(int i=1;i<array.length;i++){
  3. for(int j=0;j<array.length-i;j++)
  4. {
  5. if(array[j]>array[j+1]) //如果大于后面的就交换到后面再于后面的比
  6. {
  7. int temp=array[j+1];//保存要交换的位置
  8. array[j+1]=array[j];//交换最大的值
  9. array[j]=temp;
  10. }
  11. }
  12. }
  13. System.out.println(Arrays.toString(array));//输出

快速选择排序

基本思想:快速选择排序是对冒泡排序的升级,通过一趟的排序把数据分成2部分,其中一部分的所有数据小于另一部数据,然后再按这个方法对每个部分进行再分割,可以使用递归算法。

实现代码:

  1. int [] array={5,6,3,5,7,4};
  2. sort(array,0,array.length-1);
  3. private void sort(int array[],int low,int high){
  4. int lo=low; //记录最小索引
  5. int hi=high; //记录最大索引
  6. int mid; //记录分点元素
  7. if (high>low){
  8. mid=array[(low+high)/2]; //记录分点元素
  9. while (lo<=hi){
  10. while ((lo<high)&&(array[lo]<mid)){
  11. ++lo; //记录不大于分点元素的索引
  12. }
  13. while ((hi>low)&&(array[hi]>mid)){
  14. --hi; //记录大于分点元素的索引
  15. }
  16. if (lo<=hi){ //如果最小索引和最大索引没有重复
  17. int temp=array[lo]; //交换2个索引的元素
  18. array[lo]=array[hi];
  19. array[hi]=temp;
  20. ++lo; //增加最小索引
  21. --hi; //减小最大索引
  22. }
  23. }
  24. if (low<hi)
  25. sort(array,low,hi); //递归排序没有分解的元素
  26. if (lo<high)
  27. sort(array,lo,high); //递归排序没有分解的元素
  28. }

}
直接插入排序

基本思想:将n个有序的数存放在数组a中,要插入的数是x,首先确定x要插入的位置p,然后把p后面的元素向后移动一位,空出p,在插入这样插入后也是有序的。

实现代码:

  1. int [] array={5,6,3,5,7,4};
  2. int temp; //定义临时保存变量
  3. int j;
  4. for(int i=1;i<array.length;i++){
  5. temp=array[i]; //保存临时变量
  6. for (j=i-1;j>=0&&array[j]>temp;j--){
  7. array[j+1]=array[j]; //数组元素交换
  8. }
  9. array[j+1]=temp; //在排序位置插入数据
  10. }
  11. System.out.println(Arrays.toString(array));//输出

有反转数组中的元素顺序

基本思想:就是把最后一个元素与第一个元素交换,倒数第2个与第2个交换以此类推。

实现代码:

  1. int [] array={5,6,3,5,7,4};
  2. int len=array.length;
  3. for(int i=0;i<len/2;i++){
  4. int temp=array[i];
  5. array[i]=array[len-1-i];
  6. array[len-1-i]=temp;
  7. }
  8. System.out.println(Arrays.toString(array));//输出
暗锚,解决锚点偏移

文章评论

嘿,来试试登录吧!