文章目录
基础算法一二课
这里主要介绍选择排序，冒泡排序，插入排序，（在已经排序好的数组判断某个数据是否在数组中），（找满足>=value的最左位置），（异或的妙用），
选择排序
public static void selectionSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
minIndex = arr[j] < arr[minIndex] ? j : minIndex;
}
swap(arr, i, minIndex);
}
}
代码思路
1.哨兵模式：通过minIndex对需要排序的位置进行记录，与未排序的部分进 行比较找出最小的元素，并与其交换。
冒泡排序
public static void bubbleSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int e = arr.length - 1; e > 0; e--) {
for (int i = 0; i < e; i++) {
if (arr[i] > arr[i + 1]) {
swap(arr, i, i + 1);
}
}
}
}
代码思路
1.代码整体过程犹如最大的元素像气泡冒在最后的位置。
2.整个过程交换数据较多。
插入排序
public static void insertionSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
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);
}
}
}
代码思路
1.整体过程就好似打牌中整理牌的过程，每次拿个元素与已经排好的数据进行比较若小于则继续往后移。
2.交换的过程相比于冒泡少，选择排序多。
判断数据是否在数组中
在已经排序好的数组判断某个数据是否在数组中
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 (sortedArr[mid] == num) {
return true;
} else if (sortedArr[mid] > num) {
R = mid - 1;
} else {
L = mid + 1;
}
}
return sortedArr[L] == num;
}
代码思路
1.需要注意的是，这里除以2是通过数据右移进行实现的。
2.读取数据，这里是读取L(左边的数据），其实右边同理可以的。
找满足>=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 (arr[mid] >= value) {//这里只记录中间数据大于等于要找的数据
index = mid;
R = mid - 1;
} else {
L = mid + 1;
}
}
return index;
}
代码思路
1.整体过程与二分法找数据过程相似，但是只记录了中间数据大于等于要找的数据
2.若没有则返回为-1，所以在最开始的初始化为-1.
^ 异或符号的多用
异或运算满足交换律和结合率
一.进行交换
int a = 5;
int b = 7;
a = a ^ b;
b = a ^ b;
a = a ^ b;
代码思路
1.这里只是进行了位操作，所进行消耗成本较小。0^N == N
N^N == 0
2.论证过程: a=a^b, b = a ^ b ^ b，a = a ^ b ^ a ^b ^ b
二.数组中有一种数出现了奇数次，其他数都出现了偶数次，找出一个奇数次的数
public static void printOddTimesNum1(int[] arr) {
int eO = 0;
for (int cur : arr) {
eO ^= cur;
}
System.out.println(eO);
}
代码思路
1.整个过程就是，整个数组进行异或，出现偶数次会注解进行一个消除，只有奇数次的留下来了。
三.数组中有两种数出现了奇数次，其他数都出现了偶数次，找出这两个出现奇数次的数
这里目前还不是很懂，需要看一下讲解
public static void printOddTimesNum2(int[] arr) {
int eO = 0, eOhasOne = 0;
for (int curNum : arr) {
eO ^= curNum;
}
int rightOne = eO & (~eO + 1);
for (int cur : arr) {
if ((cur & rightOne) != 0) {
eOhasOne ^= cur;
}
}
System.out.println(eOhasOne + " " + (eO ^ eOhasOne));
}
代码思路
1.
通过递归方法找数组中最大值
public static int process(int[] arr, int L, int R) {
if (L == R) {
return arr[L];
}
int mid = L + ((R - L) >> 1);
int leftMax = process(arr, L, mid);
int rightMax = process(arr, mid + 1, R);
return Math.max(leftMax, rightMax);
}
代码思路
1.这里使用了递归方法，找出终结条件，分而治之。
归并排序
public static void mergeSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
mergeSort(arr, 0, arr.length - 1);
}
public static void mergeSort(int[] arr, int l, int r) {
if (l == r) {
return;
}
int mid = l + ((r - l) >> 1);
mergeSort(arr, l, mid);
mergeSort(arr, mid + 1, r);
merge(arr, l, mid, r);
}
public static void merge(int[] arr, int l, int m, int r) {
int[] help = new int[r - l + 1];
int i = 0;
int p1 = l;
int p2 = m + 1;
while (p1 <= m && p2 <= r) {
help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
}
while (p1 <= m) {
help[i++] = arr[p1++];
}
while (p2 <= r) {
help[i++] = arr[p2++];
}
for (i = 0; i < help.length; i++) {
arr[l + i] = help[i];
}
}
代码思路
1.代码整体分为两部分，第一部分是对数组的一个划分（采用递归的方法）。对每个划分的区域进行一个排序
通过递归方法找数组中最大值
public static int process(int[] arr, int L, int R) {
if (L == R) {
return arr[L];
}
int mid = L + ((R - L) >> 1);
int leftMax = process(arr, L, mid);
int rightMax = process(arr, mid + 1, R);
return Math.max(leftMax, rightMax);
}
代码思路
1.这里使用了递归方法，找出终结条件，分而治之。
最小和问题
这里不是很懂，需要看讲解 也同属于上面递归问题，同样的划分
问题描述：在一个数组中，每一个数左边比当前数小的数累加起来，叫做这个数组的小和。求一个数组 的小和。
例子:[1,3,4,2,5] 1左边比1小的数，没有; 3左边比3小的数，1; 4左边比4小的数，1、3; 2左边比2小的数，1; 5左边比5小的数，1、3、4、2; 所以小和为1+1+3+1+1+3+4+2=16
public static int smallSum(int[] arr) {
if (arr == null || arr.length < 2) {
return 0;
}
return mergeSort(arr, 0, arr.length - 1);
}
public static int mergeSort(int[] arr, int l, int r) {
if (l == r) {
return 0;
}
int mid = l + ((r - l) >> 1);
return mergeSort(arr, l, mid)
+ mergeSort(arr, mid + 1, r)
+ merge(arr, l, mid, r);
}
public static int merge(int[] arr, int l, int m, int r) {
int[] help = new int[r - l + 1];
int i = 0;
int p1 = l;
int p2 = m + 1;
int res = 0;
while (p1 <= m && p2 <= r) {
res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
}
while (p1 <= m) {
help[i++] = arr[p1++];
}
while (p2 <= r) {
help[i++] = arr[p2++];
}
for (i = 0; i < help.length; i++) {
arr[l + i] = help[i];
}
return res;
}
代码思路
…
堆排序
public static void heapSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
for (int i = 0; i < arr.length; i++) {
heapInsert(arr, i);
}
int size = arr.length;
//把最大值向后移
swap(arr, 0, --size);
while (size > 0) {
//在移动后，再整型为大根堆
heapify(arr, 0, size);
//再整型
swap(arr, 0, --size);
}
}
//生成大根堆
public static void heapInsert(int[] arr, int index) {
while (arr[index] > arr[(index - 1) / 2]) {
swap(arr, index, (index - 1) /2);
index = (index - 1)/2 ;
}
}
//移动后的整型方法
public static void heapify(int[] arr, int index, int size) {
int left = index * 2 + 1;
while (left < size) {
//在左分支和右分支中找到最大的那个
int largest = left + 1 < size && arr[left + 1] > arr[left] ? left + 1 : left;
//在包括根节点中，找到最大的那个
largest = arr[largest] > arr[index] ? largest : index;
//若最大仍然为根节点，则不用操作
if (largest == index) {
break;
}
//否则向下移
swap(arr, largest, index);
//再向下移进行比较
index = largest;
left = index * 2 + 1;
}
}
代码思路
整个代码过程，逐个形成大根堆，在此基础上，把根节点与当前size互换，之后在整型为大根堆。
荷兰国旗问题
问题描述：给定一个数组arr，和一个数num，请把小于num的数放在数组的 左边，等于num的数放在数组的中间，大于num的数放在数组的 右边。要求额外空间复杂度O(1)，时间复杂度O(N)
//int[] res = partition(test, 0, test.length - 1, 1);
public static int[] partition(int[] arr, int l, int r, int p) {
int less = l - 1;
int more = r + 1;
//less始终指着小于p且紧挨着等于p的值
//more始终指着大于p且紧挨着等于p的值
while (l < more) {
if (arr[l] < p) {
swap(arr, ++less, l++);
} else if (arr[l] > p) {
swap(arr, --more, l);
} else {
l++;
}
}
return new int[] { less + 1, more - 1 };
}
代码思路
首先，需要维持着两个指针： ①less始终指着小于p且紧挨着等于p的值 ②more始终指着大于p且紧挨着等于p的值。 l始终是维持着前进，然后分别对应三种不同情况进行处理。
快排
public static void quickSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
quickSort(arr, 0, arr.length - 1);
}
public static void quickSort(int[] arr, int l, int r) {
if (l < r) {
//这里是把数组中随机一个元素与数组最后一个数据交换，就以这个随机元素作为中间数
swap(arr, l + (int) (Math.random() * (r - l + 1)), r);
int[] p = partition(arr, l, r);
quickSort(arr, l, p[0] - 1);
quickSort(arr, p[1] + 1, r);
}
}
public static int[] partition(int[] arr, int l, int r) {
int less = l - 1;
int more = r;
while (l < more) {
if (arr[l] < arr[r]) {
swap(arr, ++less, l++);
} else if (arr[l] > arr[r]) {
swap(arr, --more, l);
} else {
l++;
}
}
swap(arr, more, r);
return new int[] { less + 1, more };
}
public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
代码思路
这里借用了荷兰问题的方法维持了三个部分。
计数排序
主要针对需要排序的值比较小的时候。大概范围为0-200
public static void countSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
int max = Integer.MIN_VALUE;
for (int i = 0; i < arr.length; i++) {
max = Math.max(max, arr[i]);
}
int[] bucket = new int[max + 1];
for (int i = 0; i < arr.length; i++) {
bucket[arr[i]]++;
}
int i = 0;
for (int j = 0; j < bucket.length; j++) {
while (bucket[j]-- > 0) {
arr[i++] = j;
}
}
代码思路
1.计数排序是以空间换时间，其中时间消耗O(max(value))。根据需要排序的数组中最大的数，新建一个help[max(value)]数组。
基数排序
主要针对无负数的排序
// only for no-negative value
public static void radixSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
radixSort(arr, 0, arr.length - 1, maxbits(arr));
}
//返回最大值是多少位数
public static int maxbits(int[] arr) {
int max = Integer.MIN_VALUE;
for (int i = 0; i < arr.length; i++) {
max = Math.max(max, arr[i]);
}
int res = 0;
while (max != 0) {
res++;
max /= 10;
}
return res;
}
public static void radixSort(int[] arr, int begin, int end, int digit) {
final int radix = 10;
int i = 0, j = 0;
int[] bucket = new int[end - begin + 1];
for (int d = 1; d <= digit; d++) {
int[] count = new int[radix];
for (i = begin; i <= end; i++) {
j = getDigit(arr[i], d);
count[j]++;
}
for (i = 1; i < radix; i++) {
count[i] = count[i] + count[i - 1];
}
for (i = end; i >= begin; i--) {
j = getDigit(arr[i], d);
bucket[count[j] - 1] = arr[i];
count[j]--;
}
for (i = begin, j = 0; i <= end; i++, j++) {
arr[i] = bucket[j];
}
}
}
//返回一个数在d位数上的值
public static int getDigit(int x, int d) {
return ((x / ((int) Math.pow(10, d - 1))) % 10);
}
代码思路
代码过程需要过一遍，目前还不是很懂。
总结
** 还有
①数组中有两种数出现了奇数次，其他数都出现了偶数次，找出这两个出现奇数次的数
②最小和问题
③基数排序
目前不是很懂**
1628
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
