排序(java版)

https://blog.csdn.net/yushiyi6453/article/details/76407640

# 冒泡排序
# 每次循环,相邻两数字进行比较,满足条件则进行交换

import java.util.Arrays;

public class BubbleSort {

    public static void main(String[] args) {
        int[] arr=new int[] {5,7,2,9,4,1,0,5,7};
        System.out.println(Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    

    public static void bubbleSort(int[]  arr) {
        //控制共比较多少轮
        for(int i=0;iarr[j+1]) {
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        
    }

}

# 选择排序
# 每次循环在 n(n=1，2，…n-1)个数字中选取最小的数字的下标, 之后进行交换

import java.util.Arrays;

public class SelectSort {

    public static void main(String[] args) {
        int[] arr = new int[] {3,4,5,7,1,2,0,3,6,8};
        selectSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    
    //选择排序
    public static void selectSort(int[] arr) {
        //遍历所有的数
        for(int i=0;iarr[j]) {
                    //记录下最小的那个数的下标
                    minIndex=j;
                }
            }
            //如果最小的数和当前遍历数的下标不一致,说明下标为minIndex的数比当前遍历的数更小。
            if(i!=minIndex) {
                int temp=arr[i];
                arr[i]=arr[minIndex];
                arr[minIndex]=temp;
            }
        }
    }

}

# 快速排序


import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = new int[]{2,6,4,1,0,3,8,9,7};
        quickSort(arr,0,arr.length-1);
        System.out.println( Arrays.toString(arr) );
    }

    public static void quickSort(int[] arr,int start,int end) {
        if(start

# 堆排序

import java.util.Arrays;

public class HeapSort {
    
    public static void main(String[] args) {
        int[] arr = new int[] {9,6,8,7,0,1,10,4,2};
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    
    public static void heapSort(int[] arr) {
        //开始位置是最后一个非叶子节点，即最后一个节点的父节点
        int start = (arr.length-1)/2;
        //调整为大顶堆
        for(int i=start;i>=0;i--) {
            maxHeap(arr, arr.length, i);
        }
        //先把数组中的第0个和堆中的最后一个数交换位置，再把前面的处理为大顶堆
        for(int i=arr.length-1;i>0;i--) {
            int temp = arr[0];
            arr[0]=arr[i];
            arr[i]=temp;
            maxHeap(arr, i, 0);
        }
    }
    
    public static void maxHeap(int[] arr,int size,int index) {
        //左子节点
        int leftNode = 2*index+1;
        //右子节点
        int rightNode = 2*index+2;
        int max = index;
        //和两个子节点分别对比，找出最大的节点
        if(leftNodearr[max]) {
            max=leftNode;
        }
        if(rightNodearr[max]) {
            max=rightNode;
        }
        //交换位置
        if(max!=index) {
            int temp=arr[index];
            arr[index]=arr[max];
            arr[max]=temp;
            //交换位置以后，可能会破坏之前排好的堆，所以，之前的排好的堆需要重新调整
            maxHeap(arr, size, max);
        }
    }

}

# 插入排序 

import java.util.Arrays;

public class InsertSort {
    
    public static void main(String[] args) {
        int[] arr = new int[] {5,3,2,8,5,9,1,0};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    
    //插入排序
    public static void insertSort(int[] arr) {
        //遍历所有的数字
        for(int i=1;i=0&&temp

# 归并排序

import java.util.Arrays;

public class MergeSort {

    public static void main(String[] args) {
        int[] arr = new int[] {1,3,5,2,4,6,8,10};
        System.out.println(Arrays.toString(arr));
        mergeSort(arr, 0, arr.length-1);
        System.out.println(Arrays.toString(arr));
    }
    
    //归并排序
    public static void mergeSort(int[] arr,int low,int high) {
        int middle=(high+low)/2;
        if(low