三大排序算法
通过使用对数器来检验,可以保证代码的正确性。
1)选择排序
package com.harrison.one;
import java.util.Arrays;
//选择排序
public class Class01_SelectionSort {
// 选择排序核心代码
public static void selectionSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int i = 0; i < arr.length - 1; i++) {// i~N-1
// 最小值在哪个位置上,i~N-1
int minIdx = i;
for (int j = i + 1; j < arr.length; j++) {// i~N-1上找最小值的下标
minIdx = arr[j] < arr[minIdx] ? j : minIdx;
}
swap(arr, i, minIdx);
}
}
// 交换两个元素
public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
// 产生随机数组,长度随机,且值也随机
public static int[] generateRandomArray(int maxSize, int maxValue) {
int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
}
return arr;
}
// copy数组
public static int[] copyArray(int[] arr) {
if (arr == null) {
return null;
}
int[] res = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
res[i] = arr[i];
}
return res;
}
// 写一个比较器的方法:系统提供的排序的方法,肯定是对的
public static void comparator(int[] arr) {
Arrays.sort(arr);
}
// 比较两个数组是否完全一样
public static boolean isEqual(int[] arr1, int[] arr2) {
if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
return false;
}
if (arr1 == null && arr2 == null) {
return true;
}
if (arr1.length != arr2.length) {
return false;
}
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
//打印数组
public static void printArray(int[] arr) {
if (arr == null) {
return;
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int testTime = 500000;
int maxSize = 100;
int maxValue = 100;
boolean succeed = true;
for (int i = 0; i < testTime; i++) {
int[] arr1 = generateRandomArray(maxSize, maxValue);
int[] arr2 = copyArray(arr1);
selectionSort(arr1);
comparator(arr2);
if (!isEqual(arr1, arr2)) {// 相同返回1,不相同返回0
printArray(arr1);
printArray(arr2);
break;
}
}
System.out.println(succeed ? "Nice!" : "Fucking fucked!");
int[] arr = generateRandomArray(maxSize, maxValue);
printArray(arr);
selectionSort(arr);
printArray(arr);
}
}
由于只有核心部分代码不一样,所以只放核心部分代码
2)冒泡排序
public static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int e = arr.length - 1; e > 0; e--) {// 0~e
for (int i = 0; i < e; i++) {
if (arr[i] > arr[i + 1]) {
swap(arr, i, i + 1);
}
}
}
}
3)插入排序
public static void insertionSort(int[] arr) {
if (arr == null || arr.length < 2) {// 0~0位置上有序
return;
}
// 1~i位置上有序
for (int i = 1; i < arr.length; i++) {
for (int j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
swap(arr, j, j + 1);
}
}
}
认识随机函数
- Math.random():[0,1)范围上所有的小数等概率返回一个(前闭后开)
- Math.random()*N:[0,N)
- (int)(Math.random()*N):[0,N-1]
- [0,N]:(int)(N+1)* ((maxValue+1)*Math.random());
- [-?,+?]:(int)((maxValue+1)* Math.random())-(int)(maxValue*(maxValue+1) *Math.random());
认识二分法
在一个有序数组中:1)找某个数是否存在;2)找>=某个数最左侧的位置;3)找<=某个数最右侧的位置
1)找某个数是否存在
package com.harrison.one;
import java.util.Arrays;
//在一个有序数组中,找某个数是否存在
public class Class04_BSExist {
// 二分法核心代码
public static boolean exist(int[] sortedArr, int num) {
if (sortedArr == null || sortedArr.length == 0) {
return false;
}
int L = 0;
int R = sortedArr.length - 1;
int mid = 0;
while (L < R) {
mid = L + ((R - L) >> 1);
if (num == sortedArr[mid]) {
return true;
} else if (num < sortedArr[mid]) {
R = mid - 1;
} else {
L = mid + 1;
}
}
return sortedArr[L] == num;
}
//另写的一个方法,不使用二分法
public static boolean test(int[] sortedArr, int num) {
for (int cur : sortedArr) {
if (cur == num) {
return true;
}
}
return false;
}
// 产生随机数组,长度随机,且值也随机
public static int[] generateRandomArray(int maxSize, int maxValue) {
int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
}
return arr;
}
public static void main(String[] args) {
int testTime = 500000;
int maxSize = 10;
int maxValue = 100;
boolean succeed = true;
for (int i = 0; i < testTime; i++) {
int[] arr = generateRandomArray(maxSize, maxValue);
Arrays.sort(arr);
int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
if (test(arr, value) != exist(arr, value)) {
succeed = false;
break;
}
}
System.out.println(succeed ? "Nice!" : "Fucking fucked!");
}
}
2)找>=某个数最左侧的位置
package com.harrison.one;
import java.util.Arrays;
//在一个有序数组中,找>=某个数最左侧的位置
public class Class05_BSNearLeft {
// 在arr上,找>=value的最左位置
public static int nearestIndex(int[] arr, int value) {
int L = 0;
int R = arr.length - 1;
int index = -1;// 记录最左的对号
while (L <= R) {
int mid = L + ((R - L) >> 1);
if (value <= arr[mid]) {
R = mid - 1;
index = mid;
} else {
L = mid + 1;
}
}
return index;
}
//另写的一个方法,不使用二分
public static int test(int[] arr, int value) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] >= value) {
return i;
}
}
return -1;
}
// 产生随机数组,长度随机,且值也随机
public static int[] generateRandomArray(int maxSize, int maxValue) {
int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
}
return arr;
}
// 打印数组
public static void printArray(int[] arr) {
if (arr == null) {
return;
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
public static void main(String[] args) {
int testTime = 500000;
int maxSize = 10;
int maxValue = 100;
boolean succeed = true;
for (int i = 0; i < testTime; i++) {
int[] arr = generateRandomArray(maxSize, maxValue);
Arrays.sort(arr);
int value = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
if (test(arr, value) != nearestIndex(arr, value)) {
printArray(arr);
System.out.println(value);
System.out.println(test(arr, value));
System.out.println(nearestIndex(arr, value));
succeed = false;
break;
}
}
System.out.println(succeed ? "Nice!" : "Fucking fucked!");
}
}
3)找<=某个数最右侧的位置
// 在arr上,找<=value的最右位置
public static int nearestIndex(int[] arr, int value) {
int L = 0;
int R = arr.length - 1;
int index = -1;// 记录最右的对号
while (L <= R) {
int mid = L + ((R - L) >> 1);
if (value >= arr[mid]) {
L = mid + 1;
index = mid;
} else {
R = mid - 1;
}
}
return index;
}
补充
使用二分法时,mid=(L+R)/2,如果L和R数值很大很大时,mid会溢出,所以比较好的一种方式是写成:
mid=L+(R-L)/2 => mid=L+((R-L)>>1); >>:带符号右移1位;>>>:不带符号位右移(不管最高位是0还是1,都用0来补)。
另一个写成这样的原因就是位运算就是比除运算快!!!
4)局部最小值问题
题目:给定一个数组,无序,任意两个相邻的数都不相等,返回任意一个局部最小
分析:可以用二分法,不一定要有序才能二分!只要有二分的标准,在二分的过程中,有一种排他性的原则出现,就可以二分!!!
关键代码:mid>mid-1 => right=mid-1 mid>mid+1 => left=mid+1
public static int getLessIndex(int[] arr) {
if(arr==null || arr.length==0) {
return -1;//no exist
}
if(arr.length==1 || arr[0]<arr[1]) {
return 0;
}
if(arr[arr.length-1]<arr[arr.length-2]) {
return arr.length-1;
}
int left=1;
int right=arr.length-2;
int mid=0;
while(left<right) {
mid=(left+right)/2;
if(mid>mid-1) {
right=mid-1;
}else if(mid>mid+1) {
left=mid+1;
}else {
return mid;
}
}
return left;
}
认识异或运算
- 异或运算:相同为0,不同为1
- 同或运算:相同为1,不同为0
容易记混!更好的记忆方式:异或运算即无进位相加
异或运算的性质
- 0^N==N
- N^N==0
- 异或运算满足交换律和结合律(即同样一批数异或的结果与顺序无关)
利用异或运算的性质进行骚操作
1)不用额外变量交换两个数
- int a=甲 int b=乙
- a=a^b
- b=a^b
- a=a^b
前提:a和b不能指向同一片内存,哪怕值相同也行,但是就是不能指向同一片内存
2)一个数组中有一种数出现了奇数次,其它数都出现了偶数次,怎么找到并打印这种数
3)怎么把一个整型的数,提取出最右侧的1来 => int Ans=N&((~N)+1)
4)一个数组中有两种数出现了奇数次,其它数都出现了偶数次,怎么找到并打印这两种数
5)给出一个数,求该数二进制1的个数
public static int bit1Counts(int N) {
int count=0;
// N 00100110100
// rightOne 00000000100
// N 00100110000
// rightOne 00000010000
while(N!=0) {
int rightOne=N&((~N)+1);
count++;
N^=rightOne;
}
return count;
}
代码:
package com.harrison.one;
//一个数组中有一种数出现了奇数次,其他数都出现了偶数次,怎么找到并打印这种数
public class Class07_EvenTimesOddTimes {
//arr中,只有一种数,出现奇数次
public static void printOddTimesNum1(int [] arr) {
int eor=0;
for(int i=0; i<arr.length; i++) {
eor^=arr[i];
}
System.out.println(eor);
}
//arr中,有两种数,出现奇数次
public static void printOddTimesNum2(int [] arr) {
int eor=0;
for(int i=0; i<arr.length; i++) {
eor^=arr[i];
}
//eor==a^b
//因为a和b不相等,所以eor!=0
//eor必然在某个位置上有1
//找eor最右侧的1
int rightOne=eor&((~eor)+1);
int onlyOne=0;//eor'
for(int i=0; i<arr.length; i++) {
//如果一个数 和 一个位置上有1的数 按位与 不等于0,说明这个数的这个位置上为1
if((arr[i]&rightOne)!=0) {
//eor'重新异或arr数组,但是只异或最右侧位置上为1的数
onlyOne^=arr[i];
}
}
System.out.println(onlyOne+" "+(eor^onlyOne));
}
//给出一个数,求该数二进制1的个数
public static int bit1Counts(int N) {
int count=0;
// N 00100110100
// rightOne 00000000100
// N 00100110000
// rightOne 00000010000
while(N!=0) {
int rightOne=N&((~N)+1);
count++;
N^=rightOne;
}
return count;
}
public static void main(String[] args) {
int a = 5;
int b = 7;
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.println(a);
System.out.println(b);
int[] arr1 = { 3, 3, 2, 3, 1, 1, 1, 3, 1, 1, 1 };
printOddTimesNum1(arr1);
int[] arr2 = { 4, 3, 4, 2, 2, 2, 4, 1, 1, 1, 3, 3, 1, 1, 1, 4, 2, 2 };
printOddTimesNum2(arr2);
}
}