基础算法（java）

已于 2022-05-07 21:07:26 修改
阅读量784 收藏
点赞数
分类专栏： 和y总约会❤️ 算法基础课 文章标签： 算法基础 java
于 2022-03-28 11:23:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45908682/article/details/123790955
版权

目录​​​​​​​

1.快速排序

2.归并排序

3.整数二分（两个模版）

4.浮点数二分模版

5.高精度计算​​​​​​​

1）加法

2）减法

3）乘法

4）除法

6.前缀和与差分

1）一维数组前缀和

2）二维前缀和

3）差分

4）差分矩阵

7.双指针算法

8.位运算

1）获取数字 n的二进制的第 k位是多少

2）lowBit

9.离散化

10.区间合并

1.快速排序

import java.util.*;

public class Main{
    private static int N = 100010;
    private static int[] q = new int[N];
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        for(int i = 0; i <n; i++){
            q[i] = scanner.nextInt();
        }
        int l = 0, r = n - 1;
        quicksort(q, l, r);
        for(int i = 0; i < n; i++){
            System.out.print(q[i] + " ");
        }
        
    }

    //快排模版
    public static void quicksort(int[] q, int l, int r){
        if (l >= r){
            return;
        }
        int x = q[l + r >> 1];
        int i = l - 1;
        int j = r + 1;
        
        while(i < j){
            do i ++; while (q[i] < x);//找到第一个大于等于x的数，不能取=，因为第一个数可能比后面所有数都大，必须交换第一个数
            do j --; while (q[j] > x);//找到第一个小于等于x的数，不能取=
            // 交换两个数，保证i左边数小于等于x，j右边数大于等于x
            if(i < j){
                int tmp = q[i];
                q[i] = q[j];
                q[j] = tmp;
            }
        }
        quicksort(q, l ,j); // j有可能小于i，所以取j
        quicksort(q, j + 1, r);
    }
}

2.归并排序

import java.util.*;

public class Main{
    private static int N = 100010;
    private static int[] q = new int[N];
    private static int[] tmp = new int[N];
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        for(int i = 0; i < n; i ++){
            q[i] = scan.nextInt();
        }
        int l = 0, r = n - 1;
        merge_sort(q, l, r);
        for(int i = 0; i < n; i++){
            System.out.print(q[i] + " ");
        }
    }

    //归并模版
    public static void merge_sort(int[] q, int l, int r){
        if(l >= r) return;
        int mid = l + r >> 1;
        merge_sort(q, l, mid);
        merge_sort(q, mid + 1, r);
        
        int i = l, j = mid + 1, id = 0;
        while(i <= mid && j <= r){
            if(q[i] <= q[j]) tmp[id ++] = q[i ++];
            else tmp[id ++] = q[j ++];
        }
        while(i <= mid) tmp[id ++] = q[i ++]; 
        while(j <= r) tmp[id ++] = q[j ++];
        for(i = l, id = 0; i <= r; i ++, id ++) q[i] = tmp[id];
    }
}

3.整数二分（两个模版）

// 区间[l, r]被划分成 [l, mid] 和 [mid+1, r]时使用
int bsearch_1(int l, int r) {
    while (l < r) {
        int mid = l + r >> 1;
        if (check[mid)  // check() 判断 mid是否满足性质
            r = mid; 
        else
            l = mid + 1;
    }
    return l;
}
// 区间[l, r]被划分成 [l, mid-1] 和 [mid, r]时使用
int bsearch_2(int l, int r) {
    while (l < r) {
        int mid = l + r + 1 >> 2;   // 注意
        if (check[mid)  // check() 判断 mid是否满足性质
            l = mid;
        else
            r = mid - 1;

    }
    return l;
}
import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int q = scan.nextInt();
        
        int arr[] = new int[n]; 
        for(int i = 0; i < n; i++){
            arr[i] = scan.nextInt();
        }
        
        while(q-- != 0){
            int target = scan.nextInt();
            int l = 0, r = n - 1;
            while(l < r){
                int mid = l + r >> 1;
                if(arr[mid] >= target) r = mid;
                else l = mid + 1;
            }
            if(arr[l] != target){
                System.out.println("-1 -1");
            }else{
                System.out.print(l + " ");
                int i = 0, j = n - 1;
                while(i < j){
                    int mid = i + j + 1 >>1;
                    if(arr[mid] <= target) i = mid;
                    else j = mid - 1;
                }
                System.out.println(j);
            }
            
        }
        
    }
        
}

