Java基础—选择排序,冒泡排序和折半查找

  选择排序是最符合人思考方式的排序方式，最容易理解，但是对于计算机来说是比较消耗内存的。冒泡排序较于选择排序，比较次数减少，从而提高了内存的利用率。折半查找的前提：数组必须是有序的，相比于一般的查找方式也提高了效率。通过老师视频的学习，写了以下的代码：
1、选择排序：

/*
  有一个数组：{9,56,78,23,50,40,30,102,122,0,45},用选择排序的方式对其进行排序（从大到小的排序）。
  分析：
       选择排序的原理：先拿数组的第一个元素跟后面的元素进行比较，若后面的元素比该元素大，
       则交换两个元素的位置。第一个元素比完，取第二个元素进行比较，依次类推，直至取倒数
       第二个元素进行比较，排序完成。
  思路：
       1、先拿数组的第一个元素跟其他的元素比较，发现比他大的，交换他们的位置；
       2、外循环的初始值为0，循环次数为：arr.length；
       3、内循环的初始值为外循环初始值+1，条件为arr.length；
       4、因为要交换两者的位置，所以应该定义一个中间变量；
  步骤：
       1、定义一个数组；
       2、定义一个比较的方法，将数组传入；
       3、输出排序结果。
*/
import java.util.*;
class SelectTest
{
    public static void main(String[] args) 
    {
        //定义数组
        int[] in = {9,56,78,23,50,40,30,102,122,0,45};
        //将排序前的数组打印
        System.out.println(Arrays.toString(in));
        //调用排序方法对数组进行排序
        selectArray(in);
        //将排序后的数组打印（也可以使用遍历数组的方式将其打印）
        System.out.println(Arrays.toString(in));
    }
    //定义一个选择排序的方法
    public static void selectArray(int[] in)
    {
        //定义一个中间变量，以便两元素交换位置
        int temp = 0;
        for(int i=0;i<in.length;i++)
        {
            for(int j=i+1;j<in.length;j++)
            {
                //若后一个元素比前一个元素大，则交换他们的位置
                if(in[i] < in[j])
                {
                    temp = in[i];
                    in[i] = in[j];
                    in[j] = temp;
                }
            }
        }
    }
}

2、冒泡排序：

/*
  有一个数组：{9,56,78,23,50,40,30,102,122,0,45},用选择冒泡排序的方式对其进行排序（从小到大的排序）。
  分析：
       冒泡排序的原理： 相邻元素进行排序，前面大于后面，则交换他们的位置。
   思路：
        采用嵌套的for循环来实现排序的过程。外循环：初始值为0，条件为：in.length-1；
                                           内循环：初始值为0，条件为：in.length-1-i;
    步骤：
         1、定义数组；
         2、定义冒泡排序的功能函数；
         3、打印排序结果。

    注：从直观上看，冒泡排序跟选择排序的区别在于：冒泡排序时，元素角标跟外循环无关。
        java的类Arrays中，定义了对数组进行排序的方法：static void sort(int[] in):对指定的int型数组进行升序排序
*/
import java.util.*;
class BubbleSortTest
{
    public static void main(String[] args) 
    {
        //定义数组
        int[] in = {9,56,78,23,50,40,30,102,122,0,45};
        //将未排序前的数组打印
        System.out.println(Arrays.toString(in));
        //调用函数对数组进行排序
        bubbleSort(in);
        //将排序后的数组打印
        System.out.println(Arrays.toString(in));
    }
    //定义对数组进行冒泡排序的函数
    public static void bubbleSort(int[] in)
    {
        //定义中间变量，以便两个元素进行交换
        int temp = 0;
        for(int i=0;i<in.length-1;i++)
        {
            for(int j=0;j<in.length-i-1;j++)
            {
                //相邻元素进行比较，较大的元素往后面放
                if(in[j] > in[j+1])
                {
                    temp = in[j];
                    in[j] = in[j+1];
                    in[j+1] = temp;
                }
            }
        }
    }
}

3、折半查找：
/*
用折半查找的方法，判断50是否在数组中：{9,56,78,23,50,40,30,102,122,0,45}
分析：
折半查找的原理：先中间的那个数，再决定往哪边查找。
思路：先确定比较的范围，然后与中间数比较，再确定范围，再比较。
步骤：
1、定义一个数组；
2、定义一个对数组进行排序的方法；
3、定义一个这般查找的方法；

注：折半查找的前提是：数组是已排序好的，如果数组是没排序的，则获取的角标是排序后的角标，
     所以获取的角标是错误的,所以只能判断该元素是否在数组中

总结：折半查找的过程：范围——与中间元素是否相等——min>max?——范围——与中间元素是否相等。
      折半查找中用到的变量都是用来标示角标，折半查找的循环条件是：
      key != in[mid]和min > max；若果要将该元素插入到该数组后，数组仍然有序，那么该
      元素插入的位置有两种情况：如果在该数组中找到该元素，则该元素的插入位置的角标就是mid的值，若
      在该数组中没有找到该元素，则该元素插入位置的角标值为min值。

*/
class BinarySearchTest
{
public static void main(String[] args)
{
//定义一个数组
int[] in = {9,56,78,23,50,40,30,102,122,0,45};
//对数组进行排序
bubbleSort(in);
//判断50是否在该数组中
boolean b = binarySearch(in,50);
System.out.println(b);
}
//定义一个函数对数组进行排序
public static void bubbleSort(int[] in)
{
//定义一个中间变量，以便两个元素交换位置
int temp = 0;
for(int i=0;i