4种排序（冒泡，选择，直接插入，快速排序）和二分法查找

最新推荐文章于 2024-07-09 23:56:48 发布

苏氨酸S

最新推荐文章于 2024-07-09 23:56:48 发布

阅读量100

点赞数 1

文章标签：排序算法算法 java

本文链接：https://blog.csdn.net/qq_45679124/article/details/125839408

版权

13.13_常见对象(数组高级冒泡排序原理)

A:	需求：
		数组元素： {24, 6, 80, 57, 13, 2, 0, 3, 8, -1, -2, 300, 80, 93}
		请对数组元素进行排序。
		
B:冒泡排序原理
		相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

```java
	public class Test {
    public static void main(String[] args) {
        int[] arr = {24, 6, 80, 57, 13, 2, 0, 3, 8, -1, -2, 300, 80, 93};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]){
                    int t=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

13.14_常见对象(数组高级选择排序原理)

A:	需求：
		数组元素：{24, 69, 80, 57, 13, 2, 0, 3, 8}
		请对数组元素进行排序。
		
B:选择排序原理
		每次拿一个元素，跟它后面的元素挨个比较，小的往前放，经过一轮比较，最小的元素就会出现在最前面，如此往复，经过几轮后，就会排序好。
	

```java
public class Test {
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13, 2, 0, 3, 8};
        for (int index = 0; index < arr.length - 1; index++) {
            for (int i = 1 + index; i < arr.length; i++) {
                if (arr[i] < arr[index]) {
                    int t = arr[i];
                    arr[i] = arr[index];
                    arr[index] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

13.15_常见对象(数组高级直接插入排序原理图解)

A:	需求：
		数组元素：{24, 6, 80, 57, 13, 2, 0, 3, 8, -1, -2, 300, 80, 93}
		请对数组元素进行排序。
		
B:直接插入排序原理
		从1索引处开始，把后面的元素插入到之前的一个有序序列中，使之仍保持有序。
	

```java
public class Test {
    public static void main(String[] args) {
        int[] arr = {24, 6, 80, 57, 13, 2, 0, 3, 8, -1, -2, 300, 80, 93};
        //定义外层循环控制轮数
        for (int i = 1; i < arr.length; i++) {
            //arr[i] 当前元素 ， arr[i-1] 它前面的一个元素
            //如果当前元素小于前一个元素，那就交换位置
            for (int j = i; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    int t = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

13.16_常见对象(数组高级快速排序原理)

A:	需求：
		数组元素：{24,6,80,57,13,2,0,3,0}
		请对数组元素进行排序。
		
B:快速排序原理
	分治法：比大小，再分区
	1.从数组中取出一个数，作为基准数。
	2.分区：将比这个数大或等于的数全放到他的右边，小于他的数全放到他的左边。
	3.再对左右区间重复第二步，直到各区间只有一个数。
```java
	public class MyTest{
    public static void main(String[] args) {
        int[] arr = {24,6,80,57,13,2,0,3,0};
        QuickSortUtils.quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
}


//挖坑填数
//将基准数挖出形成第一个坑
//由后向前找比它小的数，找到后挖出此数填到前一个坑中
//由前向后找比它大的数，找到后也挖出此数填到前一个坑中
//再重复执行2，3步
public class QuickSortUtils {
    public static void quickSort(int[] arr,int start,int end){
    //找出基准数，分成左右两区
        if (start<end){
        //找出基准数
            int index=getIndex(arr,start,end);
        //对左区进行递归
            quickSort(arr, start, index-1);
        //对右区进行递归
            quickSort(arr, index+1, end);
        }
    }

    private static int getIndex(int[] arr,int start, int end) {
        int i=start;
        int j=end;
        //将基准数挖出形成第一个坑
        int x=arr[i];
        while (i<j){  //重复执行2，3步
            //由后向前找比它小的数
            while(i<j&&arr[j]>=x){
                j--;//找出比基准数小的那个数的位置
            }
            if (i<j) {
                //找到后挖出此数填到前一个坑中
                arr[i]=arr[j];
                i++;//顺便让i递增一下
            }
            //由前向后找比它大的数
            while (i<j&&arr[i]<x){
                i++;
            }
            if (i<j){
                arr[j]=arr[i];
                j--;    //顺便让j递减一下
            }
        }
        arr[i]=x;   //把基准数填到最后一个坑位中
       // arr[j]=x;二者都行，因为i和j已经重合
        return j;
    }
}

13.17_二分查找

A:二分查找：前提数组元素必须有序   
B:二分查找的思想：每一次都查中间索引的那个元素，比较大小就能减少一半的元素。

 注意:二分查找不是找该元素第一次出现的索引。
 比如下面这个数组，找4元素的索引，找出来的索引是5
 int[] arr = {1,2,3,4,4,4,6,7,8,9,10};
 
 
基本查询：从头开始挨个往后找，该元素第一次出现的索引。 

```java
public class Test {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,4,4,6,7,8,9,10};
        Scanner sc=new Scanner(System.in);
        int x=sc.nextInt();
        System.out.println(getIndex(arr,x));

    }
    public static int getIndex(int[] arr,int x){
        int minindex=0;
        int maxindex=arr.length-1;
        int centerindex=(maxindex+minindex)/2;

      while (minindex<=maxindex){
                if (x==arr[centerindex]){
                    return centerindex;

                }else if (x>centerindex){
                    minindex=centerindex+1;
                }else if (x<centerindex){
                    maxindex=centerindex-1;
                }
                    centerindex=(maxindex+minindex)/2;
            }

        return -1;
    }
}