4.浮点数二分模版


​​​​​​​​​​

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        double target = scan.nextDouble();
        
        double l = -10000, r = 10000;
        
        while(r - l > 1e-8){
            double mid = (l + r) / 2;
            if(mid * mid * mid >= target) r = mid;
            else l = mid;
        }
        
        System.out.println(String.format("%.6f", l));
    }
}


ps：模版
double bsearch(double l, double r) {
    const double eps = 1e-6;   // eps 表示精度，取决于题目对精度的要求, 一般比所求精度高 2
    while (r - l > eps) {
        double mid = (l + r) / 2;
        if (check(mid)) r = mid;
        else l = mid;
    }
    return l;
}

5.高精度计算​​​​​​​

1）加法

import java.util.*;
public class Main{

    public static String sum(List<Integer> a,List<Integer> b) {
        int[] c = new int[100010];
        int t = 0,i;
        for(i = 0;i < a.size() || i < b.size(); i ++) {
            if(i < a.size()) c[i] = t += a.get(i);
            if(i < b.size()) c[i] = t += b.get(i);
            c[i] = t % 10;
            t = t/10;
        }
        if(t > 0) c[i] = t;
        while(i >= 1 && c[i] == 0) i --;
        StringBuilder stb = new StringBuilder();
        for(int j = i; j >= 0; j --) {
            stb.append(c[j]);
        }
        return stb.toString();
    }

    public static void main (String[] args) {
        Scanner sc = new Scanner(System.in);
        String a = sc.nextLine();
        String b = sc.nextLine();
        List<Integer> A =new ArrayList<>(a.length());
        List<Integer> B =new ArrayList<>(b.length());
        for(int i = a.length() - 1;i >= 0;i --) {
            A.add(a.charAt(i) - '0');
        }
        for(int i = b.length() - 1;i >= 0;i --) {
            B.add(b.charAt(i) - '0');
        }

        System.out.print(sum(A,B));

    }
}

2）减法

import java.util.*;

public class Main {
	// 判断是否有 A >= B
    public static boolean cmp(List<Integer> A, List<Integer> B) {
        if (A.size() != B.size()) return A.size() > B.size();
        for (int i = A.size() - 1; i >= 0; i--) {
            if (A.get(i) != B.get(i)) return A.get(i) > B.get(i);
        }
        return true;
    }
    
    public static List<Integer> sub(List<Integer> A, List<Integer> B) {
        List<Integer> C = new ArrayList();
        
        int t = 0; // 差
        for (int i = 0; i < A.size(); i++) {
            t += A.get(i);
            if (i < B.size()) t -= B.get(i);
            C.add((t + 10) % 10); // t >= 0: t; t < 0 : t + 10(借位)
            if (t < 0) t = -1;
            else t = 0;
        }
        while(C.size() > 1 && C.get(C.size() - 1) == 0) C.remove(C.size() - 1); // 删除前导0
        
        return C;
    }
    
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String a = scan.nextLine();
        String b = scan.nextLine();
        
        List<Integer> A = new ArrayList(), B = new ArrayList();
        for (int i = a.length() - 1; i >= 0; i--) A.add(a.charAt(i) - '0');
        for (int i = b.length() - 1; i >= 0; i--) B.add(b.charAt(i) - '0');
        
        if (cmp(A, B)) {
            List<Integer> C = sub(A, B);
            for (int i = C.size() - 1; i >= 0; i--) System.out.print(C.get(i));
        }
        else {
            System.out.print("-");
            List<Integer> C = sub(B, A);
            for (int i = C.size() - 1; i >= 0; i--) System.out.print(C.get(i));
        }
    }
}

3）乘法

import java.util.*;

public class Main{
    
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        String a = scan.nextLine();
        int b = scan.nextInt();
        List<Integer> A = new ArrayList<>();
        for(int i = a.length() - 1; i >= 0; i--) A.add(a.charAt(i) - '0');
        List<Integer> C = sub(A, b);
        for(int i = C.size() - 1; i >= 0; i--) System.out.print(C.get(i));
    }
    
    public static List<Integer> sub(List<Integer> A, int b){
        int t = 0;
        for(int i = 0; i < A.size(); i++){
            t += A.get(i) * b;
            A.set(i, t % 10);
            t = t / 10;
        }
        if(t != 0) A.add(t);
        while(A.size() > 1 && A.get(A.size() - 1) == 0) A.remove(A.size() - 1);
        return A;
    }
    
}

