入门算法（面试经典问题）
1.快速排序(快排) 时间复杂度O(nlogn) 最坏时间复杂度O(n^2)
基本思想：
选择一个基准数作为参照物，由2边向中进行检索，先从右边检索比基准数小的，再从左边检索比基准数大的，然后交换2个元素，再进行检索！
package quicksortdemo;
public class Demo1QuickSort {
public static void main(String[] args) {
int[] array = new int[]{3,4,1,6,2};
forEach("未排好的：", array);
quickSort(array,0,array.length-1);
forEach("排好序的：", array);
}
/**
* @param arr 数组
* @param left 左边索引位置
* @param right 右边索引位置
*/
private static void quickSort(int[] arr, int left, int right) {
// 左边索引不能大于右边索引 否则直接return
if (left > right) {
return;
}
// 定义基准数 最左边下标的位置
int basic = arr[left];
// 定义指针指向最左边的数
int i = left;
//定义指针指向最右边的数
int j = right;
// 当i和j 不相遇的时候进行检索
while (i != j) {
//先由j从右往左检索比基准数小的，检索到了就停下
// 就是说 如果当前索引位置的元素值比基准数大或者等于 就继续检索
while (arr[j] >= basic && i < j) {
j--;
}
//i从左往右检索
while (arr[i] <= basic && i < j) {
i++;
}
// 然后i再从左往右检索比基准数大的 进行交换位置
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
// 如果跳出while 循环代表他们指针相遇 此时将 指针指向的元素赋值给基准数 再将基准数的元素赋值给
// 指针指向的元素
arr[left] = arr[i];
arr[i] = basic;
// 递归调用
quickSort(arr,left,i-1);
quickSort(arr,i+1,right);
}
private static void forEach(String start , int[] arr){
StringBuilder builder = new StringBuilder();
for(int i = 0 ;i<arr.length;i++){
builder.append(arr[i]+"\t");
}
System.out.println(start + " " + builder.toString());
}
}
2.冒泡排序法 时间复杂度O(n^2)
基本思想：
相邻的2个元素进行比较，小的往前大的往后，第一轮比较得出一个最小的，共比较数组的length-1轮
package quicksortdemo;
public class Demo2Sort {
public static void main(String[] args) {
int[] array = new int[]{4,5,3,1,2,};
sort(array);
forEach("排好序的：", array);
}
/**
* 比较的是4轮 每轮选出一个大的数字排到前面
* @param arr
*/
private static void sort(int[] arr){
// 轮
for(int i =1;i<arr.length;i++){
for(int j = 0;j< arr.length-i;j++){
// 如果前面的数字比后面的数字大 那么交换位置
if(arr[j] > arr[j+1]){
int temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
}
private static void forEach(String start , int[] arr){
StringBuilder builder = new StringBuilder();
for(int i = 0 ;i<arr.length;i++){
builder.append(arr[i]+"\t");
}
System.out.println(start + " " + builder.toString());
}
}
3.选择排序 时间复杂度O(n^2) 排序快于 冒泡排序
基本思想:
第一个元素和其他元素进行比较，小的排到前面，依次进行比较
package quicksortdemo;
public class Demo3Sort {
public static void main(String[] args) {
int[] array = new int[]{1,3,2,6,4};
sort(array);
forEach("排好序的：",array);
}
// 选择排序
private static void sort(int[] arr){
// 拿第一个元素和后面的元素进行比较 大的往前 降序排列
for (int i = 0; i < arr.length-1; i++) {
for(int j = i ; j<arr.length ; j++){
if(arr[i]>arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
private static void forEach(String start , int[] arr){
StringBuilder builder = new StringBuilder();
for(int i = 0 ;i<arr.length;i++){
builder.append(arr[i]+"\t");
}
System.out.println(start + " " + builder.toString());
}
}
4.归并排序 时间复杂度O(nlogn) 最坏时间复杂度 O(nlogn) 分而治之 核心递归加merage 合并
5.二分查找法
核心思想：
二分查找对半分，递归查找。
package quicksortdemo;
/**
* 二分查找对半分
*/
public class Demo4{
public static void main(String[] args) {
// 二分查找法必须是已经排好序的
int[] array = new int[]{1,2,3,5,6};
System.out.println(search(array,6,0,array.length-1));
}
/**
*
* @param arr 数组
* @param n 找哪个元素
* @param left 起始下标
* @param right 结束下标
*/
public static int search(int[] arr,int n , int left,int right){
if(left>right){
return -1;
}
int middle = (left+right)/2;
int value = arr[middle];
//如果值大于要找的数字
if(value>n){
// 去左边数组找
return search(arr,n,left,middle-1);
}else if(value < n ){
// 小于的话去右边数组找
return search(arr,n,middle+1,right);
}else {
// 刚好的时候是直接输出下标位置
return middle ;
}
}
}
来源：CSDN
作者：像风一般
链接：https://blog.csdn.net/weixin_44824330/article/details/103663128