常见排序算法 java实现
插入排序
/**
* 插入排序
* 感觉下面的写法和冒泡排序类似
* 时间复杂度：
* 最坏：O(n2)
* 最好：O(n)
* 平均：O(n2)
*/
package others;
public class insertSort {
//所谓插入排序，其实就是类似于我们玩纸牌的时候的排序方法，每抽一张牌，都在前面已经排好序的牌中找一个合适的位置插入
public static int[] sort(int[] array){
//先判断数组是否符合规定，也就是长度
if (array.length == 0 || array.length < 2){
return array;
}else {
//采用两次for循环
//i指向当前元素的位置，由于0前面没有任何元素，因此我们从下标为1的地方开始
for (int i = 1; i < array.length; i++){
//此处for循环用来查找元素i要插入的位置
//用temp来临时保存当前的元素值
int temp = array[i];
int j =i-1;
//此处j>=0应当放在array[j]>temp的前面
//&&具有截断性，所以就不会导致j=-1时的array会报的错误了
while(j>=0&&array[j]>temp){
array[j+1]=array[j];
j--;
}
array[j+1]=temp;
}
}
return array;
}
public static void main(String[] args){
int array[] = {10,11,4,2,23,46,33,1};
array = insertSort.sort(array);
for (int num : array){
System.out.println(num);
}
}
}
归并排序
/***
*
* 归并排序
* 已完成
**/
package others;
public class mergeSort {
//给定一个数组和对应区域的起始和终止位置
public static void merge(int[] array,int start,int end){
//首先先判断起始地址是否小于终止地址，是的话执行，否则跳过，用来处理
if (start < end){
//获取要处理区间的中心mid
int mid = (start + end) / 2 ;
//递归调用merge处理index左边
merge(array,start,mid) ;
//递归调用merge处理index右边
merge(array,mid + 1,end) ;
//最后调用sort方法对此区间进行排序
sort(array,start,mid,end) ;
}
}
//其实这里才是归并排序的重点，
public static void sort(int[] nums, int low, int mid, int high) {
//创建一个和给定区间想用长度的新的int空间
int[] temp = new int[high - low + 1];
int i = low;// 左指针
int j = mid + 1;// 右指针
int k = 0;
// 把较小的数先移到新数组中
//此处是将两个有序的数组合并到一个新的数组中
//将两个数组i和j位置处的元素进行比较，将较小的数放入到新数组中，对应的i或者j+1，直到有一方数组遍历完
while (i <= mid && j <= high) {
if (nums[i] < nums[j]) {
temp[k++] = nums[i++];
} else {
temp[k++] = nums[j++];
}
}
//由于我们不知道哪个数组是遍历完的那一个，所以我们对两个数组执行同样的操作
//也就是把各自数组剩余的所有元素一次性放到新数组的后方
//由于有一方数组是已经全部遍历的，因此下面两个while循环只有一个会执行
// 把左边剩余的数移入数组
while (i <= mid) {
temp[k++] = nums[i++];
}
// 把右边边剩余的数移入数组
while (j <= high) {
temp[k++] = nums[j++];
}
// 最后把新数组中的数覆盖nums数组
for (int k2 = 0; k2 < temp.length; k2++) {
nums[k2 + low] = temp[k2];
}
}
public static void main(String[] args){
int array[] = {10,11,4,2,23,46,33,1};
int end = array.length - 1;
mergeSort.merge(array,0,end);
for (int num : array){
System.out.println(num);
}
}
}
快速排序
package others;
//快排
public class quickSort {
//快排
/**
* 快排的思想是，选择一个元素，通常是对应区间的第一个元素，
* 将所有比他小的元素放到他的左边
* 将所有比他大的元素放到他的右边去
* */
public static int[] sort(int[] array,int start,int end){
//首先先判断数组是否符合规定
if(array.length < 2 || array.length == 0 || start >= end){
return array;
}
int min = start;
int max = end;
if (min == max){
return array;
}
//保存临时值，这里的tempNum其实就是我们用来区分大数和小数的分界值，通常取第一个
int tempNum = array[min];
//当没有结束时
while (min != max){
//先找到区间右侧第一个比tempNum小的元素的位置
while (min < max && array[max] > tempNum){
max--;
}if (min选择排序
//选择排序
package others;
// 每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕。
public class selectSort {
public static int[] srot(int[] array){
int p = 0;
int temp = 0;
if (array.length < 2 || array.length == 0){
return array;
}
for (int i = 0;i < array.length; i++){
temp = i;
for(int j = i; j < array.length; j++ ){
if (array[j] < array[temp]){
temp = j;
}
}
if (temp != i){
p = array[i];
array[i] = array[temp];
array[temp] = p;
}
}
return array;
}
public static void main(String[] args){
int array[] = {10,11,4,2,23,46,33,1};
array = selectSort.srot(array);
for (int num : array){
System.out.println(num);
}
}
}
希尔排序
/**
* 希尔排序的时间复杂度是不确定的
* 依赖于增量序列
* 时间复杂度在O（n1.3~n2）
*/
package others;
/**
* 先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。
* 所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插入排序；
* 然后，取第二个增量d2 array[j + temp]) {
t = array[j];
array[j] = array[j + temp];
array[j + temp] = t;
}
}
}
}
}
if (temp == 1)
break;
}
return array;
}
public static void main(String[] args){
int array[] = {10,11,4,2,23,46,33,1};
array = shellSort.sort(array);
for (int num : array){
System.out.println(num);
}
}
}
堆排序
import java.util.Arrays;
public class HeapSort {
//堆排序
public static void heapSort(int[] array) {
array = buildMaxHeap(array); //初始建堆，array[0]为第一趟值最大的元素
for (int i = array.length - 1; i >= 1; i--) {
int temp = array[0]; //将堆顶元素和堆底元素交换，即得到当前最大元素正确的排序位置
array[0] = array[i];
array[i] = temp;
adjustHeap(array, 0, i); //整理，将剩余的元素整理成大顶堆
}
}
//自下而上构建大顶堆：将array看成完全二叉树的顺序存储结构
private static int[] buildMaxHeap(int[] array) {
//从最后一个节点array.length-1的父节点（array.length-1-1）/2开始，直到根节点0，反复调整堆
for(int i=(array.length-2)/2;i>=0;i--){
adjustHeap(array, i, array.length);
}
return array;
}
private static void adjustHeap(int[] array, int k, int length) {
int k1=2*k+1;
if(k1length-1||array[k]>=array[k1]){
return;
}else{
int temp = array[k]; //将堆顶元素和左右子结点中较大节点交换
array[k] = array[k1];
array[k1] = temp;
adjustHeap(array,k1,length);
}
}
public static void main(String[] args) {
int[] a = {87,45,78,32,17,65,53,9,122,133};
heapSort(a);
System.out.println(Arrays.toString(a));
}
}