4）除法

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        String a =scan.next();
        int b = scan.nextInt();
        int[] A = new int[a.length()];
        //除法不需要逆向输入
        for(int i = 0; i < a.length(); i ++){
            A[i] = a.charAt(i) - '0';
        }
        div(A, b);
    }
    
    public static void div(int[] a, int b){
        int i;
        int r = 0;
        int[] c = new int[a.length + 1];
        for(i = 0; i < a.length; i++){
            r = r * 10 + a[i];
            c[i] = r / b;
            r %= b;
        }
        int len = i;
        i = 0;
        while(c[i] == 0 && i < a.length - 1 ) i ++;  //去前导0;
        for(int j = i; j < len; j++){
            System.out.print(c[j]);
        }
        System.out.println();
        System.out.print(r);
    }
    
}

6.前缀和与差分

1）一维数组前缀和

 

        
// 求a[]数组的前缀和：
for(int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i - 1]; // 前缀和下标[1, n]，数组a下标[0, n - 1]
sum[l, r] = s[r] - s[l - 1] // 第l个数 到 第r个数 的和


import java.util.*;

public class Main {
    private static int N = 100010;  // 定义数组大小, 防止越界

    public static void main(String[] args) {
        // 初始化输入值
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[] arr = new int[N];
        // 注意这里是从 1开始的
        for (int i = 1; i <= n; i++)     
            arr[i] = in.nextInt();

        // s[i]代表 arr的前 i项和
        int s[] = new int[N];   
        s[0] = 0;   
        // 计算出 s[i]
        for (int i = 1; i <= n; i++)
            s[i] = s[i - 1] + arr[i];     // 注意运算方式

        // 循环输出
        while (m-- > 0) {
              int l = in.nextInt();
              int r = in.nextInt();
              System.out.println(s[r] - s[l - 1]);  // 关键
        }
    }
}

2）二维前缀和

import java.util.*;

 public class Main{
     
     public static void main(String[] args){
         Scanner scan = new Scanner(System.in);
         int n = scan.nextInt();
         int m = scan.nextInt();
         int q = scan.nextInt();
         
         int[][] arr = new int[n + 1][m + 1];
         for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                arr[i][j] = scan.nextInt();
             }
         }
         
         int[][] s = new int[n + 1][m + 1];
         for(int i = 1; i <= n; i++){
             for(int j = 1; j <= m; j++){
                 s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + arr[i][j];
             }
         }
         
         while(q -- > 0){
            int x1 = scan.nextInt();
            int y1 = scan.nextInt();
            int x2 = scan.nextInt();
            int y2 = scan.nextInt();
            
            System.out.println(s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1]);
         }
         
     }
     
 }
// 求a[][]数组左上角元素的和：
for (int i = 1; i <= n; i++)
	for (int j = 1; j <= m;j++) 
		s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i - 1][j - 1];
int x1, y1, x2, y2;
s[x2][y2] - s[x1 - 1][y2] - s[x1][y1 - 1] + s[x1 - 1][y1 - 1] // 矩形区域和

3）差分

差分就是前缀和的逆运算

import java.util.*;

public class Main{
    
    private static int N = 100010;
    
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();
        
        int[] a = new int[N];
        for(int i = 1; i <= n; i++) a[i] = scan.nextInt();
        
        int[] b = new int[N];
        for(int i = 1; i <= n; i++) b[i] = a[i] - a[i - 1];
        
        while(m -- > 0){
            int l = scan.nextInt();
            int r = scan.nextInt();
            int c = scan.nextInt();
            b[l] += c;
            b[r + 1] -= c;
        }
        
        for(int i = 1; i <= n; i++) b[i] += b[i - 1];
        for(int i = 1; i <= n; i++) System.out.print(b[i]+" ");
        
    }
    
}
//1：初始化差分数组b[]
        int[] b = new int[N];                               
        for(int i = 1 ; i <= n ; i++) b[i] = s[i] - s[i-1]; 
//2：在前缀和数组的[l,r]区间上加c 等价于 在差分数组上b[l] += c;b[r+1] -= c;
        b[l] += c;
        b[r + 1] -= c;
//3：把差分数组转化为为操作完后的前缀和数组

        for(int i = 1 ; i <= n ; i++) b[i] = b[i-1] + b[i];

