冒泡排序、简单选择排序、插入排序、希尔排序、堆排序代码

冒泡：设置i和i+1两个游标，从数组第一位开始两两比较，，每比较一轮就可以确定一个值，所有最多进行n-1轮。

public static void bubbleSort(int[] arr) {
    //控制轮数
    for(int i=0;i<arr.length;i++) {
	    //设置j游标指向第一个元素
	    for(int j=0;j<arr.length-1;j++) {
	        //如果第j个元素大于第j+1个元素，交换
	        if(arr[j]>arr[j+1]) {
	            int temp=arr[j];
		        arr[j]=arr[j+1];
		        arr[j+1]=temp;
	        }	
	    }
    }
    System.out.println(Arrays.toString(arr));
}

简单选择排序：在待排序的数组中找到最小值（最大值），然后和数组第一个数（最后一个数）交换

public static void selectSort(int[] arr) {
    for(int i=0;i<arr.length;i++) {
	    //先假设第一个是最小值
	    int minindex=i;
	    int min=arr[i];
	    //判断是否有比第一个小的，有就把它设为最小值
	    for(int j=i;j<arr.length;j++) {
	        if(min>arr[i]) {
	            min=arr[j];
		        minindex=j;
	        }
	    }
	    //把最小值和待排序的第一位交换
	    arr[minindex]=arr[i];
	    arr[i]=min;
    }
    System.out.println(Arrays.toString(arr));
}

插入排序：插入的数越小，后移的次数越多，影响效率

//插入排序
public static void insertSort(int[] arr) {
    //设置i游标，指向第二个元素，每轮往后移动1位
    for(int i=1;i<arr.length;i++) {
        //设置j游标，指向i游标前一个元素，依次往前移动1位
	    for(int j=i-1;j>=0;j--) {
	        //判断j游标和j游标后一个元素大小，并排序
	        if(arr[j]>arr[j+1]) {
	            int temp=arr[j+1];
		        arr[j+1]=arr[j];
		        arr[j]=temp;
	        }
	    }
    }
    System.out.println(Arrays.toString(arr));
}

希尔排序

//希尔排序
public static void shellSort(int[] arr) {
    //把数组按步长分开，进行插入排序，每一轮结束步长除以2
    for(int grap=arr.length/2;grap>0;grap/=2) {
        //设置i游标，指向步长所在的元素，并依次往后移动
	    for(int i=grap;i<arr.length;i++) {
	        //设置j游标，指向和i游标相隔一个步长的元素
	        for(int j=i-grap;j>=0;j-=grap) {
		        //判断j游标和i游标所指的元素大小
		        if(arr[j]>arr[j+grap]) {
		            int temp=arr[j+grap];
		            arr[j+grap]=arr[j];
		            arr[j]=temp;
		        }
	        }
        }
    }
    System.out.println(Arrays.toString(arr));
}

堆排序

import java.util.Arrays;

public class HeapSort {
    public static void main(String[] args) {
	    int[] arr=new int[] {1,4,2,523,74,12};
	    //数组上的p指针
	    for(int p=arr.length-1;p>=0;p--) {
	        Heap(arr,p,arr.length);
	    }
	    //维护
	    for(int i=arr.length-1;i>0;i--) {
	        //堆顶元素和堆底元素互换
	        int count=arr[i];
	        arr[i]=arr[0];
	        arr[0]=count;
	        Heap(arr,0,i);
	    }
	    System.out.println(Arrays.toString(arr));
    }
    // 将这个arr直接当中完全二叉树进行处理，形成大顶堆
    public static void Heap(int[] arr,int parent,int length) {
        //定义临时空间
        int temp=arr[parent];
        //左孩子
        int lChild=2*parent+1;
        while(lChild<length) {
            //定义右孩子
	        int rChild=lChild+1;
	        // 如果有右孩子，并且右孩子的值大于左孩子的值我们就将lChild指针指向rChild
	        if(rChild<length && arr[lChild]<arr[rChild]) {
	            lChild++;
	        }
	        // 让 temp和arr[Child]进行对比
	        if(temp>=arr[lChild]) {
	            break;
	        }
	        //将孩子节点的值，放入到父节点
	        arr[parent]=arr[lChild];
	        //父节点继续向下去走
	        parent=lChild;
	        lChild=2*lChild+1;
        }
        arr[parent]=temp;
    }
}