排序算法

快速排序

import java.util.Arrays;
//快速排序
public class FastSort {
	public static void main(String[] args) {
		int[] arr = {1,3,0,23,54,643,12,452,231,34,34,3,54};
		System.out.println(Arrays.toString(arr));
		sort(arr,0,arr.length-1);
		System.out.println(Arrays.toString(arr));
	}
	public static void sort(int[] arr,int low,int high) {
		//初始判断,也是递归的退出条件
		if(low>=high) {
			return;
		}
		//传入数值
		int i = low;
		int j = high;
		//选择一个基准
		int key = arr[i];
		while(i<j) {
			//由右开始滑
			while(arr[j]>=key&&i<j) {
				j--;
			}
			//小于key值,使其交换数值;
			if(i<j) {
				int t;
				t = arr[j];
				arr[j]=arr[i];
				arr[i] = t;
			}
			
			//由左开始滑
			while(arr[i]<=key&&i<j) {
				i++;
			}
			//如果大于key值,交换数值
			if(i<j) {
				int t;
				t = arr[i];
				arr[i] = arr[j];
				arr[j] = t;
				
			}
		}
		//左侧代码,递归
		sort(arr,low,i-1);
		//右侧代码,递归
		sort(arr,i+1,high);
	}
}

插入排序

import java.util.Arrays;
//插入排序
public class InsertSort {
	public static void main(String[] args) {
		int[] arr = {1,3,0,23,54,643,12,452,231,34,34,3,54};
		System.out.println(Arrays.toString(arr));
		sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	public static void sort(int[] arr) {
		//这里是将arr[0]看做是一个基准数组,往该数组中插入数据,所以一下循环是从1开始的
		for(int i= 1;i<=arr.length-1;i++) {
			//要插入的数据
			int insertValue = arr[i];
			//要插入数据的前一个数的下标
			int index = i-1;
			//不确定插入数据的比较次数,使用while循环
			while(index>=0&&insertValue<arr[index]) {//这里使用了短路算法,防止了数组角标越界
				//因为要插入的值小于arr[index],所以将arr[index]向右移动一位
				arr[index+1] = arr[index];
				index--;
			}
			//循环执行完毕.已经找到了要插入数据的正确位置
			//这里index+1是因为23行对index进行了减减操作,进行了一次循环条件判断,但是没有进入循环
			arr[index+1] = insertValue;
		}
	}
}

堆排序

import java.util.Arrays;
//堆排序
public class HeapSort {
	public static void main(String[] args) {
		int[] arr = {1,3,0,23,54,643,12,452,231,34,34,3,54};
		System.out.println(Arrays.toString(arr));
		sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	//堆排序的各种函数的调用
	public static void sort(int[] arr) {
		//获取数组的长度
		int n = arr.length;
		//构造一个堆
		for(int k = n/2;k>=1;k--) {
			sink(arr,k,n);
		}
		while(n>1) {
			//将最小的数
			exch(arr,1,n--);
			sink(arr,1,n);
		}
	}
	//下沉函数
	private static void sink(int[] arr,int k,int n) {//arr:对arr数组进行sink操作,第K个元素
		//判断2*k是否是数组中的元素
		while(2*k<=n) {
			//获取k元素的左子节点
			int j = 2*k;
			//比较左右子节点的大小,以他们当中更小的作为下沉的对象
			if(j<n&&less(arr,j,j+1)) {
				//若arr[j]>arr[j+1],使j+1作为下沉对象,所以使j++
				j++;
			}
			//循环退出条件,当k大于下一层的子节点的数字时跳出循环
			if(!less(arr,k,j)) {
				break;
			}
			//k与j的值进行交换
			exch(arr,k,j);
			k=j;
		}
	}
	//数组元素交换
	private static void exch(int[] arr,int i,int j) {
		int x  = arr[i-1];
		arr[i-1] = arr[j-1];
		arr[j-1] = x;
	}
	//比较大小
	private static boolean less(int[] arr,int i,int j) {
		boolean b = arr[i-1]<arr[j-1];
		return b;
	}
}