数组，查找算法，二分查找法，冒泡排序，选择排序，插入排序

一、常用数组查找算法

工作原理：它又称为顺序查找，在一列给定的值中进行搜索，从一端的开始逐一检查每个元素，知道找到所需元素的过程。

例1：查找指定的数在数组中出现的位置，找到返回下标，找不到返回-1

import java.util.Scanner;
public class LinearSearch{
    public static void main(String []argas)
    {
        int [] array={10,100,90,65,80,92};
        System.out.println("请输入要获取的数");
        Scanner input=new Scanner(System.in);
        int number=input.nextInt();
        int index=-1;//找到数组中所在数的下标，找不到等于-1
        for(int i=0;i<array.length;i++)
        {
            if(array[i]==number)
            {
                index=i+1;
                break;
            }
        }
        if(index!=-1)
        {
            System.out.println("找到该数字，在数组中的第"+index+"位置");
        }
        else
        {
            System.out.println("要查找的数字不存在");
        }
    }
}

例2：求数组中的最大值，最小值

public class LinearSearch{
    public static void main(String []argas)
    {
        int [] array={10,100,90,65,80,92};
        //求数组中的最大值，最小值
        int max=array[0];//最大值
        int min=array[0];//最小值
        for(int i=1;i<array.length;i++)
        {
            if(max<array[i])
            {
                max=array[i];
            }
            if(min>array[i])
            {
                min=array[i];
            }
        }
        System.out.println("该数组的最大值为"+max+",最小值为"+min);
    }
}

二、二分查找法

工作原理：它又称为折半查找法，将数组中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将数组分成前、后两个子数组，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子数组，否则进一步查找后一子数组。重复以上过程，直到找到或找不到为止。

注：针对有序数组

import java.util.Scanner;
public class LinearSearch{
    public static void main(String []argas)
    {
        int[] array2={1,2,3,4,5,10,15,18,19,22};
        System.out.println("请输入要获取的数");
        Scanner input=new Scanner(System.in);
        int number=input.nextInt();
        int index=-1;//找到数组中所在数的下标，找不到等于-1
        int start=0;//起始下标
        int end=array2.length-1;//终止下标
        int middle;
        while(start<=end)
        {
            //找到中间下标所对应的元素值
            middle=(start+end)/2;
            int number2=array2[middle];
            //假如要查找的那个数大于中间比较的那个数
            //去掉左边的数
            if(number>number2)
            {
                start=middle+1;
            }
            //保留左边的数，去掉右边的数
            else if(number<number2)
            {
                end=middle-1;
            }
            else
            {
                index=middle+1;
                break;
            }
        }
        if(index!=-1)
        {
            System.out.println("找到该数字，在数组中的第"+index+"位置");
        }
        else
        {
            System.out.println("要查找的数字不存在");
        }
        
    }
}

三、冒泡排序法

工作原理：比较相邻的元素，如果第一个比第二个大，就交换它们两个。对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。最后的元素应该会是最大的数。针对除了最后一个元素以外所有的元素重复以上的步骤。直到没有任何一对数字需要比较。

public class BubbleSort{
    public static void main(String []argas)
    {
        int[] array={80,53,12,90,35,22,65,45,82,33};
        //N个数比较的轮数为N-1次
        for(int i=0;i<array.length-1;i++)
        {
            //每一轮比较的次数为N-1-i次
            for(int j=0;j<array.length-i-1;j++)
            {
                //比较相邻的2个数，小靠前
                if(array[j]>array[j+1])
                {
                    //两个数做交换，通过设置临时变量
                    int temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        //把排好序的数组输出
        for(int i=0;i<array.length;i++)
        {
            System.out.print(array[i]+",");
        }
    }
}

四、选择排序法

工作原理：首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。以此类推，直到所有元素均排序完毕。

public class SelectSort{
    public static void main(String []argas)
    {
        int[] array={80,53,12,90,35,22,65,45,82,33};
        int min=0;//保存最小元素值的下标
        //N个数比较的轮数为N-1次
        for(int i=0;i<array.length-1;i++)
        {
            min=i;
            //查找最小数在数组中的下标
            for(int j=i+1;j<array.length;j++)
            {
                if(array[min]>array[j])
                {
                    min=j;//保存最小数的下标
                }
            }
            //如果第i个数位置不在i上，则进行交换
            if(i!=min)
            {
                int temp=array[i];
                array[i]=array[min];
                array[min]=temp;
            }
        }
        
        for(int i=0;i<array.length;i++)
        {
            System.out.print(array[i]+",");
        }
    }
}

五、插入排序法

工作原理：它是通过构建有序序列，对于为排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

public class InsertSort{
    public static void main(String []argas)
    {
        int[] array={80,53,12,90,35,22,65,45,82,33};
        for(int i=1;i<array.length;i++)
        {
            int temp=array[i];
            //把下标保存起来
            int j=i;
            while(j>0&&temp<array[j-1])
            {
                //上面的数覆盖其下面的数
                array[j]=array[j-1];
                j--;
            }
            array[j]=temp;//插入数据
        }
        
        for(int i=0;i<array.length;i++)
        {
            System.out.print(array[i]+",");
        }
    }
}