七大查找
1.1二分查找(前提是 数据有序)
说明：元素必须是有序的，从小到大，或者从大到小都是可以的。
public static int binarySearc(int[] arr,int number){
int min=0;
int max=arr.length-1;
while(true){
if(min>max){
return -1;
}
int mid=(max+min)/2;
if(arr[mid]==number)
return mid;
else if(arr[mid]>number)
max=mid-1;
else if(arr[mid]<number)
min=mid+1;
}
}35. 搜索插入位置 最后输出left？
class Solution {
public int searchInsert(int[] nums, int target) {
int left = 0, right = nums.length - 1;
while(left <= right) {
int mid = (left + right) / 2;
if(nums[mid] == target) {
return mid;
} else if(nums[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return left;
}
}268. 丢失的数字 太简单了
！34. 在排序数组中查找元素的第一个和最后一个位置
class Solution {//不能解决数组内 负数 问题
public int[] searchRange(int[] nums, int target) {
if(nums.length==0)
return new int[]{-1,-1};
int[] arr=new int[nums[nums.length-1]+1];
for(int i=0;i<nums.length;i++){
arr[i]=0;
}
int c=-1;
for(int i=0;i<nums.length;i++){
arr[ nums[i] ]++;
if(nums[i]==target&&arr[nums[i]]==1)
c=i;
}
if(c!=-1)
return new int[]{c ,(c+arr[target]-1)};
else
return new int[]{-1,-1};
}
}
//https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/solution/zai-pai-xu-shu-zu-zhong-cha-zhao-yuan-su-de-di-3-4/
//他不是找目标位置，而是找第一个等于的位置和第一个>的位置
class Solution {
public int[] searchRange(int[] nums, int target) {
int leftIdx = binarySearch(nums, target, true);//第一个=target的位置
int rightIdx = binarySearch(nums, target, false) - 1;//第一个》target-1的位置
if (leftIdx <= rightIdx && rightIdx < nums.length && nums[leftIdx] == target && nums[rightIdx] == target) {
return new int[]{leftIdx, rightIdx};
}
return new int[]{-1, -1};
}
public int binarySearch(int[] nums, int target, boolean lower) {
int left = 0, right = nums.length - 1, ans = nums.length;
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] > target || (lower && nums[mid] >= target)) {
right = mid - 1;
ans = mid;
} else {
left = mid + 1;
}
}
return ans;
}
}74. 搜索二维矩阵
class Solution {//自己写的
public boolean searchMatrix(int[][] matrix, int target) {
int[] arr=new int[matrix.length];
if(matrix.length==1){//特殊情况，只有一个数组
for(int index:matrix[0] )
if(index==target)
return true;
return false;
}
for(int i=0;i<matrix.length-1;i++)
if(matrix[i][0]<=target&&matrix[i+1][0]>target)
{
for(int index:matrix[i] )
if(index==target)
return true;
}
else{//二维数组最后一行
for(int index:matrix[i+1] )
if(index==target)
return true;
}
return false;
}
}https://leetcode.cn/problems/search-a-2d-matrix/solution/sou-suo-er-wei-ju-zhen-by-leetcode-solut-vxui/
思路
若将矩阵每一行拼接在上一行的末尾，则会得到一个升序数组，我们可以在该数组上二分找到目标元素。
代码实现时，可以二分升序数组的下标，将其映射到原矩阵的行和列上。
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
int m = matrix.length, n = matrix[0].length;//m,n代表行和列
int low = 0, high = m * n - 1;
while (low <= high) {
int mid = (high - low) / 2 + low;
int x = matrix[mid / n][mid % n];//映射
if (x < target) {
low = mid + 1;
} else if (x > target) {
high = mid - 1;
} else {
return true;
}
}
return false;
}
}1.2插值查找 &斐波那契查找(二分查找改进版)
为什么二分查找算法一定要是折半，而不是折四分之一或者折更多呢？
其实就是因为方便，简单，但是如果我能在二分查找的基础上，让中间的mid点，尽可能靠近想要查找的元素，那不就能提高查找的效率了吗？
为什么二分查找算法一定要是折半，而不是折四分之一或者折更多呢？
其实就是因为方便，简单，但是如果我能在二分查找的基础上，让中间的mid点，尽可能靠近想要查找的元素，那不就能提高查找的效率了吗？
二分查找中查找点计算如下：
mid=(low+high)/2, 即mid=low+1/2*(high-low);
我们可以将查找的点改进为如下：
mid=low+(key-a[low])/(a[high]-a[low])*(high-low)，
这样，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。
基本思想：基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。
当然，差值查找也属于有序查找。
细节：对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。代码跟二分查找类似，只要修改一下mid的计算方式即可。
二分查找的另一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。同样地，斐波那契查找也属于一种有序查找算法。
斐波那契查找也是在二分查找的基础上进行了优化，优化中间点mid的计算方式即可
public class FeiBoSearchDemo {
public static int maxSize = 20;
public static void main(String[] args) {
int[] arr = {1, 8, 10, 89, 1000, 1234};
System.out.println(search(arr, 1234));
}
public static int[] getFeiBo() {
int[] arr = new int[maxSize];
arr[0] = 1;
arr[1] = 1;
for (int i = 2; i < maxSize; i++) {
arr[i] = arr[i - 1] + arr[i - 2];
}
return arr;
}
public static int search(int[] arr, int key) {
int low = 0;
int high = arr.length - 1;
//表示斐波那契数分割数的下标值
int index = 0;
int mid = 0;
//调用斐波那契数列
int[] f = getFeiBo();
//获取斐波那契分割数值的下标
while (high > (f[index] - 1)) {
index++;
}
//因为f[k]值可能大于a的长度，因此需要使用Arrays工具类，构造一个新法数组，并指向temp[],不足的部分会使用0补齐
int[] temp = Arrays.copyOf(arr, f[index]);
//实际需要使用arr数组的最后一个数来填充不足的部分
for (int i = high + 1; i < temp.length; i++) {
temp[i] = arr[high];
}
//使用while循环处理，找到key值
while (low <= high) {
mid = low + f[index - 1] - 1;
if (key < temp[mid]) {//向数组的前面部分进行查找
high = mid - 1;
/*
对k--进行理解
1.全部元素=前面的元素+后面的元素
2.f[k]=k[k-1]+f[k-2]
因为前面有k-1个元素没所以可以继续分为f[k-1]=f[k-2]+f[k-3]
即在f[k-1]的前面继续查找k--
即下次循环,mid=f[k-1-1]-1
*/
index--;
} else if (key > temp[mid]) {//向数组的后面的部分进行查找
low = mid + 1;
index -= 2;
} else {//找到了
//需要确定返回的是哪个下标
if (mid <= high) {
return mid;
} else {
return high;
}
}
}
return -1;
}
}
1.3分块查找
当数据表中的数据元素很多时，可以采用分块查找。
汲取了顺序查找和折半查找各自的优点，既有动态结构，又适于快速查找
分块适用于数据较多，但是数据不会发生变化的情况，如果需要一边添加一边查找，建议使用哈希查找
分块查找的过程：
需要把数据分成N多小块，块与块之间不能有数据重复的交集。
给每一块创建对象单独存储到数组当中
查找数据的时候，先在数组查，当前数据属于哪一块
再到这一块中顺序查找
核心思想： 块内无序，块间有序
代码示例：
public static void main(String[] args) {
/*
实现步骤：
1.创建数组blockArr存放每一个块对象的信息
2.先查找blockArr确定要查找的数据属于哪一块
3.再单独遍历这一块数据即可
*/
int[] arr = {16, 5, 9, 12,21, 18,
32, 23, 37, 26, 45, 34,
50, 48, 61, 52, 73, 66};
//创建三个块的对象
Block b1 = new Block(21,0,5);
Block b2 = new Block(45,6,11);
Block b3 = new Block(73,12,17);
//定义数组用来管理三个块的对象（索引表）
Block[] blockArr = {b1,b2,b3};
//定义一个变量用来记录要查找的元素
int number = 37;
//调用方法，传递索引表，数组，要查找的元素
int index = getIndex(blockArr,arr,number);
//打印一下
System.out.println(index);
}
//利用分块查找的原理，查询number的索引
private static int getIndex(Block[] blockArr, int[] arr, int number) {
//1.确定number是在那一块当中
int indexBlock = findIndexBlock(blockArr, number);
if(indexBlock == -1){
//表示number不在数组当中
return -1;
}
//2.获取这一块的起始索引和结束索引 --- 30
// Block b1 = new Block(21,0,5); ---- 0
// Block b2 = new Block(45,6,11); ---- 1
// Block b3 = new Block(73,12,17); ---- 2
int startIndex = blockArr[indexBlock].getStartIndex();
int endIndex = blockArr[indexBlock].getEndIndex();
//3.遍历
for (int i = startIndex; i <= endIndex; i++) {
if(arr[i] == number){
return i;
}
}
return -1;
}
//定义一个方法，用来确定number在哪一块当中
public static int findIndexBlock(Block[] blockArr,int number){ //100
//从0索引开始遍历blockArr，如果number小于max，那么就表示number是在这一块当中的
for (int i = 0; i < blockArr.length; i++) {
if(number <= blockArr[i].getMax()){
return i;
}
}
return -1;
}
}
class Block{
private int max;//最大值
private int startIndex;//起始索引
private int endIndex;//结束索引
//构造、getset、tostring方法
}1.4扩展分块（无规律分块）
6. 哈希查找
哈希查找是分块查找的进阶版，适用于数据一边添加一边查找的情况。
一般是数组 + 链表的结合体或者是数组+链表 + 红黑树的结合体
在课程中，为了让大家方便理解，所以规定：
数组的0索引处存储1~100
数组的1索引处存储101~200
数组的2索引处存储201~300
以此类推
但是实际上，我们一般不会采取这种方式，因为这种方式容易导致一块区域添加的元素过多，导致效率偏低。
更多的是先计算出当前数据的哈希值，用哈希值跟数组的长度进行计算，计算出应存入的位置，再挂在数组的后面形成链表，如果挂的元素太多而且数组长度过长，我们也会把链表转化为红黑树，进一步提高效率。
7. 树表查找
本知识点涉及到数据结构：树。
建议先看一下后面阿玮讲解的数据结构，再回头理解。
基本思想：二叉查找树是先对待查找的数据进行生成树，确保树的左分支的值小于右分支的值，然后在就行和每个节点的父节点比较大小，查找最适合的范围。 这个算法的查找效率很高，但是如果使用这种查找方法要首先创建树。
二叉查找树（BinarySearch Tree，也叫二叉搜索树，或称二叉排序树Binary Sort Tree），具有下列性质的二叉树：
1）若任意节点左子树上所有的数据，均小于本身；
2）若任意节点右子树上所有的数据，均大于本身；
二叉查找树性质：对二叉查找树进行中序遍历，即可得到有序的数列。
不同形态的二叉查找树如下图所示：
基于二叉查找树进行优化，进而可以得到其他的树表查找算法，如平衡树、红黑树等高效算法。
具体细节大家可以参见B站阿玮讲解课程：从入门到起飞。在集合章节详细讲解了树数据结构。全程采取动画形式讲解，让大家一目了然。
在此不多做阐述。
不管是二叉查找树，还是平衡二叉树，还是红黑树，查找的性能都比较高
十大排序算法
2.1 冒泡排序
核心思想：
1，相邻的元素两两比较，大的放右边，小的放左边。（升序）
2，第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推。
3，如果数组中有n个数据，总共我们只要执行n-1轮的代码就可以。
public static void main(String[] args) {
/*
冒泡排序：
核心思想：
1，相邻的元素两两比较，大的放右边，小的放左边。
2，第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推。
3，如果数组中有n个数据，总共我们只要执行n-1轮的代码就可以。
*/
//1.定义数组
int[] arr = {2, 4, 5, 3, 1};
//2.利用冒泡排序将数组中的数据变成 1 2 3 4 5
//外循环：表示我要执行多少轮。 如果有n个数据，那么执行n - 1 轮
for (int i = 0; i < arr.length - 1; i++) {
//内循环：每一轮中我如何比较数据并找到当前的最大值
//-1：为了防止索引越界
//-i：提高效率，每一轮执行的次数应该比上一轮少一次。
for (int j = 0; j < arr.length - 1 - i; j++) {
//i 依次表示数组中的每一个索引：0 1 2 3 4
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
printArr(arr);
}
private static void printArr(int[] arr) {
//3.遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}
2.2选择排序
public class A02_SelectionDemo {
public static void main(String[] args) {
/*
选择排序：
1，从0索引开始，跟后面的元素一一比较。
2，小的放前面，大的放后面。
3，第一次循环结束后，最小的数据已经确定。
4，第二次循环从1索引开始以此类推。
*/
//1.定义数组
int[] arr = {2, 4, 5, 3, 1};
//2.利用选择排序让数组变成 1 2 3 4 5
/* //第一轮：
//从0索引开始，跟后面的元素一一比较。
for (int i = 0 + 1; i < arr.length; i++) {
//拿着0索引跟后面的数据进行比较
if(arr[0] > arr[i]){
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
}
}*/
//最终代码：
//外循环：几轮
//i:表示这一轮中，我拿着哪个索引上的数据跟后面的数据进行比较并交换
for (int i = 0; i < arr.length -1; i++) {
//内循环：每一轮我要干什么事情？
//拿着i跟i后面的数据进行比较交换
for (int j = i + 1; j < arr.length; j++) {
if(arr[i] > arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
printArr(arr);
}
private static void printArr(int[] arr) {
//3.遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
}2.3插入排序
for (inti=0; i < arr.length -1; i++) {
//内循环：每一轮我要干什么事情？//拿着i跟i后面的数据进行比较交换for (intj= i + 1; j > 0; j--) {
if(arr[j-1] > arr[j]){
inttemp= arr[j-1];
arr[j-1] = arr[j];
arr[j] = temp;
}
}
上面是我自己想的插入排序 没有引入startIndex 相当于把整个数组都当成无序从头 插入排序
{
int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
//1.找到无序的哪一组数组是从哪个索引开始的。 2intstartIndex= -1;
for (inti=0; i < arr.length; i++) {
if(arr[i] > arr[i + 1]){
startIndex = i + 1;
break;
}
}
//2.遍历从startIndex开始到最后一个元素，依次得到无序的哪一组数据中的每一个元素for (inti= startIndex; i < arr.length; i++) {
//问题：如何把遍历到的数据，插入到前面有序的这一组当中//记录当前要插入数据的索引intj= i;
while(j > 0 && arr[j] < arr[j - 1]){
//交换位置inttemp= arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
j--;
}
}
//printArr(arr); 打印数组
}
2.4 快速排序！！！
一定要先移动end（就是把大数移到右边），后移动start；
否则 先找小数，会出现end start重合位置大于基准数，在交换位置就左边不全是小数了！
处理大数据最快的排序算法之一
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
/*
快速排序：
第一轮：以0索引的数字为基准数，确定基准数在数组中正确的位置。
比基准数小的全部在左边，比基准数大的全部在右边。
后面以此类推。
*/
int[] arr = {1,1, 6, 2, 7, 9, 3, 4, 5, 1,10, 8};
System.out.println(Arrays.toString(arr));
//课堂练习：
//我们可以利用相同的办法去测试一下，选择排序，冒泡排序以及插入排序运行的效率
//得到一个结论：快速排序真的非常快。
}
/*
* 参数一：我们要排序的数组
* 参数二：要排序数组的起始索引
* 参数三：要排序数组的结束索引
* */
public static void quickSort(int[] arr, int i, int j) {
//定义两个变量记录要查找的范围
int start = i;
int end = j;
if(start > end){
//递归的出口
return;
}
//记录基准数
int baseNumber = arr[i];
//利用循环找到要交换的数字
while(start != end){
//利用end，从后往前开始找，找比基准数小的数字
//int[] arr = {1, 6, 2, 7, 9, 3, 4, 5, 10, 8};
while(true){
if(end <= start || arr[end] < baseNumber){
break;
}
end--;
}
System.out.println(end);
//利用start，从前往后找，找比基准数大的数字
while(true){
if(end <= start || arr[start] > baseNumber){
break;
}
start++;
}
//把end和start指向的元素进行交换
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
//当start和end指向了同一个元素的时候，那么上面的循环就会结束
//表示已经找到了基准数在数组中应存入的位置
//基准数归位
//就是拿着这个范围中的第一个数字，跟start指向的元素进行交换
int temp = arr[i];
arr[i] = arr[start];
arr[start] = temp;
//确定6左边的范围，重复刚刚所做的事情
quickSort(arr,i,start - 1);
//确定6右边的范围，重复刚刚所做的事情
quickSort(arr,start + 1,j);
}
}贪心算法
【165-尚硅谷-图解Java数据结构和算法-贪心算法解决集合覆盖思路图解】https://www.bilibili.com/video/BV1LW4y1x7c9?vd_source=5475f4f6010a81c8e6d4789af8e1a20f
763. 划分字母区间
https://leetcode.cn/problems/partition-labels/solution/hua-fen-zi-mu-qu-jian-by-leetcode-solution/
class Solution {
public List<Integer> partitionLabels(String s) {
/*
*我的想法就是字符串划分 找每个字母lastPlace;第一个字母肯定是一段区域里面包含哪些字母，
这些字母last最大的，继续找；第一段区域的下一个字母，看包含关系
*/
int[] last=new int[26];
for(int i=0;i<s.length();i++){
last[s.charAt(i)-'a']=i;
}
ArrayList<Integer> list=new ArrayList<>();
int end=0,start=0;
int max=last[s.charAt(start)-'a'];
for(int i=start;i<=max;i++){
end=last[s.charAt(i)-'a'];
if(i<max){
max=(Math.max(end,max));
//System.out.println(max);
}
else{
list.add(max-start+1);
start=max+1;
if(start<s.length()) {
max=(int)last[s.charAt(start)-'a'];
//System.out.println(start+" "+max);
}
else {
break;
}
}
}
return list;
}
}class Solution {
public List<Integer> partitionLabels(String s) {
int[] last = new int[26];
int length = s.length();
for (int i = 0; i < length; i++) {
last[s.charAt(i) - 'a'] = i;
}
List<Integer> partition = new ArrayList<Integer>();
int start = 0, end = 0;
for (int i = 0; i < length; i++) {
end = Math.max(end, last[s.charAt(i) - 'a']);
if (i == end) {//好
partition.add(end - start + 1);
start = end + 1;
}
}
return partition;
}
}121. 买卖股票的最佳时机
class Solution {//自己写的暴力法超时了O(n²)
public int maxProfit(int[] prices) {
int len=prices.length;
int res=0;
for(int i=0;i<len;i++){
int start=prices[i];
int max=start;
for(int j=i;j<len;j++){
if(max<prices[j])
max=prices[j];
}
res=Math.max(max-start,res);
} // System.out.println(Arrays.toString(arr));
return res;
}
}
public class Solution {//O(n)
public int maxProfit(int prices[]) {
int minprice = Integer.MAX_VALUE;//int类型的最大值
int maxprofit = 0;
for (int i = 0; i < prices.length; i++) {
if (prices[i] < minprice) {//最低的购入价格
minprice = prices[i];
} else if (prices[i] - minprice > maxprofit) {//如果利润大于之前的就替换最大利润
maxprofit = prices[i] - minprice;
}
}
return maxprofit;
}
}55. 跳跃游戏
我最开始的想法是倒着推dp，没做出来 ；
//https://leetcode.cn/problems/jump-game/solution/shun-zhao-tui-dao-zhao-tui-liang-chong-fang-shi-ji/
public boolean canJump(int[] nums) {
if (nums == null || nums.length == 0) {
return false;
}
//pos表示需要到达的位置
int pos = nums.length - 1;
for (int i = nums.length - 2; i >= 0; i--) {
if (nums[i] + i >= pos) {
pos = i;//需要到达第i个位置才能跳完
}
}
return pos == 0;
}
class Solution {//参考这个思路做的 错了
public boolean canJump(int[] nums) {
int len=nums.length;
int max=0;
if(len==1||len==0)
return true;
for(int i=0;i<i+jump ;i++){
int jump=nums[i];
max=Math.max(i+jump,max);
if(max>=len-1)
return true;
}
return false;
} }其实我觉得他写的可读性不好，有点刻意缩减代码的嫌疑 这是他评论区的Java 跟我的差不多
就是for循环的条件写错了，确实是中间不应该放弃；
class Solution {
public boolean canJump(int[] nums) {
if (nums == null) {
return false;
}
int k = 0;//前n-1个元素能够跳到的最远距离
for (int i = 0; i <= k; i++) {
int temp = i + nums[i];//第i个元素能够跳到的最远距离
k = Math.max(k, temp);//更新最远距离
//如果最远距离已经大于或等于最后一个元素的下标,则说明能跳过去,退出. 减少循环
if (k >= nums.length - 1) {
return true;
}
}
//最远距离k不再改变,且没有到末尾元素
return false;
}
}倒着推更快
45. 跳跃游戏 II
class Solution {//倒着走 做的不对
public int jump(int[] nums) {
int len = nums.length;
int c=0;
int postion=len-1;
for(int i=postion;i>0;i--){
if(postion-i<=nums[i])//如果距离<数值 表示能跳到
{
postion=i;
c++;
break;
}
}
return c;
}
}{
if(nums.length == 1||num.length==0) return 0;
int postion = nums.length - 1, ans = 0;
while( postion > 0) {//倒着走到达起点退出循环
for(int j = 0; j < postion; j++) {//正序
if(j + nums[j] >= postion) {//能到达当前位置的话
postion = j;
ans++;
break;
}
}
}
return ans;}
