经典排序算法

测试题库：

https://leetcode.cn/problems/sort-an-array/description/

冒泡排序

package 十大排序算法;

public class 冒泡排序 {
	public int[] sortArray(int[] nums) {
		//先pass掉空数组，或者只有一个元素的情况
		if(nums.length <2){
			return nums;
		}
		/**
		 * //先要清楚怎么插
		 * 冒泡是每一轮把最大的泡，放在最后面
		 */
		for (int i=0;i< nums.length;i++){
			for (int j=0;j< nums.length - 1 - i;j++){
				if (nums[j+1] < nums[j]){
					int temp = nums[j+1];
					nums[j+1] = nums[j];
					nums[j] = temp;
				}
			}
		}
		return nums;
	}
}

希尔排序

package 十大排序算法;

public class 希尔排序ShellSort__不够理解 {
	public int[] sortArray(int[] nums) {
		/**
		 * 希尔---增量距
		 * 选择增量gap=length/2，缩小增量继续以gap = gap/2的方式
		 *
		 * 重在【分组】
		 */
		int gap = nums.length / 2;
		while (gap > 0){
			for (int i=gap;i< nums.length;i++){     //从这里开始的话，前面还有一批
				int temp = nums[i];
				int preIndex = i - gap;
				while (preIndex >= 0 && nums[preIndex] > temp){
					nums[preIndex + gap]	= nums[preIndex];
					preIndex-=gap;
				}
				nums[preIndex + gap] = temp;
			}
			gap/=2;
		}
		return nums;
	}
}

归并排序

package 十大排序算法;

import java.util.Arrays;

public class 归并排序MergeSort {
	public static void main(String[] args) {
		int nums[] = {5,1,1,2,0,0};
		sortArray(nums);
	}
	public static int[] sortArray(int[] nums) {
		/**
		 * 归并 ---多路合并
		 * 两两一组，两批一组
		 *
		 * 分为两个步骤，，，一个负责去思考合并范围MergeSort
		 *              一个去负责合并过程Merge
		 */
		int len = nums.length;
		mergeSort(nums,0,len-1);
		//System.out.println(Arrays.toString(nums));
		return nums;
	}

	/**
	 * mergeSort负责归并，即划分区域，告知哪个区域需要合并排序
	 *
	 * @param array
	 * @param left
	 * @param right
	 */
	private static void mergeSort(int[] array, int left, int right) {
		if (left < right){
			int mid = left + (right-left)/2 ;
			mergeSort(array,left,mid);
			mergeSort(array,mid+1,right);
			merge(array,left,mid,right);    //merge负责合并，即将左右两个区域进行合并排序。
		}
	}

	/**
	 * merge负责合并，即将左右两个区域进行合并排序
	 *
	 * @param array
	 * @param left
	 * @param mid
	 * @param right
	 */
	private static void merge(int[] array, int left, int mid, int right) {
		/**
		 * 合并怎么合呢？
		 * 就跟两个链表放在一起类似，
		 * 先要确定各自的大小，然后生成一个各自的子数组
		 * 然后两个数组比大小，逐个插进去，
		 * 之后就剩余的插进去
		 */
		int new1Length = mid - left + 1;
		int new2Length = right - mid;
		int new1Array [] = new int[new1Length];
		int new2Array [] = new int[new2Length];
		for (int i=0;i<new1Length;i++){
			new1Array[i] = array[left+i];
		}
		for (int i=0;i<new2Length;i++){
			new2Array[i] = array[mid + 1 + i];
		}
		//开始对比插入，并且判断值
		int i1Length = 0,j2Length=0;
		int k = left;
		while (i1Length<new1Length && j2Length <new2Length){
			if (new1Array[i1Length] <= new2Array[j2Length]){
				array[k] = new1Array[i1Length];
				i1Length++;
				//k++;
			}else {
				array[k] = new2Array[j2Length];
				j2Length++;
				//k++;
			}
			k++;
		}
		//可能存在某一部分还有剩余，具体剩余哪个部分，不清楚
		while (i1Length<new1Length ){
			array[k] = new1Array[i1Length];
			i1Length++;
			k++;
		}
		while (j2Length <new2Length){
			array[k] = new2Array[j2Length];
			j2Length++;
			k++;
		}
	}
}

快速排序

package 十大排序算法;

public class 快速排序QuickSort {
	public int[] sortArray(int[] nums) {
		/**
		 * 每次选取pivot，以pivot为参考进行左右放，同时记录下pivot的位置
		 * 下次同样，选择pivot左边为一个排序区域，选择第一个和元素为新的pivot
		 * 进行上面重复的pivot快速排序
		 *
		 */
		quickSort(nums,0,nums.length-1);
		return nums;
	}


	/**
	 *
	 * @param nums
	 * @param left
	 * @param right
	 */
	private static void quickSort(int[] nums, int left, int right) {
		if(left < right){
			//找到分区点的索引
			int pivotIndex = partition(nums,left,right);
			//递归下一轮的“左“ ，”右”
			quickSort(nums,left,pivotIndex-1);
			quickSort(nums,pivotIndex+1,right);
		}
	}

	/**
	 *
	 * @param array
	 * @param left
	 * @param right
	 * @return
	 */
	private static int partition(int[] array, int left, int right) {
		int pivot = array[right];        //这里选择最左边为pivot枢纽。
		//初始化分区索引为最左边
		int index = left - 1;
		//遍历数组并根据元素与分区点的大小关系进行交换
		for (int j = left;j<right;j++){
			if (array[j] <= pivot){
				index++;
				int temp = array[index];
				array[index] = array[j];
				array[j] = temp;
			}
		}
		//最后，将分区点元素和arr[i+1]（当前分区点位置）交换。
		int temp = array[index + 1];
		array[index + 1] = array[right];
		array[right] = temp;
		return index+1;
	}
}

插入排序

package 十大排序算法;

public class 插入排序 {
	public int[] sortArray(int[] nums) {
		//先pass掉空数组，或者只有一个元素的情况
		if(nums.length <2){
			return nums;
		}
		/**
		 * 插入排序就是说，每一次都当做是一个有序数组去进行从后往前的插入
		 */
		for (int i=1;i< nums.length;i++){
			//从当前位置往前比
			//当前的i是需要进行插入排序的新元素
			int curValue = nums[i];
			int index = i - 1;//需要比较的位置
			while (index >=0 && nums[index] > curValue){
				//当前比较值nums[index]后移
				 nums[index+1] = nums[index];
				 index--;
			}   //此时，说明放在当前需要比较值的位置的下一个即可。
			nums[index + 1] = curValue;
		}
		return nums;
	}
}

简单选择排序

package 十大排序算法;

public class 简单选择排序 {
	public int[] sortArray(int[] nums) {
		//先pass掉空数组，或者只有一个元素的情况
		if(nums.length <2){
			return nums;
		}
		/**
		 * //先要清楚怎么插
		 * 选择排序是每一轮把最小的泡，选出来
		 */
		for (int i=0;i< nums.length;i++){
			int curMin = nums[i];
			int curMinIndex = i;
			for (int j=i+1;j< nums.length;j++){
				if (nums[j] < curMin){
					curMin = nums[j];
					curMinIndex = j;
				}
			}
			int temp = nums[i];
			nums[i] = curMin;
			nums[curMinIndex] = temp;
		}
		return nums;
	}
}