数据结构与算法基础

最新推荐文章于 2024-07-13 13:55:40 发布
最新推荐文章于 2024-07-13 13:55:40 发布
阅读量308 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bennettgxd/article/details/114666898
版权

算法学习

1、数据结构

存储数据的不同方式。

2、算法

同一问题的不同解决方法。（算法往往是针对特定数据结构的。）

算法的优劣

时间复杂度：随着问题规模的变化而时间变化的规律。
空间复杂度：随着问题规模的变化而空间变化的规律。

3、 Big O

时间-问题（数据）规模

  • 不考虑必须要做的操作
    循环、赋初值、程序初始化……
  • 不考虑常数项
  • 不考虑低次项

常见排序列表

序号中文名称英文名称平均时间复杂度最坏时间复杂度最好时间复杂度空间复杂度稳定性
1选择排序Selectionn2n2n21N
2冒泡排序Bubblen2n2n1Y
3*插入排序Insertionn2n2n1Y
4*堆排序Heapn log2nn log2nn log2n1N
5希尔排序Shelln1.3n2n1N
6*归并排序Mergen log2nn log2nn log2nnY
7*快速排序Quickn log2nn2n log2nlog2nN
8桶排序Buckeln + kn2nn + kY
9计数排序Countingn + kn + kn + kn + kY
10基数排序Radixn * kn * kn * kn + kY

(注意：Y：稳定，N：不稳定。)

在这里插入图片描述

如何编写算法程序

  1. 有简单到复杂
    验证一步走一步
    多打印中间结果
  2. 先局部后整体
    没思路时先细分
  3. 先粗糙后精细
    变量更名
    语句合并
    边界处理

简单排序

1、选择排序

package Tests;

public class Test1 {
/*
 * 选择排序
 * 
 * */
	public static void main(String[] args) {
		int[] arrays = { 4, 6, 7, 2, 8, 1, 9, 3, 5 };
//		排序前
		System.out.println("排序前：");
		for (int i = 0; i < arrays.length; i++) {
			System.out.print(arrays[i] + " ");
		}
//		long star = System.currentTimeMillis();
		for (int j = 0; j < arrays.length; j++) {
//		1、线找到最小值的下标
			int min = j;
			for (int i = j + 1; i < arrays.length; i++) {
				if (arrays[i] < arrays[min]) {
					min = i;
				}
			}
//		2、将最小值的下标与第一个元素进行交换位置
			int temp = arrays[j];
			arrays[j] = arrays[min];
			arrays[min] = temp;
		}
//		long end = System.currentTimeMillis();
		System.out.println("\n排序后：");
		for (int i = 0; i < arrays.length; i++) {
			System.out.print(arrays[i] + " ");
		}
//		System.out.println("\nusing time:" + (end - star));
	}

}

package com.gxd.dao;

public class SelectSort {
    public static void main(String[] args) {
        int[] arr = {2,4,6,8,9,5,3,1};
        sort(arr);
        System.out.println("***************");
        print(arr);
    }

    private static void print(int[] arr) {
        for (int i:arr) {
            System.out.print(i+",");
        }
        System.out.println();
    }

    private static void sort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            int min = i;
            for (int j = i+1; j < arr.length; j++) {
                min = arr[min] > arr[j] ? j : min;
            }
            int temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
            print(arr);
        }
    }
}

//运行结果：
1,4,6,8,9,5,3,2,
1,2,6,8,9,5,3,4,
1,2,3,8,9,5,6,4,
1,2,3,4,9,5,6,8,
1,2,3,4,5,9,6,8,
1,2,3,4,5,6,9,8,
1,2,3,4,5,6,8,9,
***************
1,2,3,4,5,6,8,9,

选择排序（实现list集合）

package com.bennett.test1014;

import java.util.LinkedList;
import java.util.List;

/**
 * 选择排序（实现list集合）
 * @author bennett
 *
 */
public class SelectSortByList {
	public static void main(String[] args) {
//		System.out.println("hello world!");
		List<Integer> integers = new LinkedList<Integer>();
		integers.add(4);
		integers.add(7);
		integers.add(3);
		integers.add(8);
		integers.add(2);
		integers.add(9);
		integers.add(1);
		print(integers);
		System.out.println();
		SelectSortByList(integers);
		print(integers);
	}

	private static void SelectSortByList(List<Integer> integers) {
		for (int i = 0; i < integers.size(); i++) {
			int min = i;
			for (int j = i+1; j < integers.size(); j++) {
				if (integers.get(j) < integers.get(min)) {
					min = j;
				}
			}
			int temp = integers.get(i);
			integers.set(i, integers.get(min));
			integers.set(min, temp);
		}
	}

