方法一:mid=(left+right)/2 -> left/2+right/2 -> left+(-left/2+right/2) -> l+(r-l)/2
方法二:mid=(l+r)>>>1 字节溢出整体右移一位就是正确的值
冒泡排序常规版优化方法bubble(减少比较次数+冒泡次数)重点加上标志
冒泡排序终极版优化方法bubble1记录最后一次交换位置(减少比较次数+冒泡次数)
文字描述:依次比较数组中相邻两个元素大小 若a[j]>a[j+1] 则交换两个元素 两两比较一遍称为一轮冒泡,结果是让最大的元素排到最后
package com.huhu.sort;
import java.util.Arrays;
public class BubbleSort2 {
public static void main(String[] args) {
int[] a={5,2,7,4,1,3,8,9};
bubble2(a);
}
public static void bubble(int[] a){
for (int j = 0; j < a.length - 1; j++) {
// 一轮冒泡
boolean swapped=false;//默认没有交换
// 优化二:减少冒泡次数(判断是否交换)
// 优化一:减少比较次数 -j
for (int i = 0; i < a.length - 1 - j; i++) {
System.out.println("比较次数:"+(i+1));
if (a[i]>a[i+1]){
swap(a,i,i+1);
swapped=true;
}
}
System.out.println("第"+(j+1)+"轮冒泡:"+ Arrays.toString(a));
if (!swapped) {
break;
}
}
}
public static void bubble2(int[] a){
int n=a.length-1;
while (true){
int last=0;//记录最后一次交换的位置
for (int i=0;ia[i+1]){
swap(a,i,i+1);
last=i;
}
}
n=last;
System.out.println("第轮冒泡:"+ Arrays.toString(a));
if (n==0){
break;
}
}
}
public static void swap(int[] a,int i,int j){
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
将数组分为两个子集,排序和未排序的,每一轮从未排序的子集中选出最小的元素,放入排序子集,重复以上步骤,直到整个数组有序(循环查找最小元素索引位置 交换)
package com.huhu.sort;
import java.util.Arrays;
//理论上的选择排序法
public class SelectSort2 {
public static void main(String[] args) {
int[] arr = {101, 34, 119, 60};
System.out.println("排序前的数组");
System.out.println(Arrays.toString(arr));
selectSort(arr);
}
private static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
// i代表每轮选择最小元素要交换到的目标索引
int s=i; //最小元素的索引
for (int j = s + 1; j < arr.length; j++) {
if (a[s] > arr[j]) {
s=j;
}
}
if (s != i) {
swap(a,s,i);
}
System.out.println("第" + (i + 1) + "轮排序后数组");
System.out.println(Arrays.toString(arr));
}
}
public static void swap(int[] a,int i,int j){
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
选择排序与冒泡排序比较
将数组分为两个区域,排序和未排序的,每一轮从未排序的区域中取出第一个元素,插入到排序区域,重复以上步骤,直到整个数组有序
package com.huhu.sort;
import java.util.Arrays;
public class InsertSort2 {
public static void main(String[] args) {
int[] a = {9,3,7,2,5,8,1,4};
insert(a);
}
private static void insert(int[] a) {
// i代表待插入元素的索引
for (int i = 1; i < a.length; i++) {
int t = a[i];//t代表待插入元素的值
int j = i - 1;//代表已排序数组的索引
while (j >= 0) {
if (t < a[j]) {
a[j + 1] = a[j];
} else {
break;
}
j--;
}
a[j + 1] = t;
System.out.println(Arrays.toString(a));
}
}
}
插入排序与选择排序比较
时间复杂度O(nlogn) 最坏O(n) 使用于数据量大 不稳定排序
单边快排
package com.huhu.sort;
import java.util.Arrays;
public class QuickSort1 {
public static void main(String[] args) {
int[] a={5,3,7,2,9,8,1,4};
quick(a,0,a.length-1);
}
public static void quick(int[] a,int l,int h){
if (l>=h){
return;
}
int p=partition(a,l,h);
quick(a,l,p-1);
quick(a,p+1,h);
}
public static int partition(int[] a,int l,int h){
int pv=a[h];//最右为基准元素
int i=l;
for (int j = l; j < h; j++) {
if (a[j]从右往左找小的 从左往右找大的)
package com.huhu.sort;
import java.util.Arrays;
public class QuickSort1 {
public static void main(String[] args) {
int[] a={5,3,7,2,9,8,1,4};
quick(a,0,a.length-1);
}
public static void quick(int[] a,int l,int h){
if (l>=h){
return;
}
int p=partition(a,l,h);
quick(a,l,p-1);
quick(a,p+1,h);
}
public static int partition(int[] a,int l,int h){
int pv=a[l];
int i=l;
int j=h;
while (ipv){
j--;
}
while (i