java语言实现冒泡排序和二分查找-CFANZ编程社区

冒泡排序：冒泡排序在一趟趟的两两对比中把逆序的元素进行交换,每次都是相邻的两个元素比较,交换也发生在这两个元素之间。所以,如果两个元素相等,是不会再交换的;如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法，每一趟至少确立一个值的最终位置，因为这种形式就像水下的气泡，大气泡总是会往上冒头，所以取名为冒泡排序。

冒泡排序算法的实现：

对给定的数组进行冒泡排序

public class MaoPaoSort {
    public static void main(String[] args) {
        int[] arr={11,23,40,13,42,34,60,1,41};
        System.out.println("===================这是排序前的数组======================");
        printarr(arr);
        System.out.println("===================这是冒泡排序后的数组===================");
        maopao(arr);
        printarr(arr);
    }
//写一个方法来实现冒泡排序
    public static int[] maopao(int[] arr){
        int temp=0;
//内循环控制排序的趟数，外循环控制相邻数两两交换的次数
        for (int i= 0;i<arr.length;i++){
            for (int j=0;j< arr.length-i-1;j++){
//这里因为冒泡排序每一次都会确定一个最大值
所以内循环j变量每进行一次循环要减去一个值

                if (arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        return arr;
    }
//再写一个输出数组的方法
    public static int[] printarr(int[] arr){
        for (int i =0;i<= arr.length-1;i++){
            if (i==0){
                System.out.print("["+arr[0]+",");
            }else if (i==arr.length-1){
                System.out.print(arr[arr.length-1]+"]");
            }else{
                System.out.print(arr[i]+",");
            }
        }
        System.out.println();
        return  arr;
    }

实现结果：

二分查找：

二分查找又叫做折半查找，百度百科关于二分查找的描述如下：二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。很明显，二分查找必须要在有序顺序结构下使用。

百度百科关于二分查找的使用：首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

那么知道了二分查找的原理和使用过程，我们的具体代码实现就很清晰了，二分查找在java中可以使用循环结构进行实现，也可以使用方法的递归调用进行实现。

首先是循环结构，因为我们不知道循环的次数，所以这里采用while循环实现：

import java.util.Scanner;
//二分查找求数组中的数据；
public class Text3Demo6 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11};
   //键盘录入创建对象
        Scanner sc= new Scanner(System.in);
        System.out.println("请输入你要查找的元素：");
        int num1= sc.nextInt();

   //设置数组头变量是数组第一个元素，尾变量是数组最后一个元素

        int low = 0;
        int high = arr.length - 1;
        if (num1<arr[0] |num1>arr[arr.length-1]){
            System.out.println("查找的数不在该数组内");
        }else{
            while (low <= high) {
    //设置一个中间变量 i是头尾的中间
    //注意看中间的变量和查找数比较后，头尾变量的变化情况
                int i = (low + high) / 2;
                if (num1 == arr[i]) {
                    System.out.println(i);
                    break;
                } else if (num1 < arr[i]) {
                    high = i - 1;
                } else {
                    low = i + 1;
                }
            }
        }
        if (low > high) {
            System.out.println("查找的元素不在该数组中");
        }
    }}

代码里可以很清晰的看到，当数组中间位置的元素大于我们要查找的元素的时候，我们就需要进一步查找中间位置左边的元素，所以我们把尾变量的位置赋值成中间位置减一。当中间位置的元素小于我们要查找的元素的时候，我们需要进一步查找中间位置右边的元素，所以我们需要把头变量的位置赋值成中间位置加一，循环下去，当我们查找到我们想要的元素，就会输出元素的位置i，并且通过break结束循环，当我们没找到元素，就会提示元素不在数组内。

当我们使用方法实现二分查找时，只需要把二分查找的一趟实现写成一个方法，然后通过方法的返回值递归调用，一直调用方法，直到找到元素或者不满足方法的条件。

import java.util.Scanner;

public class Text3Demo8 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数进行查找");
        int value= sc.nextInt();
        int[] nums={1,2,3,5,7,8,9,11};
        int flag = erFen(nums,0,7,value);
        System.out.println(flag);
    }
    public static int erFen(int[] nums, int low, int high, int value) {

        if (low > high) 
        return -1;
        // 找出中间下标
        int mid = low + ((high - low) / 2);
        if (nums[mid] == value) {
            return mid;
        } else if (nums[mid] > value) {
            return erFen(nums, low, mid - 1, value);
        } else {
            return erFen(nums, mid + 1, high, value);
        }

    }}

最后分别放上一个查找元素失败的结果和一个查找元素成功的结果