	private static void print(List<Integer> integers) {
		for (Integer integer : integers) {
			System.out.print(integer+" ");
		}
	}
}

对算法的时间/空间复杂度进行分析

验证算法——对数器

DataChecker.java

package Tests;

import java.util.Arrays;
import java.util.Random;

public class DataChecker {
	/*
	 * 第一步：创建随机数组
	 */
	static int[] getByRandomToArrays() {
//		1、创建一个随机数的对象
		Random r = new Random();
//		2、创建数组
		int[] arr = new int[20];
//		3、向数组中添加数组元素
		for (int i = 0; i < arr.length; i++) {
			arr[i] = r.nextInt(20);
		}
		return arr;
	}
	/*
	 * 第二步：系统的比较器与你的比较算法进行比较
	 * 
	 */

	static void check() {
		int[] arr1 = getByRandomToArrays();
//		拷贝一份随机数组
		int[] arr2 = new int[arr1.length];
		System.arraycopy(arr1, 0, arr2, 0, arr1.length);

//		使用系统的比较器进行数组的排序
		Arrays.sort(arr1);
//		使用你的排序算法进行排序
		SelectSort.sort(arr2);
		/*
		 * 第三步：进行数组元素之间的比较
		 *
		 */
		Boolean b = true;
		for (int i = 0; i < arr2.length; i++) {
//			if (arr1[i] != arr2[i])
//				b = false;
			b = arr1[i] != arr2[i] ? false:true;
		}
		System.out.println(b == true ? "righr" : "wrong");
//		return b;
	}
	
//	main()方法测试
	public static void main(String[] args) {
		check();
	}

}

注意：最好是在check()进行多次的比较，对你写的算法就更加可靠。

SelectSort.java
自己定义的排序算法

package Tests;

public class SelectSort {
	
	public static int[] sort(int[] arr3) {
		for (int i = 0; i < arr3.length; i++) {
			int min = i;
			for (int j = i + 1; j < arr3.length; j++) {
				min = arr3[j] < arr3[min] ? j : min;
			}
			int temp = arr3[i];
			arr3[i] = arr3[min];
			arr3[min] = temp;
		}
		return arr3;
	}

}

2、冒泡排序

//	冒泡排序1 
	public static void bubbleSort(int arr[]) {

		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
	}

//	冒泡排序2 
	static void sort(int arr[]) {
		for (int i = arr.length - 1; i > 0; i--) {
			for (int j = 0; j < i; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j + 1];
					arr[j + 1] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}

3、插入排序

package bennett.sortingAlgorithm;

public class InsertionSort {
    public static void main(String[] args) {
        int[] arrays = {5,3,6,8,1,7,9,4,2};
        System.out.println("排序前");
        print(arrays);
        sort(arrays);
        System.out.println("\n排序后");
        print(arrays);
    }

    static void sort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {  //i最好从i=1开始，因为i=0时，内层循环不执行
            for (int j = i; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    swap(arr, j, j - 1);
                }
            }
 /*优化结构 
for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
                    swap(arr, j, j - 1);
            }
*/           
        }
    }
//问题:为什么arr.length时,排序后将会8变为4???
    static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void print(int[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]);
        }
    }
}

非简单排序

1、希尔排序

package bennett.sortingAlgorithm;

public class ShellSort {
    public static void main(String[] args) {
        int[] arrays = {9,6,11,3,5,12,8,7,10,15,14,4,1,13,2};
        System.out.println("排序前");
        print(arrays);
        sort(arrays);
        System.out.println("\n排序后");
        print(arrays);
    }

    static void sort(int[] arr) {
//        version 1.0
//        shift + ctrl + /如下注释  。ctrl + / 每一个都用“//”注释
        /*for(int gap = 4; gap > 0;gap /= 2){
            for (int i = gap; i < arr.length; i++) {
                for (int j = i; j > gap - 1; j-= gap) {
                    if (arr[j] < arr[j - gap]) {
                        swap(arr, j, j - gap);
                    }
                }
            }
        }*/
//        version 2.0
//        希尔最开时就是使用二分的办法来进行分组
        /*for(int gap = arr.length / 2; gap > 0;gap /= 2){
            for (int i = gap; i < arr.length; i++) {
                for (int j = i; j > gap - 1; j-= gap) {
                    if (arr[j] < arr[j - gap]) {
                        swap(arr, j, j - gap);
                    }
                }
            }
        }*/
//        version 3.0
//        Kunth序列
//        h = 1; h = 3*h +1;
        int h = 1;
        while(h <= arr.length / 3){
            h = 3*h + 1;
        }
        for(int gap = h; gap > 0;gap = (gap - 1)/3){
            for (int i = gap; i < arr.length; i++) {
                for (int j = i; j > gap - 1; j-= gap) {
                    if (arr[j] < arr[j - gap]) {
                        swap(arr, j, j - gap);
                    }
                }
            }
        }
    }
    //问题:为什么arr.length时,排序后将会8变为4???
    static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void print(int[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+",");
        }
    }
}

