Java的排序算法

Java的排序算法

1. 冒泡排序算法

冒泡排序算法的运作如下:(从后往前)

比较相邻的元素. 如果第一个比第二个大, 就交换他们两个.

对每一对相邻元素作同样的工作, 从开始第一对到结尾的最后一对. 在这一点, 最后的元素应该会是最大的数.

针对所有的元素重复以上的步骤, 除了最后一个.

持续每次对越来越少的元素重复上面的步骤, 直到没有任何一对数字需要比较.

相同元素的前后顺序并没有改变, 所以冒泡排序是一种稳定排序算法.

代码:

package cesi.tomcat.util;
import java.util.Arrays;

/**
 * Created by gailun on 2018/11/4.
 */
public class Test4 {
    public static void main(String[] args) {
        int[] nums = {34,4,56,17,92,68};
        int length = nums.length-1; //比较轮数等于数列的长度-1
        //循环控制轮数
        for (int i = 0; i < length; i++) {
            for (int j = 0; j < length - 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];
                }
            }
        }

        System.out.println(Arrays.toString(nums));
    }
}

执行结果:

实现原理:

/**
 34,4,56,17,92,68  --> 排序数组

 排序原理:
 4 34 17 56 68 92  --> 第一轮比较  比较了5次
 4 17 34 56 68     --> 第二轮比较  比较了4次
 4 17 34 56        --> 第三轮比较  比较了3次
 4 17 34           --> 第四轮比较  比较了2次
 4 17              --> 第五轮比较  比较了1次

 */

2.选择排序算法

选择排序算法

每一趟从待排序的数据元素中选出最小(或最大)的一个元素, 顺序放在已排好序的数列的最后, 直到全部待排序的数据元素排完. 选择排序是不稳定的排序方法.

代码:

package cesi.tomcat.util;
import java.util.Arrays;

/**
 * Created by gailun on 2018/11/4.
 */
public class Test5 {
    public static void main(String[] args) {
        //待排序的数列
        int[] nums = {34,4,56,17,92,68};
        //用于记录每次比较的最小值下标
        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];
            }
        }

        System.out.println(Arrays.toString(nums));
    }
}

执行结果:

实现原理:

/**
 34,4,56,17,92,68   --> 排序数组

 排序原理:
 4 34 56 17 92 68   --> 第一轮比较  比较了5次
 4 17 34 56 92 68   --> 第二轮比较  比较了4次
 4 17 34 56 92 68   --> 第三轮比较  比较了3次
 4 17 34 56 92 68   --> 第四次比较  比较了2次
 4 17 34 56 68 92   --> 第五次比较  比较了1次
 */

3、二分查找算法

二分法查找(折半查找): 前提是在已经排好序的数组中, 通过将待查找的元素与中间索引值对应的元素比较, 若大于中间索引值对应的元素, 去右半部分查找, 否则, 去左半部分查找. 以此类推, 直到找到为止; 找不到返回一个负数.

代码:

package cesi.tomcat.util;

/**
 * Created by gailun on 2018/11/6.
 */
public class Test6 {
    public static void main(String[] args) {
        //必须保证数列是有序的
        int[] nums ={10,20,50,65,88,90};
        int i = binarySearch(nums, 88);
        System.out.println(i);
    }

    //二分查找算法
    public static int binarySearch(int[] nums,int key){
        int start = 0 ;  //开始下标
        int end = nums.length - 1 ;  //结束下标
        while (start<=end){
            int middle = (end+start)/2;  //>>>1
            if (nums[middle]>key){
                end = middle - 1;
            }else if (nums[middle]<key){
                start = middle + 1;
            }else{
                return middle;
            }
        }
        return -1;
    }
}

执行结果: