Java中常见的排序算法

文章中只写排序算法的代码，而Java中常见的排序算法有：
冒泡排序、选择排序、插入排序、快速排序、希尔排序、归并排序和堆排序

冒泡排序

首先最基础的就是冒泡排序
冒泡排序的思想就是：每一趟都进行俩俩比较，把最大的交换在末尾。

public int[] bubbleSort(int[] array) {
	if(array.length <= 1) {
		return array;
	}
	for(int i = 0 ; i < array.length; i++) {//总共有array.length 趟次数
		int falt = -1;//优化
		for(int  j = 0; j < array.length - i - 1; j++) {//遍历
			if(array[j] > array[j + 1] ) {//每一次遇到大的就和后面一个交换
				int temp = array[j];
				array[j] = array[j + 1];
				array[j + 1] = temp;
				falt++;
			}
		}//走到这里说明已经把这趟最大的数放在最后了，前面都是小于它的数
		if(falt == -1) {//如果一趟里面一次都没有比较过，说明已经有序了。
			break;
		}
	}
	return array;
}

选择排序

算法思想：从要排序数组的坐标为0开始，遍历数组，找到最小的下标，与当前数组下标进行交换。

public int[] selectSort(int[] array) {
	if(array.length <= 1) {
		return array;
	}
	for(int i = 0; i < array.lenght; i++) {
		int minIndex = i;
		for(int j = i; j < array.lenght; j++) {
			if(array[j] < array[minIndex]) {
				minIndex = j;
			}
		}
		int temp = array[minIndex];
		array[minIndex] = array[i];
		array[i] = temp;
	}
	return array;
}

插入排序

算法思想：采取一次遍历，每次都拿到下一个数（temp）与前面的数进行比较，如果比前面小，就把大数后移一位，直到找到前面的数小于或等于temp，那么此时就插入完成了，又重新重复上一个步骤。

public static int[] insertSort(int[] array) {
	if(array.length <= 1) {
		return array;
	}
	for(int i = 0; i < array.length - 1; i++) {
		int temp = array[i + 1];
		int index = i;
		while(index >= 0 && array[index] > temp) {
			array[index + 1] = index[index];
			index--;
		}
		array[index + 1] = temp;
	}
	return array;
}

快速排序

public static void quickSort(int[] array,int star,int end) {
	 if(star >= end) {
            return;
        }
        int left = star;
        int right = end;
        int temp = array[left];
        while (left < right) {
            while (left < right && array[right] >= temp) {
                right--;
            }
            array[left] = array[right];
            while (left < right && array[left] <= temp) {
                left++;
            }
            array[right] = array[left];
        }
        array[left] = temp;
        quickSort(array,star,left-1);
        quickSort(array,left+1,end);
    }
}

希尔排序

public static int[] birarySort(int[] array) {
	if(array.length <= 1) {
		return array;
	}
	int gap = array.length / 2;//
	while(gap > 0) {
		for(int i = gap; i < array.length; i++) {
			int temp = array[i];
			int pre = i - gap;
			while(pre >= 0 && array[pre] > temp) {
				array[pre + gap] = array[pre];
				pre -= gap;
			}
			array[pre + gap] = temp;
		}
		gap /= 2;
	}
	return array;
}

归并排序

public static int[] mergeSort(int[] array) {
	if(array.lenght <= 1) {
		return array;
	}
	int mid = array.lenght / 2;
	int[] left = Arrays.copyOfRange(array,0,mid);
	int[] right = Arrays.copyOfRange(array,mid,array.lenght);
	return merge(mergeSort(left), mergeSort(right));
}

public static int[] merge(int[] left, int[] right) {
	int[] result = new int[left.lenght + right.lenght];
	for(int i = 0,j = 0,index = 0; index < result.lenght; index++) {
		if(i >= left.lenght) {
			result[index] = right[j++];
		}else if(j >= right.lenght) {
			result[index] = left[i++];
		}else if(left[i] <= right[j]) {
			result[index] = left[i++];
		}else {
			result[index] = right[j++];
		}
	}
	return result;
}

堆排序

// 堆排序 最后结果是升序排列的
public class Main{

	public static void main(String []args){
        int []arr = {7,6,7,11,5,12,3,0,1};
        System.out.println("排序前："+Arrays.toString(arr));
        sort(arr);
        System.out.println("排序前："+Arrays.toString(arr));
    }

//结果为：
//排序前：[7, 6, 7, 11, 5, 12, 3, 0, 1]
//排序后：[0, 1, 3, 5, 6, 7, 7, 11, 12]
//1
	public static void sort(int[] array) {
        //1.构建大顶堆
        for(int i = array.length / 2 - 1; i >= 0; i--) {
            //从第一个非叶子节点，从下到上，从左到右
            adjustHeap(array,i,array.length);
        }
        //2.调整堆结构 + 交换堆顶元素 与末尾元素
        for(int j = array.length - 1; j > 0; j--) {
            swap(array,0,j);//对顶元素与末尾元素交换
            adjustHeap(array,0,j);
        }
    }

    //2
    public static void adjustHeap(int[] array, int i,int len) {
        int temp = array[i];//取出当前元素
        for(int k = i * 2 + 1; k < len; k = k * 2 + 1) {//从i结点的左子结点开始，也就是2i+1处开始
            if(k + 1 < len && array[k] < array[k + 1]) {//如果左子结点小于右子结点，k指向右子结
                k++;
            }
            if(array[k] > temp) {//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                array[i] = array[k];
                i = k;
            }else {
                break;
            }
        }
        array[i] = temp;//将temp值放到最终的位置
    }

    public static void swap(int[] array, int a, int b) {
        int temp = array[a];
        array[a] = array[b];
        array[b] = temp;
    }
}

博客中都是个人理解，如有错误或误导，欢迎指出，我会及时修改，谢谢大家。