Java程序设计入门第八课：冒泡排序算法与快速排序算法

本文链接：https://blog.csdn.net/m0_73493055/article/details/134274812

一、冒泡排序

冒泡排序：重复地遍历要排序的数组，依次比较数组中两个相邻的元素，如果前一个元素比后一个元素大，就交换两个元素的位置，直到没有相邻元素需要交换。此时就说明该数组已经排序完成。

通俗来说就是两两比较，大数沉底，小数上浮。

示例代码如下：

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        //定义数组，初始化
        int[] arr={10,30,25,79,40,32,6,25};
        //调用冒泡排序函数BubberSort
        BubbleSort(arr);
        //输出数组元素
        System.out.println(Arrays.toString(arr));
    }
    //定义冒泡排序函数BubberSort
    public static void BubbleSort(int[] arr){
        //for循环执行length次
        for(int i=0;i<arr.length;i++){
            //两两比较，大数沉底，小数上浮，比较length-1-i次
            for(int j=0;j<arr.length-1-i;j++){
                //if判断元素大小
                if(arr[j]>arr[j+1]){
                    //数组元素更新
                    arr[j]=arr[j]+arr[j+1];
                    arr[j+1]=arr[j]-arr[j+1];
                    arr[j]=arr[j]-arr[j+1];
                }
            }
        }
    }
}

运行结果为：

二、快速排序

快速排序：采用分治思想，在一个无序数组中任意选取一个基值，通过基值将待无序数组分成两部分，前面部分元素均小于或等于基值，后面部分元素均大于或等于基值，然后采用递归方法分别对前后两部分重复上述操作，直到将无序数组变为有序数组。

示例代码如下：

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        //定义数组，初始化
        int[] arr={10,30,25,79,40,32,6,25};
        //调用快速排序函数QuickSort
        QuickSort(arr,0,arr.length-1);
        //输出数组元素
        System.out.println(Arrays.toString(arr));
    }
    //定义快速排序函数QuickSort
    public static void QuickSort(int[] arr,int left,int right) {
        //函数退出条件
        if(left>=right){
            return;
        }
        //定义变量left0基值位置
        int left0=left;
        //定义变量baseNumber基数值
        int baseNumber = arr[left0];
        //while循环比较
        while (left != right) {
            //右边元素比基值，加右游标，注意越界
            while(arr[right]>=baseNumber && left<right){
                right--;
            }
            //左边元素比基值，加左游标，注意越界
            while(arr[left]<=baseNumber && left<right){
                left++;
            }
            //循环内数组元素更新
            int tmp=arr[right];
            arr[right]=arr[left];
            arr[left]=tmp;
        }
        //循环外数组元素更新
        int tmp=arr[left0];
        arr[left0]=arr[left];
        arr[left]=tmp;
        //循环递归调用
        QuickSort(arr,left+1,arr.length-1);
        QuickSort(arr,left0,right-1);
    }
}

运行结果为：

三、二分查找

二分查找需要有起始的索引和终止的索引。二分查找的特点在于如果需要查找的值大于中间值,则在中间值的后面寻找，同时起始的索引发生变化。同样，如果需要查找的值小于中间值,则在中间值的前面寻找，同时终止的索引变化。

示例代码如下：

import java.util.Scanner;

public class MidSelect {
    public static void main(String[] args) {
        //定义数组，初始化
        int arr[]={6,10,25,25,30,32,40,79};
        //提示用户输入
        System.out.print("请您输入一个想要查找的数据:");
        //接收输入设备Scanner
        Scanner input = new Scanner(System.in);
        //try——catch避免程序报错
        try{
            //定义输入数据变量num
            int num=input.nextInt();
            //初始化数组的起始位置
            int start_index=-1;
            //初始化数组的终止位置
            int end_index=arr.length;
            //定义初始mid值,通过开始索引和终止索引得到中间值索引
            int mid=(start_index+end_index)/2;
            //while循环判断数据位置
            while(arr[mid]!=num){
                //比较输入数据与中间数据，输入数据大于中间数据，在后半部分寻找，小于中间数据，在前半部分寻找
                if(arr[mid]<num){
                    //循环比较，更新索引
                    start_index=mid+1;
                }else{
                    //循环比较，更新索引
                    end_index=mid-1;
                }
                //查询完毕
                if(start_index>=end_index){
                    break;
                }
                mid=(start_index+end_index)/2;
            }
            //判断数据是否存在
            if(arr[mid]==num) {
                System.out.println("元素在该数组中存在！位置位于"+mid);
            }else{
                System.out.println("元素在该数组中不存在！");
            }
        }
        //判断输入是否合法
        catch(Exception e){
            System.out.println("你输入的数字不合法!");
        }
    }
}