2、快速排序(Quick Sort)

package bennett.sortingAlgorithm;

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {7,3,2,8,1,9,5,4,6};
        System.out.println("排序前");
        print(arr);
        sort(arr,0,arr.length - 1);
        System.out.println("\n排序后");
        print(arr);
    }

    public static void sort(int[] arr, int leftBound, int rightBound) {
        if (leftBound >= rightBound) return;
        int mid = partition(arr,leftBound,rightBound);
        sort(arr,leftBound,mid - 1);
        sort(arr,mid + 1,rightBound);
    }
    static int partition(int[] arr, int leftBound, int rightBound){
        int pivot = arr[rightBound];
        int left = leftBound;
        int right = rightBound - 1;

        while (left <= right){
            while (left <= right && arr[left] <= pivot) left ++;
            while (left <= right && arr[right] > pivot) right --;

//            System.out.println("left = "+left+" ;right = "+right);
            if (left < right) swap(arr,left,right);
        }

        swap(arr,left,rightBound);
        return left;
    }
    static void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    static void print(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+",");
        }
    }
}

list集合进行快速排序

package com.bennett.test1013;

import java.util.ArrayList;
import java.util.List;

/**
 * @version:
 * @Description:对list集合进行快速排序
 * @author bennett
 * @date: 2021年10月13日 下午8:39:40
 */ 
public class QuickSortByList {
	public static void main(String[] args) {
		List<Integer> integers = new ArrayList<Integer>();
		integers.add(7);
		integers.add(3);
		integers.add(2);
		integers.add(8);
		integers.add(1);
		integers.add(9);
		integers.add(5);
		integers.add(4);
		integers.add(6);
		System.out.println("排序前");
		print(integers);
		sort(integers, 0, integers.size()-1);
		System.out.println("\n排序后");
		print(integers);
	}

	public static void sort(List<Integer> integers, int leftBound, int rightBound) {
		if (leftBound >= rightBound)
			return;
		int mid = partition(integers, leftBound, rightBound);
		sort(integers, leftBound, mid - 1);
		sort(integers, mid + 1, rightBound);
	}

	static int partition(List<Integer> integers, int leftBound, int rightBound) {
		int pivot = integers.get(rightBound);
		int left = leftBound;
		int right = rightBound - 1;

		while (left <= right) {
			while (left <= right && integers.get(left) <= pivot)
				left++;
			while (left <= right && integers.get(right) > pivot)
				right--;

			if (left < right)
				swap(integers, left, right);
		}

		swap(integers, left, rightBound);
		return left;
	}

	static void swap(List<Integer> integers, int i, int j) {
		int temp = integers.get(i);
		integers.set(i, integers.get(j));
		integers.set(j, temp);
	}

	static void print(List<Integer> integers) {
		for (Integer integer : integers) {
			System.out.print(integer+" ");
		}
	}
}

归并排序

package bennett.sortingAlgorithm;
//归并排序
public class MergeSort {
    public static void main(String[] args) {
//		1、数组初始化
        int[] arrays = {2,5,7,8,3,4,9};
        System.out.println("排序前");
        print(arrays);
        sort(arrays);
    }
    static void sort(int[] arr) {
        merge(arr);
    }
    static void merge(int[] arr){
        int mid = arr.length / 2;
        int[] temp = new int[arr.length];

        int i = 0;
        int j = mid + 1;
        int k = 0;
        while (i <= mid && j < arr.length){
            if (arr[i] <= arr[j]){
                temp[k] = arr[i];
                i++;
                k++;
            }else {
                temp[k] = arr[j];
                j++;
                k++;
            }
//            if...else...的优化
//            temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];  //代码优化
        }
        while (i <= mid) temp[k++] = arr[i++];
        while (j < arr.length) temp[k++] = arr[j++];
        System.out.println("\n排序后：");
        print(temp);
    }
    // 2、打印数组元素
    public static void print(int[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]);
        }
    }
}

