前言
仅记录学习笔记，如有错误欢迎指正。
记录一下常用的数组的各种排序冒泡排序
复杂度O(n2)public static void bubbleSort(int[] array) {
if (array == null || array.length <= 1) {
return;
}
int length = array.length;
// 外层循环控制比较轮数i
for (int i = 0; i < length; i++) {//最后一个数也需要比较
// 内层循环控制每一轮比较次数，每进行一轮排序都会找出一个较大值
// (array.length - 1)防止索引越界，(array.length - 1 - i)减少比较次数
for (int j = 0; j < length - 1 - i; j++) {
// 前面的数大于后面的数就进行交换
if (array[j] > array[j + 1]) {
int temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
}
}
}
选择排序
复杂度O(n2)public static void selectionSort(int[] array) {
if (array == null || array.length <= 1) {
return;
}
int length = array.length;
for(int i = 0;i<length-1;i++){ //<length-1 的原因是最后一个数不需要比了 所有不用走最后一次
int minIndex = i;//记录最小值的下标 关键！！！！！！
//找到最小值所在的下标
for(int j = i+1;j<length;j++){
if(array[minIndex]>array[j]){
minIndex = j;
}
}
// 交换元素位置
if (i != minIndex) {
swap(array, minIndex, i);
}
}
}
//交换位置的方法
private static void swap(int[] array, int a, int b) {
int temp = array[a];
array[a] = array[b];
array[b] = temp;
}
插入排序
复杂度O(n2)public static void insertionSort(int[] array) {
if (array == null || array.length <= 1) {
return;
}
int length = array.length;
int flagNum;//这是每次需要插入的数
for(int i = 1;i<length-1;i++){ // i<length-1不需要走最后一次 i从1开始！！
flagNum = array[i];
int j = i-1;
while(j >= 0 &&array[j]>flagNum){
// 从后到前循环，将大于insertNum的数向后移动一格 34521
array[j+1]=array[j];
j--;
}
array[j+1]=flagNum;
}
}
希尔排序
复杂度O(nlog2n) public static void shellSort(int[] array) {
if (array == null || array.length <= 1) {
return;
}
int length = array.length;
// temp为临时变量，gap增量默认是长度的一半，每次变为之前的一半，直到最终数组有序
int temp, gap = length / 2;
while (gap > 0) {
for (int i = gap; i < length; i++) {
// 将当前的数与（减去增量之后位置的数）进行比较，如果大于当前数，将它后移
temp = array[i];
int preIndex = i - gap;
while (preIndex >= 0 && array[preIndex] > temp) {
array[preIndex + gap] = array[preIndex];
preIndex -= gap;
}
// 将当前数放到空出来的位置
array[preIndex + gap] = temp;
}
gap /= 2;
}
}
归并排序
分治法 T(n) = O(nlogn) master 公式：T(N) = 2T(N/2) +O(n) = O(nlogn)  public static void mergeSort(int[] array) {
if (array == null || array.length <= 1) {
return;
}
sort(array, 0, array.length - 1);
}
private static void sort(int[] array, int left, int right) {
if(left == right){
return;
}
int mid = left + ((right - left) >> 1);
// 对左侧子序列进行递归排序
sort(array, left, mid);
// 对右侧子序列进行递归排序
sort(array, mid + 1, right);
// 合并
merge(array, left, mid, right);
}
private static void merge(int[] array, int left, int mid, int right) {
int[] temp = new int[right - left + 1];
int i = 0;
int p1 = left;
int p2 = mid + 1;
// 比较左右两部分的元素，哪个小，把那个元素填入temp中
while (p1 <= mid && p2 <= right) {
temp[i++] = array[p1] < array[p2] ? array[p1++] : array[p2++];
}
// 上面的循环退出后，把剩余的元素依次填入到temp中
// 以下两个while只有一个会执行
while (p1 <= mid) {
temp[i++] = array[p1++];
}
while (p2 <= right) {
temp[i++] = array[p2++];
}
// 把最终的排序的结果复制给原数组
for (i = 0; i < temp.length; i++) {
array[left + i] = temp[i];
}
}
快速排序
O(nlogn) 多来看看！~ public static void quickSort(int[] array){
quickSort(array,0,array.length-1);
}
//重载方便调用
private static void quickSort(int[] array, int left, int right) {
if(array == null || left >= right ||array.length < 1){
return;
}
int mid = partition(array,left,right);
quickSort(array, left, mid-1);//第一次结束后对左边进行排序，记得mid-1，不然54321报错
quickSort(array, mid + 1, right);//第一次结束后对右边边进行排序
}
private static int partition(int[] array, int left, int right) {
int temp = array[left];//基准数开始设为第一个数
//小的放左边 大的放右边
while (left < right){
while (array[right]>= temp && left < right){
--right;//在右边找小于temp的下标
}
//找到后直接赋值
if(left < right){
array[left] = array[right];
++left;//left位置加一方便下次赋值！！
}
while (array[left] <= temp && left < right){
++left;//在右边找小于temp的
}
if(left < right){
array[right]=array[left];
--right;
}
}
array[left] = temp; //基准数的值赋值回来
return left;
}
堆排序
大根堆 根节点的值大于左右节点的值java默认小根堆 PriorityQueue
public static void heapSort(int[] array) {
if (array == null || array.length <= 1) {
return;
}
int length = array.length;
//1.构建大顶堆
for (int i = length / 2 - 1; i >= 0; i--) {
//从第一个非叶子结点从下至上，从右至左调整结构
adjustHeap(array, i, length);
}
//2.调整堆结构+交换堆顶元素与末尾元素
for (int j = length - 1; j > 0; j--) {
//将堆顶元素与末尾元素进行交换
swap(array, 0, j);
//重新对堆进行调整
adjustHeap(array, 0, j);
}
}
private static void adjustHeap(int[] array, int i, int length) {
int temp = array[i];
//从i结点的左子结点开始，也就是2i+1处开始 (1,3,5 下标对应的为左子节点)
for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
//如果左子结点小于右子结点，k指向右子结点
if(k+1<length && array[k]<array[k+1]){
k++;
}
//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
if (array[k] > temp) {
array[i] = array[k];
i = k;
} else {
break;
}
}
//将temp值放到最终的位置
array[i] = temp;
}
转载地址：大佬的博客~
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
