笔试编程（二） | 7种常见的排序算法解析（附实现代码）
1. 快速排序（这里给出两种实现方法）
/**思路:
* 1. 在数据集中,选择一个元素作为"基准(pivot)"
* 2. 分区(partition)：所有小于"基准"的元素，都移到"基准"的左边；所有大于"基准"的元素都移到"基准"的右边
* 3. 分区操作结束后，基准元素所处的位置就是最终排序后它所处的位置
* 4. 对"基准"左边和右边的两个子集，不断重复第一步和第二步，直到所有子集都只剩下一个元素为止
*
* @param arr 待排序数组
* @param low 数组第一个元素索引
* @param high 数组最后一个元素的索引
* @return 排序后的数组
*/
public static int[] quickSort(int[] arr,int low,int high) {
//对low和high进行大小判断(此处如果仅对数组arr做非空及是否有元素判断会出现栈溢出)
if(low >= high) {
return arr;
}
//将arr一分为二
int middleIndex = partition(arr,low,high);
//对基准左边的进行递归排序
quickSort(arr,low,middleIndex-1);
//对基准右边的进行递归排序
quickSort(arr,middleIndex+1,high);
return arr;
}
/**获得"基准"(默认是最低位low)在数组排序后所在位置
* @param arr 待查找数组
* @param low 开始位置
* @param high 结束位置
* @return "基准"所在位置
*/
private static int partition(int[] arr, int low, int high) {
//每次都假设数组第一个位置的元素作为基准
int temp = arr[low];
while (low < high) {
while (arr[high] >= temp && high > low) {//后半部分向前扫描
//将临时基准元素与其右边的元素依次比较,值大于等于它的将high--
//当low<=high时,获取到等于或小于临时基准元素的元素
high--;
}
//将小于或等于基准元素的元素移到基准元素左边最低端
arr[low] = arr[high];
while (arr[low] <= temp && high > low) {//从前半部分扫描
low++;
}
//将大于或等于基准元素的元素移到基准元素右边最高端
arr[high] = arr[low];
}
//基准值
arr[low] = temp;
//返回最终基准
return low;
}
2. 选择排序（这里给出两种实现方法）
/** 思路:
* 1. 首先从未排序的序列中找到最小的元素, 放到排序序列的起始位置
* 2. 然后从剩余的未排序序列中继续查找最小元素, 放置到已排序序列的末尾
*
* 双层for循环: 遍历次数为数组长度-1, 外层for循环遍历索引从0到arr.length-2; 内层for循环遍历索引从1到arr.length-1
*/
public static int[] selectionSort(int[] arr) {
//判断数组是否为空及是否有元素
if(arr==null || arr.length==0) {
return arr;
}
//数组中有元素
//外层循环遍历数组目的是获取数组元素索引
for (int i = 0; i < arr.length - 1; i++) {
//将每个索引都假设为最小值的索引
int min = i;
for (int j = i + 1; j < arr.length; j++) {
//此时min=i, 将min位置的值跟其余的值比较
if(arr[j] < arr[min]) {
//索引j处的值比假设最小值小
min = j;
}
}
//元素位置交换获取升序排序(元素相同的0 0)
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
return arr;
}
/**方法2:
* 双层for循环: 遍历次数都是数组长度, 遍历索引都是从0到arr.length-1
*/
public static int[] selectSort(int[] arr) {
//判断数组是否为空及是否有元素
if(arr==null || arr.length==0) {
return arr;
}
int length = arr.length;
for (int i = 0; i < length; i++) {
int k = i;//待确定位置
//选择出应该在第i个位置的数
for (int j = length - 1; j > i; j--) {
if(arr[j] < arr[k]) {
k = j;
}
}
//交换两个数
int temp = arr[i];
arr[i] = arr[k];
arr[k] = temp;
}
return arr;
}
3. 冒泡排序
/**思路:
* 1. 依次比较相邻的元素, 如果第一个比第二个大, 就交换他们两个的位置
* 2. 对每一对相邻元素作同样的操作, 从开始第一对到结尾的最后一对. 在这一点, 最后的元素应该会是最大的数
* 3. 针对所有的元素重复以上的步骤, 除了最后n个【n代表比较相邻元素的循环次数, 如第一次循环比较结束出去最后一个元素n=1】
* 4. 持续每次对越来越少的元素重复上面的步骤, 直到没有任何一对数字需要比较
*/
public static int[] bubbleSort(int[] arr) {
//对数组进行非空及是否有元素判断
if(arr==null || arr.length==0) {
return arr;
}
//每次循环都去掉最后面的i-1个元素，i代表循环次数
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - i - 1; j++) {
//如果相邻的两个元素,前一个比后一个大则进行交换位置
if(arr[j]>arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return arr;
}
4. 插入排序
/**思路:
* 1. 认为第一个元素是排好序的, 从第二个开始遍历
* 2. 拿当前的元素, 从排好序的序列从中后往前找
* 3. 如果序列中的元素比当前元素大, 就把它后移, 直到找到一个小的
* 4. 将当前元素放在这个小的后面
*/
public static int[] insertionSort(int[] arr) {
//对数组进行非空及是否有元素判断
if(arr==null || arr.length==0) {
return arr;
}
for (int i = 0; i < arr.length; i++) {
for (int j = i; j > 0; j--) {
//相邻两个元素比较,如果前一个大于后一个则交换二者的位置
if(arr[j] < arr[j-1]) {
int temp = arr[j];
arr[j] = arr[j-1];
arr[j-1] = temp;
}
}
}
return arr;
}
5. 希尔排序
/**思路:
* 1. 先取一个正整数d1(d1 < n), 把全部记录分成d1个组, 所有元素之间距离为d1的倍数的记录看成一组, 然后在各组内进行插入排序
* 2. 然后取d2(d2 < d1)
* 3. 重复上述分组和排序操作, 直到取di = 1(i >= 1)位置, 即所有记录成为一个组, 最后对这个组进行插入排序.
*
* 一般选d1约为n/2, d2为d1/2, d3为d2/2 ... di = 1, n为数组元素个数
*
* 根据需求, 如果你想要结果从大到小排列, 它会首先将数组进行分组, 然后将较大值移到前面, 较小值移到后面, 最后将整个数组进行插入排序, 这样比起一开始就用插入排序减少了数据交换和移动的次数, 可以说希尔排序是加强版的插入排序
* 拿数组5, 2, 8, 9, 1, 3，4来说, 数组长度为7, 当increment为3时, 数组分为两个序列5、2、8和9、1、3、4, 第一次排序, 9和5比较, 1和2比较, 3和8比较, 4和比其下标值小increment的数组值相比较
*
* 此例子是按照从大到小排列, 所以大的会排在前面, 第一次排序后数组为9、2、8、5、1、3、4
* 第一次后increment的值变为3/2=1, 此时对数组进行插入排序, 实现数组从大到小排
*/
public static int[] shellSort(int[] arr) {
//对数组进行非空及是否有元素判断
if(arr==null || arr.length==0) {
return arr;
}
for (int gap = arr.length/2; gap > 0 ; gap/=2) {
for (int i = gap; i < arr.length; i++) {
int j = i;
while (j-gap>=0 && arr[j]<arr[j-gap]) {
int temp = arr[j];
arr[j] = arr[j-gap];
arr[j-gap] = temp;
j -= gap;
}
}
}
return arr;
}
6. 大顶堆排序
/**思路:
* 1. 将待排序的序列构建成一个大顶堆
* 2. 堆排序就是把最大堆堆顶的最大数取出, 将剩余的堆继续调整为最大堆, 再次将堆顶的最大数取出, 这个过程持续到剩余数只有一个时结束
*
* 最大堆调整: 将堆的末端子节点作调整, 使得子节点永远小于父节点
* 创建最大堆: 将堆所有数据重新排序, 使其成为最大堆
* 堆排序: 移除位于第一个数据的根节点, 并做最大堆调整的递归运算
*/
public static int[] heapSort(int[] arr) {
for (int i = arr.length / 2; i >= 0; i--) {
heapAdjust(arr, i, arr.length);
}
//逐步将每个最大值的根节点与末尾元素交换, 并且再调整二叉树, 使其成为大顶堆
for (int i = arr.length - 1; i > 0; i--) {
//进行元素位置交换
swap(arr, 0, i);
//交换之后, 需要重新检查堆是否符合大顶堆, 不符合则要调整
heapAdjust(arr, 0, i);
}
return arr;
}
/** 构建大顶堆 */
private static void heapAdjust(int[] arr, int i, int n) {
int childLeaf;
int fatherLeaf;
for (fatherLeaf = arr[i]; leftLeafChild(i) < n; i = childLeaf) {
childLeaf = leftLeafChild(i);
//如果左子树小于右子树, 则需要比较右子树和父节点
if (childLeaf != n - 1 && arr[childLeaf] < arr[childLeaf + 1]) {
//序号增1, 指向右子树
childLeaf++;
}
//父节点小于孩子结点时, 进行交换
if (fatherLeaf < arr[childLeaf]) {
arr[i] = arr[childLeaf];
} else {
//大顶堆结构未被破坏, 不需要调整
break;
}
}
arr[i] = fatherLeaf;
}
// 获取到左子结点
private static int leftLeafChild(int i) {
return 2 * i + 1;
}
private static void swap(int[] arr, int index1, int index2) {
int tmp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = tmp;
}
7. 归并排序
/**
* 递归将一个较大的数组不断切分为较小的两个子数组, 直到无法再切分之后再做合并, 并在合并的过程中调整顺序
* 归并算法的难点是如何尽可能的减少额外存储空间的使用
*/
public static int[] mergeSort(int[] arr) {
if (arr == null || arr.length == 0) {
return arr;
}
//finalArr 作为辅助数组
int[] finalArr = new int[arr.length];
inMergeSort(arr, finalArr, 0, arr.length - 1);
return finalArr;
}
private static void inMergeSort(int[] arr1, int[] arr2, int low, int high) {
if (high <= low) {
return;
}
int middle = (low + high) / 2;
//对左右子数组进行划分处理
inMergeSort(arr1, arr2, low, middle);
inMergeSort(arr1, arr2, middle + 1, high);
//最终合并两个有序的子数组
finalMergeSort(arr1, arr2, low, middle, high);
}
private static void finalMergeSort(int[] arr1, int[] arr2, int low, int middle, int high) {
int i = low;
int j = middle + 1;
int k = 0;
while (i <= middle && j <= high) {
if (arr1[i] <= arr1[j]) {
arr2[k++] = arr1[i++];
} else {
arr2[k++] = arr1[j++];
}
}
while (i <= middle) {
arr2[k++] = arr1[i++];
}
while (j <= high) {
arr2[k++] = arr1[j++];
}
for (i = 0; i < k; ++i) {
arr1[low + i] = arr2[i];
}
}
关注微信公众号：大数据学习与分享，获取更对技术干货