归并排序（优化）

package bennett.sortingAlgorithm;
//归并排序（优化）
public class MergeSort {
    public static void main(String[] args) {
//        1、数组元素初始化
        int[] arrays = {2,5,7,8,3,4,9};
        System.out.println("排序前");
        print(arrays);
        sort(arrays,0,arrays.length - 1);
        System.out.println("排序后");
        print(arrays);
    }
//    3、排序
    public static void sort(int[] arr,int left,int right) {
        if (left == right) return;
        int mid = left + (right - left)/2;//分成两半
        sort(arr,left,mid);//左边排序
        sort(arr,mid+1,right);//右边排序
        merge(arr,left,mid+1,right);//归并排序
    }
//  4、归并排序
    public static void merge(int[] arr,int leftPtr,int rightPtr,int rightBound){
        int mid = rightPtr - 1;
        int[] temp = new int[rightBound - leftPtr + 1];
        int i = leftPtr;
        int j = rightPtr;
        int k = 0;
        while (i <= mid && j <= rightBound){
            temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];  //代码优化
        }
        while (i <= mid) temp[k++] = arr[i++];
        while (j <= rightBound) temp[k++] = arr[j++];
        for(int n = 0;n < temp.length;n++) arr[leftPtr+n] = temp[n];
    }
//  2、打印数组元素
    public static void print(int[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]);
        }
        System.out.println();
    }
}

4、创建算法介绍

回溯法（Backtracking）

n皇后问题描述为：在一个nxn的棋盘上摆放n个皇后，要求任意两个皇后不能冲突，即任意两个皇后不在同一行、同一列或者同一斜线上
算法的基本思想如下：
将第i个皇后摆放在第i行，i从1开始，每个皇后都从第1列开始尝试。尝试时判断在该列摆放皇后是否与前面的皇后有冲突，如果没有冲突，则在该列摆放皇后，并考虑摆放下一个皇后；如果有冲突，则考虑下一列。如果该行没有合适的位置，回溯到上一个皇后，考虑在原来位置的 个位置上继续尝试摆放皇后，……直到找到所有合理摆放方案。

下面是算法的Java语言实现。
(1)常量和变量说明
n：皇后数，棋盘规模为nxn
queen[]：皇后的摆放位置数组，queen[i]表示第i个皇后的位置，1<=queen[i]<=n

