常见算法
查找算法
1.基本查找
将数据放在一个数组或者集合中进行基本数据遍历查找
2.二分查找/折半查找
前提条件：数组中的数据必须是有序的
核心逻辑：每次排除一半的查找范围
优点：提高查找效率
基本思想：也称为是折半查找，属于有序查找算法。用给定值先与中间结点比较。比较完之后有三种情况：
-
相等
说明找到了
-
要查找的数据比中间节点小
说明要查找的数字在中间节点左边
-
要查找的数据比中间节点大
说明要查找的数字在中间节点右边
代码示例：
package com.itheima.search; public class A02_BinarySearchDemo1 { public static void main(String[] args) { //二分查找/折半查找 //核心： //每次排除一半的查找范围 //需求：定义一个方法利用二分查找，查询某个元素在数组中的索引 //数据如下：{7, 23, 79, 81, 103, 127, 131, 147} int[] arr = {7, 23, 79, 81, 103, 127, 131, 147}; System.out.println(binarySearch(arr, 150)); } public static int binarySearch(int[] arr, int number){ //1.定义两个变量记录要查找的范围 int min = 0; int max = arr.length - 1; //2.利用循环不断的去找要查找的数据 while(true){ if(min > max){ return -1; } //3.找到min和max的中间位置 int mid = (min + max) / 2; //4.拿着mid指向的元素跟要查找的元素进行比较 if(arr[mid] > number){ //4.1 number在mid的左边 //min不变，max = mid - 1； max = mid - 1; }else if(arr[mid] < number){ //4.2 number在mid的右边 //max不变，min = mid + 1; min = mid + 1; }else{ //4.3 number跟mid指向的元素一样 //找到了 return mid; } } } }
3.分块查找
mid = min + 黄金分割点左半边长度 - 1
原则：前一块中的最大数据，小于后一块中的所有的数据（块内无序，块间有序）
块数量一般等于数字的个数开根号（16个数据 分为4组）
核心思路：先确定要查找的元素在那一块，然后再块内逐个查找
4.插值查找
前提条件：数列分部均匀（等差数列）
mid=low+(key-a[low])/(a[high]-a[low])*(high-low)，
这样，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。
基本思想：基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。当然，差值查找也属于有序查找。
**细节：**对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。
代码跟二分查找类似，只要修改一下mid的计算方式即可。
5.斐波那契查找
6.树表查找
7.哈希查找
排序
冒泡排序
将相邻的数据两两比较，小的放前面，大的放后面，外循环（length-1）次
public class BubbleDemo {
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();
}
}
选择排序
从0索引开始，拿着每一个索引上的元素跟后面的元素一次比较，小的放前面，大的放后面，外循环（length-1）次
public class 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();
}
}
插入排序
将0索引的元素到N索引看作是有序的，把N+1索引的元素到最后一个当成是无序的。遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。
package com.itheima.mysort;
public class InsertDemo {
public static void main(String[] args) {
/*
插入排序：
将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个当成是无序的。
遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。
N的范围：0~最大索引
*/
int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
//1.找到无序的哪一组数组是从哪个索引开始的。 2
int startIndex = -1;
for (int i = 0; i < arr.length; i++) {
if(arr[i] > arr[i + 1]){
startIndex = i + 1;
break;
}
}
//2.遍历从startIndex开始到最后一个元素，依次得到无序的哪一组数据中的每一个元素
for (int i = startIndex; i < arr.length; i++) {
//问题：如何把遍历到的数据，插入到前面有序的这一组当中
//记录当前要插入数据的索引
int j = i;
while(j > 0 && arr[j] < arr[j - 1]){
//交换位置
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
j--;
}
}
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();
}
}
快速排序
递归算法
递归算法：方法中调用方法本身，递归一定要有出后，否则就会出现内存溢出
应用场景：把一个复杂的问题层层转化为一个与原来问题相似的规模较小的问题来求解
递归策略秩序少量的程序就可以描述出解题过程所需要的多次重复计算
Eg：使用递归求1~100的和
public static int getSum(int number){
if(number == 1){
return 1;
}
return number + getSum(number - 1)
}
快速排序
第一轮：把0索引的数字作为基准数，确定基准数在数组中正确的位置。比基准数小的全部在左边，比基准数大的全部在右边。
package com.itheima.mysort;
import java.util.Arrays;
public class A05_QuickSortDemo {
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};
//int[] arr = new int[1000000];
/* Random r = new Random();
for (int i = 0; i < arr.length; i++) {
arr[i] = r.nextInt();
}*/
long start = System.currentTimeMillis();
quickSort(arr, 0, arr.length - 1);
long end = System.currentTimeMillis();
System.out.println(end - start);//149
System.out.println(Arrays.toString(arr));
//课堂练习：
//我们可以利用相同的办法去测试一下，选择排序，冒泡排序以及插入排序运行的效率
//得到一个结论：快速排序真的非常快。
/* for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}*/
}
/*
* 参数一：我们要排序的数组
* 参数二：要排序数组的起始索引
* 参数三：要排序数组的结束索引
* */
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);
}
}
先移动end,后移动start
希尔排序
堆排序
桶排序
归并排序
计数排序
基数排序
Arrays
public static
Arrays.toString（arr []）;//把数组拼接春耕一个字符串
Arrays.binarySearch（arr[] , 查找的元素）；//二分查找法查找元素；注：数组中的元素必须是升 序的；元素若不存在，返回的是（-插入点-1）为了避免查询0而不存在0时的bug，所以-1
Arrays.copyOf(原数组，新数组长度)；//拷贝数组；新数组长度小于老数组长度：部分拷贝； 新等于老：完全拷贝；新大于老：会补上默认初始值
Arrays.copyOfRange(原数组，起始索引，结束索引); //拷贝数组（指定范围）；拷贝时：包头不包 尾，包左不包右
Arrays.fill(数组，元素);//填充数组
Arrays.sort(数组);//按照默认方式进行数组排序，给基本数据类型进行升序排序
Arrays.sort(数组，排序规则)；//按照指定的规则排序（插入+二分查找）
排序规则： 升序排列 o1-o2
降序排列 o2-o1
查找的元素）；//二分查找法查找元素；注：数组中的元素必须是升 序的；元素若不存在，返回的是（-插入点-1）为了避免查询0而不存在0时的bug，所以-1
Arrays.copyOf(原数组，新数组长度)；//拷贝数组；新数组长度小于老数组长度：部分拷贝； 新等于老：完全拷贝；新大于老：会补上默认初始值
Arrays.copyOfRange(原数组，起始索引，结束索引); //拷贝数组（指定范围）；拷贝时：包头不包 尾，包左不包右
Arrays.fill(数组，元素);//填充数组
Arrays.sort(数组);//按照默认方式进行数组排序，给基本数据类型进行升序排序
Arrays.sort(数组，排序规则)；//按照指定的规则排序（插入+二分查找）
排序规则： 升序排列 o1-o2
降序排列 o2-o1
扫一扫
4184
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
