浅析常用算法(代码演示)

常见算法浅析

针对Java工程师职位，介绍几种常见的算法

1、二分查找

解析：

要求待查的序列有序，每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，如果中间位置的值比待查关键字小，则在后半部分循环这个查找的过程。直到查到为止，否则序列中没该关键字！

代码演示：

package com.my.day02;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 14:45
 * 二分查找算法演示
 */
public class Demo01 {
   
    public static void main(String[] args) {
   
        int arr[]={
   1,3,4,5,6,7,9,10};
        int a=9;
        int search = search(arr, a);//查询出的数组下标+1
        System.out.println(search);//打印出该关键字所在位置
        System.out.println(arr[6]);//验证是否是下标+1
    }

    public static int search(int [] arr,int a){
   

        int left=0;//定义为0d的变量，便于后面判断
        int right=arr.rightgth-1;//数组一半的长度
        int mid;//用于更新每次数组的中间长度

        while (left<=right){
   //开始循环 条件rightgth>=0
            mid=(left+right)/2;//取中间长度
            if(arr[mid]==a){
   //取中间数 判断是否是关键字
                return mid+1;//
            }else if(arr[mid]<a){
   //若中间数小于关键字，则向后半部分查询
                left=mid+1;//长度更改为中间数+1
            }else if(arr[mid]>a){
   //若中间数大于关键字则向前半部分查询
                right=mid-1;//长度更改为中间数-1
            }
        }
        return -1;//未找到为-1
    }
}

2、冒泡排序算法

步骤：

• 比较前后相邻的两个数据，如果前面数据大于后面的，就将这两个数据互换
• 照此方法，对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就落在数组的第N-1位置
• N=N+1，如果N不为0，则重复上面两个步骤，否则排序完成

代码演示：

package com.my.day02;

import java.util.Arrays;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 15:24
 *
 * 冒泡排序算法
 */
public class Demo02 {


    public static void main(String[] args) {

        int arr[]={2,3,5,1,9,8,6,22,21,10};//定义无序数组
        int b=arr.length;//获取数组长度
        bubbleSort(arr,b);//执行冒泡排序方法
        System.out.println(Arrays.toString(arr));//打印出数组
    }
    public static void bubbleSort(int[]arr,int b){
        int m, n;
        for (m=0;m<b;m++){
            for(n=1;n<b-m;n++){
                if(arr[n-1]>arr[n]){
                    int temp;
                    temp=arr[n-1];
                    arr[n-1]=arr[n];
                    arr[n]=temp;
                }
            }
        }
    }
}

3、插入排序算法

解析：

对未排序数据，在已排序序列中从后向前扫描，找到相应位置插入。插入排序非常类似于整扑克牌。在开始摸牌时，左手是空的，牌面朝下放在桌上。接着， 一次从桌上摸起一张牌，并将它插入到左手一把牌中的正确位置上。 为了找到这张牌的正确位置，要将它与手中已有的牌从右到左地进行比较。无论什么时候，左手中的牌都是排好序的。如果输入数组已经是排好序的话，插入排序出现最佳情况，其运行时间是输入规模的一个线性函数。如果输入数组是逆序排列的，将出现最坏情况。平均情况与最坏情况一样，其时间代价是(n2)。

代码演示：

package com.my.day02;

import java.util.Arrays;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 15:42
 */
public class Demo03 {
   

    public static void main(String[] args) {
   
        int arr[] = {
   2, 4, 5, 1, 6, 8, 0, 9};//构建无序序列
        sort(arr);//执行插入排序
        System.out.println(Arrays.toString(arr));//打印
    }
        public static void sort(int arr[]){
   
            for (int i = 1; i < arr.length; i++) {
   
                //插入的数
                int insertVal = arr[i];
                //被插入的位置(准备和前一个数比较)
                int index = i - 1;
                //如果插入的数比被插入的数小
                while (index >= 0 && insertVal < arr[index]) {
   
                    //将把 arr[index] 向后移动
                    arr[index + 1] = arr[index];
                    // 让 index 向前移动
                    index--;
                }
                // 把插入的数放入合适位置
                arr[index + 1] = insertVal;
            }
        }
    }

4、快速排序算法

解析：

选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的），一般选择序列的第一个元素。开始循环后，从后往前比较，用基准值和最后一个值比较，如果比基准值小的交换位置，如果没有继续比较下一个，直到找到第一个比基准值小的值才交换。 找到这个值之后，又从前往后开始比较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的值才交换。直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值来说，这样左右两边就是有序的

代码演示：

package com.my.day02;

import java.util.Arrays;

/**
 * @author shi_meng_yong
 * @date 2020/6/25 16:06
 *
 * 快速排序算法
 */
public class Demo04 {
   
    public static void main(String[] args) {
   
    int arr[]={
   1,5,2,4,3,23,99,88,33,11,0,42,67,63,87,98,101,92,114};//定义无序序列
    int high=arr.length-1;//获取序列最大长度
    sort(arr,0,high);//执行快速排序方法
    System.out.println(Arrays.toString(arr));//打印排序后的序列
    }
    public static  void sort(int[] a,int low,int high){
   
        int start = low;
        int end = high;
        int key = a[low];
        while(end>start) {
   
            //从后往前比较
            while (end > start && a[end] >= key)
                // 如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
                end--;
            if (a[end] <= key) {
   
                int temp = a[end];
                a[end]