4）差分矩阵

import java.util.*;

public class Main{
    
    private static int N = 1010;
    
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();
        int q = scan.nextInt();
        
        int[][] arr = new int[N][N];
        int[][] dif = new int[N][N];
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                arr[i][j] = scan.nextInt();
                insert(i, j, i, j, dif, arr[i][j]);
            }
        }
        
        while(q -- > 0){
            int x1 = scan.nextInt();
            int y1 = scan.nextInt();
            int x2 = scan.nextInt();
            int y2 = scan.nextInt();
            int t = scan.nextInt();
            insert(x1, y1, x2, y2, dif, t);
        }
        
        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                dif[i][j] = dif[i][j] + dif[i - 1][j] + dif[i][j - 1] - dif[i - 1][j - 1];
                System.out.print(dif[i][j] + " ");
            }
            System.out.println();
        }
        
        scan.close();
        
    }
    
    private static void insert(int x1, int y1, int x2, int y2, int[][] dif, int t){
        dif[x1][y1] += t;
        dif[x1][y2 + 1] -= t;
        dif[x2 + 1][y1] -= t;
        dif[x2 + 1][y2 + 1] += t;
    }
}

7.双指针算法

for (int i = 0, j = 0; i < n; i ++ )
{
    while (j < i && check(i, j)) j ++ ;

    // 具体问题的逻辑
}
常见问题分类：
    (1) 对于一个序列，用两个指针维护一段区间
    (2) 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作

 

 

import java.util.*;

public class Main{
    
    private static int N = 100010;
    private static int[] a = new int[N];
    private static int[] s = new int[N];
    
    public static void main(String[] args){
        int ans = 0;
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        for(int i = 0; i < n ;i ++){
            a[i] = scan.nextInt();
        }
        
        for(int i = 0,j = 0;i < n;i++){
            s[a[i]]++;
            while(s[a[i]] > 1){
                s[a[j]]--;
                j++;
            }
            ans = Math.max(ans, i - j + 1);
        }
        
        System.out.println(ans);
    }
}

8.位运算

1）获取数字 n的二进制的第 k位是多少

for (int i = n; i >= 0; i--) {
    System.out.print(x >> i & 1);
}
//先将二进制数向右移动 k位(此时 k位移动到了第一位), 操作: x >> i
//获取最后一位的值, 操作: 移动后的值 & 1
//两步和为一步操作: x >> i & 1

2）lowBit

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        while(n -- > 0){
            int tmp = scan.nextInt();
            int ans = 0;
            while(tmp != 0){
                tmp -= tmp & (-tmp);
                ans++;
            }
            System.out.print(ans + " ");
        }
    }
}


模版：int lowbit(int x){
    return x & -x;
    //-x = ~x + 1 //(x取反加1)
}

9.离散化

 

import java.util.*;

// 存储add中的x, c; query中的l, r
class Pair {
    int x, y;
    Pair(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        
        List<Pair> add = new ArrayList();   // 在x位置加c
        List<Pair> query = new ArrayList(); // 询问[l, r]区间和
        Set<Integer> set = new TreeSet();   // 涉及到的位置 x, l, r
        Map<Integer, Integer> map = new HashMap(); // 将位置映射到[1, n]
        
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();
        
        for (int i = 0; i < n; i++) {
            int x = scan.nextInt();
            int c = scan.nextInt();
            add.add(new Pair(x, c));    // 输入x, c
            set.add(x);                 // 坐标x加入有序set
        }
        for (int i = 0; i < m; i++) {
            int l = scan.nextInt();
            int r = scan.nextInt();
            query.add(new Pair(l, r));  // 输入l, r
            set.add(l);                 // 坐标l, r加入set
            set.add(r);
        }
        
        int index = 1;
        for (int x : set) {
            map.put(x, index++);    // 将坐标映射到[1, n]
        }
        
        int k = set.size();
        int[] nums = new int[k + 1];
        int[] sum = new int[k + 1];
        
        // 坐标x映射到index，给num[index]加上c
        for (int i = 0; i < n; i++) {
            Pair p = add.get(i);
            index = map.get(p.x);
            nums[index] += p.y;
        }
        
        // 求区间和
        for (int i = 1; i <= k; i++) {
            sum[i] = sum[i - 1] + nums[i];
        }
        
        // 将询问映射到[1, n]的坐标，求解区间和
        for (int i = 0; i < m; i++) {
            int l = query.get(i).x;
            int r = query.get(i).y;
            int ans = sum[map.get(r)] - sum[map.get(l) - 1];
            System.out.println(ans);
        }
    }
}