public class Backtracking {
    public static int n =4;    //皇后的数量
    public static int count = 0;  //统计n皇后问题的方案数
    public static int[] queen = new int[n + 1];
    public static void main(String[] args) {
        Nqueen(1);
        System.out.println(n+"皇后问题的解法总数："+count);
            }
//     1、
    public static void Nqueen(int j){
        int i;
        for (i = 1; i <= n; i++) {
            queen[j] = i;
            if (place(j)){
                if (j == n){   //如果所有皇后都摆放好，则输出当前的北方方案
                    show();
                    count++;
                }else{     //否则继续摆放下一个皇后
                    Nqueen(j + 1);
                }
            }
        }
    }
//    2、检查当前列是否可以放置皇后，不能返回false,可以摆放返回true
    public static boolean place(int j){
        int i;
        for (i = 1;i < j;i++){  //检查与已摆放的皇后是否在同一列或者同意斜线上
            if (queen[i]==queen[j]||Math.abs(queen[i] - queen[j]) == (j - i)){
                return false;
            }
        }
        return true;
    }
//    3、输出所有皇后摆放的方案
    public static void show(){
        int i;
        System.out.print("(");
        for (i = 1; i <= n; i++) {
            System.out.print(queen[i]);
        }
        System.out.print(")\n");

    }
}
Bennett_gxd
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
数据结构与算法必知基础知识
bigsai
01-06 1万+
原创公众号：bigsai 文章已收录在 全网都在关注的数据结构与算法学习仓库 欢迎star 前言 数据结构与算法是程序员内功体现的重要标准之一，且数据结构也应用在各个方面，业界更有程序=数据结构+算法这个等式存在。各个中间件开发者，架构师他们都在努力的优化中间件、项目结构以及算法提高运行效率和降低内存占用，在这里数据结构起到相当重要的作用。此外数据结构也蕴含一些面向对象的思想，故学好掌握数据结构对逻辑思维处理抽象能力有很大提升。 为什么学习数据结构与算法？如果你还是学生，那么这门课程是必修的，考研基本也.
数据结构与算法基础.txt
04-24
数据结构与算法基础
bennett机构角度推导
Alejandro123的博客
11-30 1512
Bennett机构转角关系推导 一、D-H坐标 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、bennett机构模型 满足条件： 3.推导 该处使用的url网络请求的数据。 总结 提示：这里对文章进行总结： 例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。 ...
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
【超全汇总】学习数据结构与算法，计算机基础知识，看这篇就够了
帅地
01-18 10万+
由于文章有点多，并且发的文章也不是一个系列一个系列发的，不过我的文章大部分都是围绕着 数据结构 + 算法 + 计算机网络 + 操作系统 + Linux + 数据库 这几个方面发的，为了方便大家阅读，我整理了一波。不过公众号可以说是不支持修改文章，因为我决定每两三个月就整理一次，会非常详细着按照类别整理出来哦，并且也给出了目录哦。大家记得多看看哦，好多文章都是面试中常问滴 文章目录一、经验/经历/所...
数据结构与算法之基础概述
努力让自己发光，对的人才能迎着光而来
08-15 1万+
数据结构和算法的重要性 数据结构概述 逻辑结构 存储结构 算法概述 如何理解“大O记法” 时间复杂度 空间复杂度
数据结构与算法基础1绪论
weixin_74889578的博客
02-01 2071
数据结构主要研究非数值计算中数据的逻辑结构、存储结构以及数据之间的关系,以便对数据进行运算和操作。
数据结构与算法基础-青岛大学-王卓
Java后端技术栈
12-13 2587
线性表循环链表。
数据结构与算法——知识点总结
记录知识，学习分享
06-02 2万+
本文包含数据结构与算法主要的基本知识点，便于知识的梳理和回顾。 如需详细了解具体知识点请自行结合课本或者网上查阅。 目录 1、概述 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 1、概述 从 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 ...
数据结构与算法基础（青岛大学-王卓）
weixin_47312141的博客
10-03 7347
数据结构与算法基础（青岛大学-王卓） 来源链接：点击查看bilibili数据结构与算法基础（青岛大学-王卓） 已整理完成 第一周 第01周a–前言 第01周b–1.1数据结构研究内容 第01周c–1.2基本概念和术语1 第01周d–1.2基本概念和术语2 第01周e–1.3抽象数据类型的表示与实现 第01周f–1.4算法与算法分析1 第01周g–1.4算法与算法分析2 第01周h–1.4算法与算法分析3 第01周i–1.4算法与算法分析4 第二周 第02周01–2.1线性表的定义和特点 第02周02–2.2
数据结构与算法基础（王卓）（38）：排序、全部PPT、笔记整理
Zz_zzzzzzz__的博客
05-10 1933
回头我把链接贴出来，感兴趣的朋友可以Mark一下，希望可以帮助到大家。对了，后续应该会把王卓老师所有的PPT附带笔记全部打包上传百度云。还有，大家免费上传，CSDN你还想收钱，未免太不够意思了。首先，庆祝本系列完结撒花！
数据结构与算法基础知识总结.pdf
07-14
数据结构与算法是计算机科学的基础，对于理解和优化程序性能至关重要。算法是解决问题的精确步骤描述，它不等同于程序，但程序的高效实现离不开良好的算法设计。算法必须具备可行性、确定性、有穷性和足够的信息，即...
数据结构与算法基础专栏.zip
01-01
数据结构与算法基础是计算机科学的核心领域，它们是解决问题和设计高效程序的基石。数据结构主要研究如何在计算机中组织和存储数据，以便能够高效地访问和修改这些数据。算法则是解决问题的步骤或方法，它定义了数据...
数据结构与算法基础.pdf
03-14
王卓老师数据结构与算法基础笔记
DataStructure-Algorithmics:数据结构与算法基础（青岛大学-王卓）
04-12
数据结构与算法基础是计算机科学的核心课程之一，它关乎如何高效地存储、组织和操作数据。这门课程，由青岛大学的王卓教授讲授，旨在深入理解和掌握这些关键概念，为日后的软件开发和问题解决奠定坚实的基础。 在...
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 318
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
配置Java开发环境
Broken_x的博客
07-10 1467
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 364
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 431
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
算法与数据结构课件PPT第一章
07-16
在计算机科学中，算法与数据结构是不可或缺的基础，它们构成了程序设计的核心。数据结构是研究数据的组织方式，它关注如何在计算机中有效地存储和访问数据。算法则是解决问题的步骤描述，通常由一系列指令组成，用于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值