10.区间合并

​​​​​​​

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int[][] a = new int[n][2];
        for(int i = 0 ;i < n; i++){
            a[i][0] = scan.nextInt();
            a[i][1] = scan.nextInt();
        }
        
        Arrays.sort(a, new Comparator<int[]>(){
            public int compare(int[] o1, int[] o2){
                return o1[0] - o2[0];
            }
        });
        
        int res = 0;
        int r = Integer.MIN_VALUE;
        for(int i = 0; i < n; i++){
            if(r < a[i][0]){
                res ++;
            }
            r = Math.max(r, a[i][1]);
        }
        
        System.out.println(res);
    }
}

姐姐的半熟芝士
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
常用算法(java)
Nichole_sss进击之路
02-18 397
1. 排序 1. 冒泡排序（O(n2)） 把最大的沉到最后，两两交换 public void bubbleSort(int[] nums) { // 外层循环控制排序的轮数 for (int i = nums.length - 1 ; i > 0; i--) { boolean isSorted = true; // ...
Java基础算法
YuMi的博客
10-21 582
文章目录一、Java基础算法1.一共有20级楼梯，每次可以上1级或2级，登上第20级一共有多少种上法。2.生成随机验证码(5位数，有数字，有大写字母，小写字母.3.彩票算法4.求出10000以内素数的和5.任意一个整数,请输出其各个位数的和。6.请输入10000以内所有的完数.7.实现任意数量的实心菱形和固定数量的实心菱形 一、Java基础算法 1.一共有20级楼梯，每次可以上1级或2级，登上第20级一共有多少种上法。 package com.java.demoTest; public class Te
JAVA 基础算法汇总（持续更新）
dayu199804的博客
04-14 1万+
前言 做一些基础数据结构算法汇总，便于日后复习。 一、查找算法 1.顺序查找（线性查找） 依据数组的下标按顺序进行查找，然后返回数组下标。对于数据量较小的情况，比较适用。但是如果数据量较大，花费的时间就比较多。 2.二分查找 二分查找Binary Search 二分查找的使用，要有一个前提条件：要查找的数必须在一个有序数组里。在这个前提下，取中间位置数作为比较对象： 若要查找的值和中间数相等，则查找成功。 若小于中间数，则在中间位置的左半区继续查找。 若大于中间数，则在中间位置...
Java基础算法看这一篇就够了，简单全面一发入魂
热门推荐
学Java，找哪吒
05-18 1万+
一、算法 编写一段计算机程序一般都是实现一种已有的方法来解决某个问题。这种方法大多和使用的编程语言无关，它适用于各种计算机及编程语言。是这种方法而非计算机程序本身描述了解决问题的步骤。在计算机科学领域，我们用算法这个词来描述一种有限、确定、有效的并适合用计算机程序来实现的解决问题的方法。算法是计算机科学的基础，是这个领域的核心。 要定义一个算法，我们可以用自然语言描述解决某个问题的过程或是编写一点程序来实现这个过程。 大多数算法都需要适当地组织数据，而为了组织数据就产生了数据结构，数据结构也是计算机科学研究
Java最经典最基础十大算法《内含算法思想-算法步骤-程序实现》（你一定会用到
最新发布
2401_83947048的博客
04-01 970
还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。} else {// persons} else {} else {// safety} else {/**概率统计*/i++) {自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
java算法编程基础知识
m0_61696809的博客
02-23 1696
数组Java 中数组是一种存储固定数量元素的数据结构，它具有以下特点：数组长度是固定的，一旦创建，长度就不能再改变。数组可以存储任意类型的数据，包括基本类型和对象类型。数组中的元素是有序的，可以通过下标访问。Java 中提供了一系列方法来处理数组，包括以下常用方法：1、创建数组Java 中使用关键字new来创建数组，语法如下：数据类型[] 数组名=new数据类型[数组长度];
Java语言常用的算法
qq_45506362的博客
06-09 9555
分治算法是一种递归的算法思想，其基本思想是将一个大问题分解为若干个小问题，分别解决这些小问题，最后将小问题的解合并起来得到大问题的解。二分查找，也称为折半查找，它要求数据集合必须是有序的，它的基本思想是将数据集合分成两半，如果目标元素比中间元素小，就在前半部分继续查找，否则在后半部分继续查找，直到找到目标元素或数据集合为空。在实际应用中，分治算法也可以用来解决很多实际问题，比如在计算机图形学中，将一个大的图形对象分解成若干个小的三角形对象，每个小对象单独处理后再合并成一个大对象。
JAVA基础算法
qwerasdctds的博客
07-28 362
​ 数据结构是数据存储的方式，算法是数据计算的方式。所以在开发中，算法和数据结构息息相关。今天的讲义中会涉及部分数据结构的专业名词，如果各位铁粉有疑惑，可以先看一下哥们后面录制的数据结构，再回头看算法。
基础算法Java实现源码.zip
10-18
基础算法Java实现源码.zip基础算法Java实现源码.zip基础算法Java实现源码.zip基础算法Java实现源码.zip基础算法Java实现源码.zip基础算法Java实现源码.zip基础算法Java实现源码.zip
java基础算法
10-23
这里整理了齐全的代码 ,我是在开发的过程中积累的,很多是跟别人要的,希望能帮到系伙伴们.
algorithm-java:基础算法Java版本 --持续更更新中
05-17
基础算法Java版本 --持续更更新中 注重算法思想和算法的优化过程并有详细的注释 排序算法 简单排序 选择排序 插入排序 字典排序 复杂排序 归并排序 快速排序 双基准快速排序 三路快速排序 堆排序 索引堆排序（堆...
java基础算法训练
10-13
Java基础算法中部分试题的训练代码，有简单的语法训练，有稍微难的算法应用
基础算法-java韩信点兵
11-06
【基础算法】-java韩信点兵 public class HanXin { public static void main(String[] args) { int num=HanXin.peopleNum(1,1,5,4,10); System.out.println(num); num = HanXin.peoplrNum_For(1,1,5,4,10); ...
Java-基础（数据结构与算法篇）
weixin_59413946的博客
07-17 2962
数据结构（data structure）：数据在计算机中的存储与组织形式；其主要目的是为了对数据进行高效地访问和修改；数据结构包含数组、链表这样的线性数据结构，也包含树、图这样的复杂数据结构。算法（algorithm）：在特定的计算模型下，旨在解决特定问题的一系列指令。程序 = 数据结构 + 算法。
程序员必须知道的10大基础实用算法及其讲解
YesKing_new的专栏
06-17 760
算法一：快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法（Divide and conquer）策
java常见算法篇【完整版】
jsmeng626的博客
06-29 1758
java常见算法
面试中的排序算法总结
weixin_33722405的博客
03-05 2022
前言 　　查找和排序算法是算法的入门知识，其经典思想可以用于很多算法当中。因为其实现代码较短，应用较常见。所以在面试中经常会问到排序算法及其相关的问题。但万变不离其宗，只要熟悉了思想，灵活运用也不是难事。一般在面试中最常考的是快速排序和归并排序，并且经常有面试官要求现场写出这两种排序的代码。对这两种排序的代码一定要信手拈来才行。还有插入排序、冒泡排序、堆排序、基数排序、桶排序等。面试官对于这些排...
Java常用算法分类介绍与示例
算命de博客
05-11 1223
插入排序是一种简单直观的排序算法，它将数组分为已排序和未排序两部分，每次从未排序部分取一个元素插入到已排序部分的正确位置。归并排序是一种稳定的排序算法，它使用分治法策略，将数组分为两部分，递归地对两部分进行排序，然后将两部分合并成一个有序数组。冒泡排序是一种简单的排序算法，它依次比较相邻的元素，并交换它们的位置，使得最大（或最小）的元素逐渐“冒泡”到数组的末尾。堆排序是一种高效的排序算法，它使用堆数据结构维护元素的大小关系，将未排序部分中最大（或最小）的元素放到已排序部分的末尾。
10大基础算法 程序员你会吗？
Care0527的博客
10-15 626
算法一：快速排序算法 Python学习资料 https://mz.tanzhouedu.com/?s=d7632358e94455c7 Q群 784633899 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个项目要Ο(nlogn)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。 事实上，快速排序通常明显比其他Ο(nlogn)算法更快，因为它的内部循环（innerloop）可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法（Divideandcon
JAVA经典算法42例.doc
09-01
JAVA经典算法42例，都是很基础的编程题

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值