Java数据结构和算法笔记

合集下载

Java数据结构和算法

Java数据结构和算法一、数组于简单排序 (1)二、栈与队列 (4)三、链表 (7)四、递归 (22)五、哈希表 (25)六、高级排序 (25)七、二叉树 (25)八、红—黑树 (26)九、堆 (36)十、带权图 (39)一、数组于简单排序数组数组（array）是相同类型变量的集合，可以使用共同的名字引用它。

数组可被定义为任何类型，可以是一维或多维。

数组中的一个特别要素是通过下标来访问它。

数组提供了一种将有联系的信息分组的便利方法。

一维数组一维数组（one-dimensional array ）实质上是相同类型变量列表。

要创建一个数组，你必须首先定义数组变量所需的类型。

通用的一维数组的声明格式是：type var-name[ ];获得一个数组需要2步。

第一步，你必须定义变量所需的类型。

第二步，你必须使用运算符new来为数组所要存储的数据分配内存，并把它们分配给数组变量。

这样Java 中的数组被动态地分配。

如果动态分配的概念对你陌生，别担心，它将在本书的后面详细讨论。

数组的初始化（array initializer ）就是包括在花括号之内用逗号分开的表达式的列表。

逗号分开了数组元素的值。

Java 会自动地分配一个足够大的空间来保存你指定的初始化元素的个数，而不必使用运算符new。

Java 严格地检查以保证你不会意外地去存储或引用在数组范围以外的值。

Java 的运行系统会检查以确保所有的数组下标都在正确的范围以内（在这方面，Java 与C/C++ 从根本上不同，C/C++ 不提供运行边界检查）。

多维数组在Java 中，多维数组（multidimensional arrays ）实际上是数组的数组。

你可能期望，这些数组形式上和行动上和一般的多维数组一样。

然而，你将看到，有一些微妙的差别。

定义多维数组变量要将每个维数放在它们各自的方括号中。

例如，下面语句定义了一个名为twoD 的二维数组变量。

int twoD[][] = new int[4][5];简单排序简单排序中包括了：冒泡排序、选择排序、插入排序；1.冒泡排序的思想：假设有N个数据需要排序，则从第0个数开始，依次比较第0和第1个数据，如果第0个大于第1个则两者交换，否则什么动作都不做，继续比较第1个第2个…，这样依次类推，直至所有数据都“冒泡”到数据顶上。

数据结构与算法知识点必备

数据结构与算法知识点必备在计算机科学的广袤领域中，数据结构与算法犹如基石般重要。

它们不仅是解决各种复杂问题的关键工具，更是提升程序性能和效率的核心所在。

首先，我们来谈谈数据结构。

数据结构是一种组织和存储数据的方式，以便于对数据进行高效的操作和访问。

常见的数据结构包括数组、链表、栈、队列、树和图等。

数组是一种最简单的数据结构，它将元素按照顺序依次存储在连续的内存空间中。

数组的优点是访问元素的时间复杂度为 O(1)，即可以在常数时间内获取任意位置的元素。

但其缺点也很明显，插入和删除元素的操作可能需要移动大量元素，时间复杂度较高。

链表则与数组不同，它的元素通过指针链接在一起，内存空间不一定连续。

链表在插入和删除元素时非常方便，只需修改指针即可，时间复杂度为 O(1)。

但访问特定位置的元素需要从头开始遍历，时间复杂度为 O(n)。

栈是一种具有特殊操作规则的数据结构，遵循“后进先出”的原则。

就像一叠盘子，最后放上去的盘子最先被拿走。

栈常用于函数调用、表达式求值等场景。

队列则是遵循“先进先出”原则的数据结构，类似于排队买票，先到的人先得到服务。

队列常用于任务调度、消息传递等。

接下来聊聊树这种数据结构。

二叉树是树结构中最常见的一种。

二叉搜索树中，左子树的节点值小于根节点，右子树的节点值大于根节点。

这使得查找、插入和删除操作的平均时间复杂度为 O(log n)，效率较高。

平衡二叉树则是对二叉搜索树的优化，通过自动调整保持树的平衡，进一步提高操作效率。

图是一种更为复杂的数据结构，用于表示对象之间的关系。

图可以分为有向图和无向图。

图的遍历算法包括深度优先搜索和广度优先搜索，常用于网络路由、社交网络分析等领域。

再来说说算法。

算法是解决特定问题的一系列明确步骤。

常见的算法有排序算法、搜索算法、动态规划等。

排序算法用于将一组数据按照特定顺序排列。

冒泡排序是一种简单但效率较低的排序算法，通过反复比较相邻元素并交换位置来排序。

java思维导图笔记

Java思维导图笔记1. 什么是思维导图思维导图是一种用于展示思维和概念之间关系的图形工具。

它能够帮助我们整理、组织和表达思维。

在学习和思考过程中，使用思维导图可以更清晰地将复杂的信息归类和记录，提高信息的理解和记忆。

2. Java基本语法2.1 数据类型Java提供了一系列的数据类型，包括基本数据类型（如整数、浮点数、字符、布尔值）和引用数据类型（如类、接口、数组等）。

常见的基本数据类型有： - 整数类型：byte、short、int、long- 浮点数类型：float、double - 字符类型：char - 布尔类型：boolean引用数据类型： - 类（class）：是面向对象编程中的基本概念，用来封装数据和方法。

- 接口（interface)：是一种抽象的数据类型，用来定义类的行为规范。

- 数组（array)：用来存储一组相同类型的元素。

2.2 控制流程语句控制流程语句用于控制程序的执行流程。

Java提供了三种主要的控制流程语句：顺序结构、选择结构和循环结构。

顺序结构是最简单的控制流程，指按照代码的先后顺序执行。

选择结构用于根据条件选择不同的执行路径。

常见的选择语句有：- if语句：用于根据一个条件判断选择是否执行某个代码块。

- switch语句：用于根据一个表达式的值选择执行不同的代码块。

循环结构用于重复执行某个代码块直到满足退出条件。

常见的循环语句有： - while语句：在循环开始之前，先判断条件是否满足，如果满足则执行循环体，然后再次判断条件。

- do-while语句：先执行一次循环体，然后再判断条件是否满足，如果满足则继续执行循环体。

- for语句：在循环开始之前，先执行初始化表达式，然后判断条件是否满足，如果满足则执行循环体，并在每次循环结束后执行更新表达式。

2.3 方法方法是一种可重复使用的代码块，用于执行特定的任务。

在Java 中，每个方法都有名称和参数列表，有时也有返回值。

第一章-Java基础笔记

第⼀章-Java基础笔记Java语⾔的概述Java是⼀门⾯向对象的语⾔,Java相对于C语⾔来说学习相对简单,它主要的三⼤特点就是:封装、继承、多态,并且只需要进⾏⼀次源码编译,在任何装有对应版本的JVM 虚拟机环境的计算机下运⾏;Java的三个版本JavaSE主要⽤于桌⾯应⽤的开发JavaME主要⽤于嵌⼊式系统的开发JavaEE主要⽤于企业级的WEB端开发和服务器开发Java环境介绍JDK - 提供了开发者的⼀些⼯具包,并包含了[JRE和JVM]JRE - Java的运⾏环境,提供了运⾏时需要的类库,并包含了[JVM]JVM - Java的虚拟⼀块内存区域,⽤于执⾏Java的代码Java跨平台交互图Java代码的运⾏机制后缀点java的⽂件会通过 javac命令进⾏⽂件的编译成⼀个能够被JVM读懂的字节码⽂件,通过加载、校验、初始化的过程都内存中，通过JVM寄存器读取⽂件中的⾏号，进⾏执⾏相关代码；注释注释是为了在编写程序时对某个类、⽅法或是⼀段代码进⾏功能作⽤的说明，它不会被编译成代码执⾏，只是起到⼀个描述作⽤，便于对代码的理解；Java中的注释分为3种：单⾏注释：//多⾏注释：/* */⽂档注释：/** */对注解的内容⽣成JavaDoc⽂档DOS命令进⼊到要⽣成Doc⽂档的层级⽬录,执⾏:javadoc -encoding UTF-8 -charset UTF-8 ⽂件名称/*** @Author JavaCat7* @Description 这是⼀个⽂档注释*/public class Demo{/*** @Parameter args 对参数的描述* @Description 这是⼀个⽂档注释*/public static void main(String[] args){//这是⼀个单⾏注释System.out.println("Hello Java");/*这是多⾏注释这是多⾏注释*/}}标识符每个⼈都有名字,⽽标识符是为了给代码中的类、接⼝、⽅法、变量取⼀个名字，但它们的明⽩是有着严格规范的；规范：每个⼈都有名字,⽽标识符是为了给代码中的类、接⼝、⽅法、变量取⼀个名字，但它们的明⽩是有着严格规范的；**规范：**1.严格区分⼤⼩写；2.开头可以是$ 或 _ 或 A-Z a-z的字母组成,也可以汉字(不会这么⼲);3.可以由数字、字母或者是 $ 或 _ 组成，但数字不能⽤于开始；4.不可以包含特殊字符；5.不能以Java语⾔中的保留字作为命名；6.类名采取⼤驼峰命名法;7.⽅法和变量采取⼩驼峰命名法;8.常量采取⼤学加_进⾏命名;基本数据类型Java是强类型计算机语⾔,所有的变量必须先定义才能使⽤,对于强类型⽽⾔主要就是指的数据安全,强类型的语⾔有很多,⽐如C、C++、python...计算机存储单位换算bit(位) - 是计算内部数据存储的最⼩单元,通过8个⼆进制位进⾏表⽰;byte(字节) - 是计算机中数据处理的基本单位,通常使⽤B来表⽰;8个bit(位) = 1B(字节)1024个B(字节) = 1KB1024个KB = 1MB1024个MB = 1GB....//整数类型byte a = 1;short b = 2;int c = 3;long d = 4L;//⼩数类型float e = 5.0f;duble f = 6.0d;//字符类型char g = 'a';//布尔类型boolean h = true;boolean i = false;数据类型的转换各数值相关数据类型⽀持类型上的转换,既可以把排序级别较低的类型转换成排序级别较⼤的类型,也可以把排序级别较⾼的类型转换成级别较低的类型(但会造成数据的丢失);数据的转换强制类型转换 - 在要转换的变量前使⽤:要转换的对应数据类型如- (int)⾃动类型转换 - 在不同的数值数据类型运算中,它会以排序级别较⾼的数据类型作为基础⾃动转换int number1 = 128;//正常byte的值是 -128 - 127,强制把int类型转换成byte会造成数据的不精确byte number2 = (byte)number1;int number3 = 519;float number4 = 1.0f;//在运算过程中因为float的排序级别⽐int⾼,那么它会⾃动转换成float类型在完成运算float number5 = number3 + number4;变量,静态变量,常量及作⽤域变量是指可以变化的值,通过数据类型和变量名可以在内存中申请⼀块存储的空间,通过内存的引⽤地址可以设置改变内存中存储的值或者修改值,所有的变量必须先赋值才可以使⽤;成员变量成员变量是指在类中与⽅法同级的位置中定义的成员变量,在该位置定义的变量可以不⽤设置值就可以使⽤,因为它会对类进⾏初始化,并完成初始化赋值,就算不给他们赋值也会有默认的初始值,他们的默认初始值都是最⼩的单元;作⽤域成员位置的变量,可以在⾮静态⽅法的所有位置使⽤,如果要在静态⽅法中使⽤,需要先创建对象;public class Variable{int a; //默认为:0float b; //默认为:0.0char c; //默认为:''boolean d; //默认为:false}局部变量局部变量是指在⽅法内部定义的变量,必须要先完成初始化后,才可以被使⽤;作⽤域局部位置的变量,外部⽆法使⽤,只能在⽅法内部使⽤,可以和外部的变量名称相同;public class Variable{int number;public void method(){int number = 3;//可以和成员位置的变量名称相同}}静态变量静态变量是指被static关键字修饰的变量,被修饰的变量⼜称为类变量;作⽤域静态变量可以作⽤域与所有⽅法中,静态变量只能定义在类的成员位置;public class Variable{static int number ;public static void main(String[] arags){System.out.println(number);}public void method(){System.out.println(numbe);}}常量常量是指不能被改变的值,它在创建到成员位置必须要先完成赋值,⼀旦被创建它的值是不允许被更改的;作⽤域它的作⽤域和成员变量相同public class Variable{final int NUMBER = 3.1415926;}静态常量静态常量是指从属于类的常量,在完成初始化以后是不可以被修改的,并且被public所进⾏修饰;作⽤域它的作⽤域和静态变量相同运算符算术运算符int a = 5;int b = 2;int number = a + b; //number = 7;int number = b - a; //number = 3;int number = a * b; //number = 10;int number = a / b; //number = 2,只取整数;double number = a / (double)b; //number = 2.5int number = a % b; //number = 1;⾃增⾃减运算符int a = 1;int b;b = a++; //b = 1; 先把a的值赋值给b,后a进⾏ +1 操作;b = a--; //b = 2; a前⾯进⾏了⾃增那么就是2,先把2赋值给b,然后进⾏ -1 操作;b = ++a; //b = 2; 前⾯a进⾏了⾃减那么就是1,先对a进⾏⾃增加1,然后在赋值给b;b = --a; //b = 1; 前⾯a是2,先对a进⾏⾃减1,在赋值给b;赋值运算符int a = 5;//把 5 赋值给 a;int b = 2;//把 2 赋值给 b;a += b; // a = 7(a+b的结果在赋值给a);a -= b; // a = 3;a *= b; // a = 10;a /= b; // a = 2;a %= b; // a = 1;关系运算符int a = 5;int b = 2;a > b; //truea < b; //falsea >= b; //falsea <= b; //truea == b; //falsea != b; //true逻辑运算符boolean a = true;boolean b = false;a &&b = false;//都true则true,第⼀个条件为false就不会在看第⼆个条件,直接返回falsea ||b = true;//⼀个条件为true则true,第⼀个条件为tre就不看第⼆个条件,直接返回true! a = false;//取反a &b = false;//2个条件都要执⾏a |b = true;三元运算符int a = 5;int b = 5;a ==b ? "等于":"不等于"; //为true返回第⼀个,为false返回第⼆个流程控制语句If语句if语句就是判断条件是否成⽴,成⽴就执⾏if中的代码,不成⽴就不进⼊;boolean flag = true;if(flag){System.out.println("...");}if...else语句if...else语句就是根据判断的条件是否成⽴,成⽴⾛if语句,不成⽴⾛else语句;boolean flag = true;if(flag){System.out.println("成⽴");}else{System.out.println("不成⽴");}if...else if语句if...else if⽀持多条件的判断,只会进⼊⼀个匹配的条件;boolean flag = true;boolean fail = false;if(flag){System.out.println("条件匹配");}else if(fail){System.out.println("条件匹配");}else{System.out.println("条件都不匹配");}switch条件控制语句witch语句从JDK1.7开始可以⽀持匹配:String字符串；注意事项:每个case 后⾯必须跟⼀个数值常量或字符串常量⽤于匹配;匹配的语句后⾯需要加上break关键字,防⽌case穿透;String week = "星期⼀";switch(week){case "星期⼀":System.out.println("今天是星期⼀");break;case "星期⼆":System.out.println("今天是星期⼆");break;case "星期三":System.out.println("今天是星期⼆");break;default:System.out.println("今天星期⼏都不是");}循环控制语句for循环语句for(初始值,条件表达式,更新)for(int i = 1 ; i <= 10 ; i++){System.out.println(i);}增强for循环for(接收类型的变量,表达式)int [] arrays = {1,2,3,4,5,6,7,8,9,10};for(int i : arrays){System.out.println(arrays);}while循环语句while(条件表达式)int number = 1;while(number <= 100){System.out.println(number);number ++;}do...while循环语句do{先把语句执⾏⼀遍}while(条件表达式);boolean flag = true;do{System.out.println("先执⾏⼀遍");flag = false;}while(flag);break和continue关键字break关键字结束循环的意思;for(int i = 1; i <= 100; i++){if(i == 10){System.out.println("打印10后结束循环");break;}}continue关键字跳过当前循环,进⼊下⼀次循环;for(int i = 1 ; i <= 10; i ++){if(i % 2 == 1){continue;}System.out.println("打印:"+i);}⽅法概述:⽅法就相当于使⽤多⾏代码进⾏组合去实现的⼀个功能⽚段,对代码进⾏封装利⽤,可实现多次调⽤;⽅法的定义修饰符返回值⽅法名称(形参形参名称){⽅法体}public class Function{public static void main(String[] arags){}public void method1(){}public void method2(String name,int age){}public static void method3(){}public int method03(){int a = 3;return a;}public int method04(int a,int b){if(a == b){System.out.println(a + "和" + b + "相等");return -1;}return a > b ? a : b;}}⽅法的重载⽅法的重载是指⽅法名称相同,传递的参数类型不同,个数不同,顺序不同与返回值⽆关;这样的⽅法被称为⽅法的重载;public class Function{public int max(int a,int b) {return a > b ? a : b;}public double max(double a,double b){return a > b ? a : b;}}形参和实参形参是指在()内部的参数,实参是指被真实传递的参数;public class Function{public static vid main(String[] args){Function function = new Function();function.max(3,5);}public int max(int a,int b) {return a > b ? a : b;}}可变参数在⽅法的()中我们有时候不知道要传递多少参数,那么我们可以传递⼀个数据类型紧跟后⾯加上...来表⽰;但需要注意的是⼀个⽅法中指允许⼀个可变参,如果有其他类型的参数,那么可变参数需要写在最后⾯;可变参数本质上就是⼀个数组;public class Function{public void method(String name,int... numbers){for(int num : numbers){System.out.println(num);}}}递归递归的本质就是⾃⼰调⽤⾃⼰,它可以解决⼀些业务,但效率和开销较⼤,对⼀些⽐较⼩的运算可以使⽤;//递归求3的阶乘public class Founction{public static void main(String[] args){}public int founction(int number){int result = 1;if(number == result){return result;}return number * founction(number - 1);}}数组数组就是⼀组数据的集合,Java中的数组必须存储和数据类型相符合的值,不允许与定义的数据类型不匹配;⼀旦数组被创建出来,它的长度就不允许被改变,数组有下标(索引)的概念,都是从0开始,如果操作的数据超过数组的长度那么就会报出下标索引越界异常[ IndexOutofBoundsException ];数组的定义int[] array = new int[3];int array[] = new int[3];int array[] = {1,2,3};数组的内存模型图数组的遍历⽅式int[] arr = new int[10];//⽅式⼀for (int i = 0; i < arr.length ; i ++) {System.out.println(arr[i]);}//⽅式⼆for (int num : arr) {System.out.println(num);}⼆维数组int[][] arr = new int[3][2];String[][] strArr = {{"hello","hello"},{"hi","hi","hi",{"java","java","java","java"}}Arrays⼯具类Arrays数组的⼯具类,是jdk已经帮我们提供好的⼀套数据⼯具类,⽅便我们对数据相关进⾏⼀些操作;int[] arr = {3,51,1,33,82,22,55,53};Arrays.toString(arr);//把数组变成⼀个字符串Arrays.sort(arr);//对数组内容进⾏升序排列Arrays.fill(arr,0);//把数组的内容全部进⾏替换为0常见算法冒泡排序public static int[] arr = new int[]{5, 2, 7, 4, 6, 9, 8, 13, 19, 11, 17, 15};//冒泡排序算法public static void popArithmetic(int[] arr) {//⽐较的轮数是数组长度-1for (int i = 0; i < arr.length - 1; i++) {//每次⽐较⼀轮,需要减少1次⽐较的次数for (int j = 0; j < arr.length - i - 1; j++) {//如果前⾯的数据⽐后⾯⼤,那么就交换位置if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}System.out.println("最终结果是:" + Arrays.toString(arr));}选择排序public static int[] arr = new int[]{5, 2, 7, 4, 6, 9, 8, 13, 19, 11, 17, 15};//选择排序public static void selectOrderArithmetic(int[] arr) {//⽐较的轮数是数组长度-1for (int i = 0; i < arr.length - 1; i++) {//每⽐较⼀次,需要减少1次⽐较的次数,会把⼩的先往前排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;}}}System.out.println("最终结果是:" + Arrays.toString(arr));}⼆分查找public static int[] arr = new int[]{1, 2, 3 , 4, 6, 7, 8, 13, 19};//2分查找法public static void branchFind(int [] arr,int number){int startNode = 0;int endNode = arr.length-1;int middle = 0;while (startNode <= endNode){//中间的指针由开始节点和结束节点计算得来middle = (startNode+endNode)/2;if(number == arr[middle]){System.out.println("找到了");break;}else if(number < arr[middle]){endNode=middle-1;System.out.println(number+"⼩于中间值,结束节点变更为中间节点-1"); }else if(number > arr[middle]){startNode = middle+1;System.out.println(number+"⼤于中间值,开始节点变更为中间节点+1"); }else{System.out.println("没有找到该元素");break;}}}。

java培训笔记(全)

day01计算机分类1.PC机：家用个人电脑2.服务器：处理大量数据的超级计算机3.智能终端：手机，IPAD4：嵌入式设备：除了上面三种以外，带CPU的Windows操作系统--------PC机Linux操作系统--------其他三类java程序主要是服务器端程序一、Java开发环境（一）、认识Linux系统1.Linux是操作系统，并且开源（开放源代码，免费）2.java主要用于服务器端开发，而Linux是主流的服务器操作系统，所以java 应用部署环境多为LinuxLinux与Windows的差别1.文件结构不同，Windows以盘符为单位，盘符里面是文件夹，而Linux以目录为单位2.外部设备映射不同Windous----盘符Linux-------挂载点3.安全级别不同，Linux比较高，而Windows较低注：/：根目录/home/soft01：主目录Linux常用命令pwd：显示当前工作目录ls：显示当前工作目录的内容cd：改变当前工作目录JDK目录：/opt/jdkEclipse：/usr/local/eclipse蓝色：文件夹红色：压缩文件黑色：文件绿色：可执行文件（二）、Java开发环境1.不同操作系统的编码指令是不同的（0，1不同）2.java编译运行过程编译期：.java源文件编译为.class字节码文件运行期：JVM加载.class并运行.class注：JA V A能实现跨平台3.JDK、JRE、JVM的关系JDK----Java Development Kit（Java开发工具包）除了包含JRE，还包括开发JA V A程序所需的编译、运行等等工具JRE----Java Runtime Environment（Java运行环境）提供运行JA V A程序所需要的环境，包括JVM和JA V A系统类库JVM----Java Virtual Machines（Java虚拟机）加载并运行字节码文件运行JA V A最小环境-------JRE开发JA V A最小环境-------JDKJA V A_HOME：指向jdk安装路径CLASSPATH：类（.class）路径，一般简写为“.”PATH：指向jdk下的bin路径，bin中包括javac，java等等命令。

Java数据结构和算法笔记

Java数据结构和算法笔记篇一：Java数据结构和算法笔记Java数据结构和算法第0讲综述参考教材：Java数据结构和算法（第二版），[美]Robertlafore 1.数据结构的特性数据结构数组有序数组栈队列链表二叉树红-黑树2-3-4树哈希表堆图优点比无序的数组查找快提供后进先出方式的存取提供先进先出方式的存取插入快，删除快查找、插入、删除都快；树总是平衡的查找、插入、删除都快；树总是平衡的；类似的树对磁盘存储有用如果关键字已知，则存储极快；插入快插入、删除快；对大数据项的存取很快对现实世界建模缺点删除和插入慢，大小固定存取其他项很慢存取其他项很慢查找慢算法复杂算法复杂删除慢，如果不知道关键字则存储很慢，对存储空间使用不充分对其他数据项存取慢有些算法慢且复杂插入快；如果知道下标，可以非常快地存取查找慢，删除慢，大小固定查找、插入、删除都快（如果树保持平衡）删除算法复杂2.经典算法总结查找算法：线性查找和二分查找排序算法：用表展示第一讲数组1.Java中数组的基础知识1）创建数组在Java中把数组当作对象来对待，因此在创建数组时必须使用new操作符：一旦创建数组，数组大小便不可改变。

2）访问数组数据项数组数据项通过方括号中的下标来访问，其中第一个数据项的下标是0：3）数组的初始化当创建数组之后，除非将特定的值赋给数组的数据项，否则它们一直是特殊的null对象。

2.面向对象编程方式1）使用自定义的类封装数组2）添加类方法实现数据操作测试MyArray类方法：3.有序数组1）有序数组简介以及其优点有序数组是一种数组元素按一定的顺序排列的数组，从而方便使用二分查找来查找数组中特定的元素。

有序数组提高了查询的效率，但并没有提高删除和插入元素的效率。

2）构建有序数组将2.1中自定义的类封装数组MyArray的方法改为如下：4.查找算法1）线性查找在查找过程中，将要查找的数一个一个地与数组中的数据项比较，直到找到要找的数。

JAVA学习完整版详细笔记

Java基础知识总结Java基础知识总结写代码：1，明确需求。

我要做什么？2，分析思路。

我要怎么做？1,2,3。

3，确定步骤。

每一个思路部分用到哪些语句，方法，和对象。

4，代码实现。

用具体的java语言代码把思路体现出来。

学习新技术的四点：1，该技术是什么？2，该技术有什么特点(使用注意)：3，该技术怎么使用。

demo4，该技术什么时候用？test。

-----------------------------------------------------------------------------------------------一：java概述：1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器；1994年将Oak语言更名为Java；Java的三种技术架构:JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发；JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础；JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序；1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。

2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。

3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。

环境变量的配置：1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdkpath=%JAVA_HOME%\bin2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。

Java数据结构与算法

Java数据结构与算法一、引言Java 是一种强大、高效的编程语言，在现代软件开发领域中使用广泛。

作为一名 Java 开发人员，了解数据结构与算法的重要性不言而喻，因为数据结构和算法是计算机科学的核心。

本文将重点讨论 Java 数据结构与算法，它们的实现方式及其应用。

二、数据结构数据结构是一种在计算机中组织和存储数据的方式。

在软件开发过程中，开发人员需要选择合适的数据结构来存储和处理数据，以实现最好的性能和效率。

Java 提供了很多内置的数据结构，例如数组、链表、队列和栈等。

1. 数组数组是 Java 中最基本和最常用的数据结构之一。

它是一个固定大小的数据序列，其中的元素都具有相同的数据类型。

数组可以使用索引来访问和修改元素。

在 Java 中，可以使用内置的数组类型 int[]、double[]、char[]等，也可以使用泛型数组类型 ArrayList。

可以通过如下方式创建一个 Java 数组：int[] arr = new int[10];这会创建一个长度为 10 的 int 类型数组，其中的元素默认值为 0。

2. 链表链表是一个由节点组成的数据结构，其中每个节点都包含一个数据元素和一个指向下一个节点的指针。

链表的优点在于可以很容易地添加或删除元素，但是访问元素时需要遍历整个链表。

Java 中提供了多种链表类型，包括单向链表、双向链表和循环链表。

可以通过如下方式创建一个单向链表：public class Node {int val;Node next;Node(int x) { val = x; }}Node head = new Node(1);head.next = new Node(2);这会创建一个包含两个元素的单向链表，其值分别为 1 和 2。

3. 队列队列是一种先进先出（FIFO）的数据结构，在 Java 中可以使用内置的Queue 接口实现。

Queue 接口定义了许多方法，例如 add()、remove()、peek() 等，可以用于向队列中添加元素、删除元素和获取队列顶端的元素。

计算机等级考试--二级Java、C语言的知识点大全

计算机等级考试--二级Java、C语言的知识点大全第一章数据结构与算法【考点1】算法的基本概念1、算法：是指一组有穷的指令集，是解题方案的准确而完整的描述。

算法不等于程序，也不等于计算方法。

2、算法的基本特征：1）确定性，算法中每一步骤都必须有明确定义，不允许有多义性；2）有穷性，算法必须能在有限的时间内做完，即能在执行有限个步骤后终止；3）可行性，算法原则上能够精确地执行；4）拥有足够的情报。

3、算法的组成要素：一个算法由数据对象的运算和操作以及其控制结构这两部分组成。

4、算法的基本运算和操作：算术运算，逻辑运算，关系运算，数据传输。

5、算法的基本控制结构：顺序，选择，循环。

6、算法基本设计方法：列举法、归纳法、递推、递归、减半递推技术。

【考点2】算法的复杂度1、算法效率的度量——算法的复杂度：时间复杂度和空间复杂度。

1）算法时间复杂度：指执行算法所需要的计算工作量。

通常，一个算法所用的时间包括编译时间和运行时间。

2）算法空间复杂度：指执行这个算法所需要的内存空间。

包括算法程序所占的空间，输入的初始数据所占的空间，算法执行过程中所需的额外空间。

空间复杂度和时间复杂度并不相关。

【考点3】数据结构的基本概念数据：数据是客观事物的符号表示，是能输入到计算机中并被计算程序识别和处理的符号的总称，如文档，声音，视频等。

数据元素：数据元素是数据的基本单位。

数据对象：数据对象是性质相同的数据元素的集合。

数据结构：是指由某一数据对象中所有数据成员之间的关系组成的集合。

【考点4】逻辑结构和存储结构1、数据结构可分为数据的逻辑结构和存储结构。

1）数据的逻辑结构是对数据元素之间的逻辑关系的描述，与数据的存储无关，是面向问题的，是独立于计算机的。

它包括数据对象和数据对象之间的关系。

2）数据的存储结构也称为数据的物理结构，是数据在计算机中的存放的方式，是面向计算机的，它包括数据元素的存储方式和关系的存储方式。

2、存储结构和逻辑结构的关系：一种数据的逻辑结构可以表示成多种存储结构即数据的逻辑结构和存储结构不一定一一对应。

java知识点思维导图

java知识点思维导图Java 知识点思维导图Java 作为一门广泛应用的编程语言，拥有丰富的知识体系。

为了更清晰地理解和掌握 Java 的知识点，我们可以通过思维导图的方式来进行梳理。

一、基础语法这是 Java 学习的基石，包括变量和数据类型、运算符、控制流语句（如 ifelse、for、while、dowhile 等）。

变量就像是一个个小盒子，用来存放不同类型的数据，比如整数、小数、字符、字符串等等。

数据类型决定了这些小盒子能装什么样的数据。

运算符则是对这些数据进行各种操作的工具，有加、减、乘、除、比较大小等等。

控制流语句则决定了程序执行的顺序和逻辑，比如 ifelse 可以根据条件来决定执行哪一段代码，for 循环可以让一段代码重复执行指定的次数。

二、面向对象编程（OOP）这是 Java 的核心概念之一。

包括类和对象、封装、继承、多态。

类是对象的模板，它描述了对象具有的属性和方法。

对象则是根据类创建出来的具体实例。

封装是把类中的属性和方法进行隐藏，只暴露必要的接口给外部使用，提高了代码的安全性和可维护性。

继承允许一个类从另一个类中获取属性和方法，从而实现代码的复用和扩展。

多态则是同一个方法在不同的对象上有不同的实现，增加了程序的灵活性。

三、异常处理在程序运行过程中，可能会出现各种意外情况，比如文件找不到、网络连接中断等。

Java 通过异常处理机制来处理这些情况。

通过 trycatch 语句来捕获和处理可能出现的异常，让程序在出现异常时能够以一种可控的方式继续运行，而不是直接崩溃。

四、数组和集合数组是一种固定长度的数据结构，可以存储相同类型的元素。

集合则更加灵活，比如 ArrayList、HashSet、HashMap 等。

ArrayList 可以动态增长和收缩，HashSet 不允许重复元素，HashMap 用于存储键值对。

五、输入输出（I/O）操作包括文件读写、控制台输入输出等。

通过 File 类和相关的流（如 FileInputStream、FileOutputStream 等）来实现对文件的操作。

Java数据结构与经典算法——高手必会(DOC)

1.大O表示法：粗略的量度方法即算法的速度是如何与数据项的个数相关的算法大O表示法表示的运行时间线性查找 O(N)二分查找 O(logN)无序数组的插入 O(1)有序数组的插入 O(N)无序数组的删除 O(N)有序数组的删除 O(N)O(1)是最优秀的,O(logN)良好,O(N)还可以,O(N2)稍差(在冒泡法中见到)2.排序public class JWzw {//插入排序public void insertArray(Integer []in){int tem = 0;int num = 0;int upnum = 0;for (int i = 0; i < in.length; i++) {for (int j = i - 1; j >= 0; j--) {num++;if (in[j+1] < in[j]) {tem = in[j+1];in[j+1] = in[j];in[j] = tem;upnum++;}else{break;}}}for (int i = 0; i < in.length; i++) {System.out.print(in[i]);if(i < in.length - 1){System.out.print(",");}}System.out.println();System.out.println("插入排序循环次数:" + num);System.out.println("移动次数：" + upnum);System.out.print("\n\n\n");}//选择排序public void chooseArray(Integer []in){int tem = 0;int num = 0;int upnum = 0;for(int i = 0;i < in.length;i++){for(int j = i;j < in.length - 1;j++){num++;if(in[j+1] < in[j]){tem = in[j+1];in[j + 1] = in[j];in[j] = tem;upnum++;}}}for (int i = 0; i < in.length; i++) {System.out.print(in[i]);if(i < in.length - 1){System.out.print(",");}}System.out.println();System.out.println("选择排序循环次数:" + num);System.out.println("移动次数：" + upnum);System.out.print("\n\n\n");}//冒泡排序public void efferArray(Integer []in){int tem = 0;int num = 0;int upnum = 0;for(int i = 0;i < in.length;i++){for(int j = i;j < in.length - 1;j++){num++;if(in[j+1] < in[i]){tem = in[j+1];in[j+1] = in[i];in[i] = tem;upnum++;}}}for (int i = 0; i < in.length; i++) {System.out.print(in[i]);if(i < in.length - 1){System.out.print(",");}}System.out.println();System.out.println("冒泡排序循环次数:" + num);System.out.println("移动次数：" + upnum);System.out.print("\n\n\n");}//打印乘法口诀public void printMulti(){for (int j = 1; j < 10; j++) {for (int i = 1; i <= j; i++) {System.out.print(i + " * " + j + " = " + j * i + "\t");}System.out.print("\t\n");}System.out.print("\n\n\n");}//打印N * 1 + N * 2 + N * 3 =num的所有组合public void printNumAssemble(int num){for (int i = 0; i < num + 1; i++) {for (int j = 0; j < num / 2 +1; j++) {for (int in = 0; in < num / 3 + 1; in++) {if (i * 1 + j * 2 + in * 3 == num) {System.out.println("小马" + i + ",\t中马" + j + ",\t大马" + in);}}}}}/*** @param args*/public static void main(String[] args) {JWzw jwzw = new JWzw();int num = 3;jwzw.printMulti();//打印乘法口诀jwzw.printNumAssemble(100);//打印N * 1 + N * 2 + N * 3 =num的所有组合Integer in[] = {8,89,5,84,3,45,12,33,77,98,456,878,654,213,897};jwzw.efferArray(in);//冒泡排序Integer in1[] = {8,89,5,84,3,45,12,33,77,98,456,878,654,213,897};jwzw.insertArray(in1);//插入排序Integer in2[] = {8,89,5,84,3,45,12,33,77,98,456,878,654,213,897};jwzw.chooseArray(in2);//选择排序//int i = num++;//System.out.println(i);System.out.println(1000>>2);}}3.优先级队列class PriorityQueue {private long[] a = null;private int nItems = 0;private int maxSize = 0;public PriorityQueue(int maxSize) {a = new long[maxSize];this.maxSize = maxSize;nItems = 0;}public void insert(long l) {//优先级队列的插入不是队尾,而是选择一个合适的按照某种顺序插入的//当队列长度为0时，如下//不为0时,将所有比要插入的数小的数据后移,这样大的数就在队列的头部了int i = 0;if(nItems == 0) {a[0] = l;} else {for(i=nItems-1; i>=0; i--) {if(l < a[i])a[i+1] = a[i];elsebreak;}a[i+1] = l;}nItems++;}public long remove() {//移出的是数组最上端的数，这样减少数组元素的移动return a[--nItems];}public boolean isEmpty() {return (nItems == 0);}public boolean isFull() {return (nItems == maxSize);}public int size() {return nItems;}}public class duilie {// 队列体类private duilie s;private String data;duilie(String data) {this.data = data;}public String getData() {return data;}public void setData(String data) {this.data = data;}public duilie getS() {return s;}public void setS(duilie s) {this.s = s;}}public class duiliecz {// 队列操作类/*** @param args*/private int i = 0;// 队列长private duilie top = new duilie("");// 队列头private duilie end = new duilie("");// 队列尾public void add(String s) {// 添加队列duilie m = new duilie(s);if (i != 0) {m.setS(top.getS());top.setS(m);} else {top.setS(m);end.setS(m);}i++;}4.队列public void del() {// 删除队尾if (i == 0) {return;} else if (i == 1) {top.setS(null);end.setS(null);} else {duilie top1 = new duilie("");// 队列底查找用缓存 top1.setS(top.getS());while (!top1.getS().getS().equals(end.getS())) { top1.setS(top1.getS().getS());}end.setS(top1.getS());}i--;}public static void main(String[] args) {// TODO Auto-generated method stubduiliecz m = new duiliecz();m.add("1");m.add("2");m.add("3");m.add("4");for (int n = 0; n < 4; n++) {m.del();}}public int getI() {return i;}public duilie getEnd() {return end;}public duilie getTop() {return top;}}5.栈public class Stack {int[] arr;int len = 0;public Stack() {arr = new int[100];}public Stack(int n) {arr = new int[n];}public int size() {return len + 1;}// 扩大数组public void resize() {int[] b = new int[arr.length * 2];System.arraycopy(arr, 0, b, 0, arr.length);arr = b;}public void show() {for (int i = 0; i < len; i++) {System.out.print(arr[i] + " ");}System.out.println();}// 进栈public void push(int a) {if (len >= arr.length)resize();arr[len] = a;len++;}// 出栈public int pop() {if (len == 0) {System.out.println();System.out.println("stack is empty!");return -1;}int a = arr[len - 1];arr[len - 1] = 0;len--;return a;}}6.链表class Node {Object data;Node next;public Node(Object data) {setData(data);}public void setData(Object data) {this.data = data;}public Object getData() {return data;}}class Link {Node head;int size = 0;public void add(Object data) {Node n = new Node(data);if (head == null) {head = n;} else {Node current = head;while (true) {if (current.next == null) {break;}current = current.next;}current.next = n;}size++;}public void show() {Node current = head;if (current != null) {while (true) {System.out.println(current);if (current == null) {break;}current = current.next;}} else {System.out.println("link is empty");}}public Object get(int index) {// ....}public int size() {return size;}}7.单链表class Node // 节点类，单链表上的节点{String data; // 数据域，存放String类的数据Node next; // 指向下一个节点Node(String data) {this.data = data; // 构造函数}String get() {return data; // 返回数据}}class MyLinkList // 链表类{Node first; // 头节点int size; // 链表长度MyLinkList(String arg[]) {// Node first = new Node("head");//生成头节点first = new Node("head"); // J.F. 这里不需要定义局部变量 first// 如果定义了局部变量，那成员变量 first 就一直没有用上// 所以，它一直为空size = 0;Node p = first;for (int i = 0; i < arg.length; i++) // 将arg数组中的元素分别放入链表中{Node q = new Node(arg[i]);q.next = p.next; // 每一个节点存放一个arg数组中的元素p.next = q;p = p.next;size++;}}MyLinkList() // 无参数构造函数{// Node first = new Node("head");first = new Node("head"); // J.F. 这里犯了和上一个构造方法同样的错误size = 0;}int size() // 返回链表长度{return size;}void insert(Node a, int index) // 将节点a 插入链表中的第index个位置{Node temp = first;for (int i = 0; i < index; i++) {temp = temp.next;// 找到插入节点的前一节点}a.next = temp.next; // 插入节点temp.next = a;size++;}Node del(int index) // 删除第index个节点，并返回该值{Node temp = first;for (int i = 0; i < index; i++) {temp = temp.next;// 找到被删除节点的前一节点}Node node = temp.next;temp.next = node.next;size--; // 删除该节点，链表长度减一return node;}void print() // 在屏幕上输出该链表（这段程序总是出错，不知道错在哪里）{Node temp = first;for (int i = 1; i < size; i++) // 将各个节点分别在屏幕上输出{temp = temp.next;System.out.print(temp.get() + "->");}}void reverse() // 倒置该链表{for (int i = 0; i < size; i++) {insert(del(size - 1), 0); // 将最后一个节点插入到最前// J.F. 最后一个节点的 index 应该是 size - 1// 因为第一个节点的 index 是 0}}String get(int index) // 查找第index个节点，返回其值{if (index >= size) {return null;}Node temp = first;for (int i = 0; i < index; i++) {temp = temp.next;// 找到被查找节点的前一节点}return temp.next.get();}}class MyStack // 堆栈类，用单链表实现{MyLinkList tmp;Node temp;MyStack() {// MyLinkList tmp = new MyLinkList();tmp = new MyLinkList(); // J.F. 和 MyLinkList 构造方法同样的错误}void push(String a) // 压栈，即往链表首部插入一个节点{Node temp = new Node(a);tmp.insert(temp, 0);}String pop() // 出栈，将链表第一个节点删除{Node a = tmp.del(0);return a.get();}int size() {return tmp.size();}boolean empty() // 判断堆栈是否为空{if (tmp.size() == 0)return false;elsereturn true;}}public class MyLinkListTest // 测试程序部分{public static void main(String arg[]) // 程序入口{if ((arg.length == 0) || (arg.length > 10))System.out.println("长度超过限制或者缺少参数");else {MyLinkList ll = new MyLinkList(arg); // 创建一个链表ll.print(); // 先输出该链表（运行到这一步抛出异常）ll.reverse(); // 倒置该链表ll.print(); // 再输出倒置后的链表String data[] = new String[10];int i;for (i = 0; i < ll.size(); i++) {data[i] = ll.get(i); // 将链表中的数据放入数组}// sort(data);// 按升序排列data中的数据（有没有现成的排序函数？）for (i = 0; i < ll.size(); i++) {System.out.print(data[i] + ";"); // 输出数组中元素}System.out.println();MyStack s = new MyStack(); // 创建堆栈实例sfor (i = 0; i < ll.size(); i++) {s.push(data[i]); // 将数组元素压栈}while (!s.empty()) {System.out.print(s.pop() + ";"); // 再将堆栈里的元素弹出}}}}8.双端链表class Link {public int iData = 0;public Link next = null;public Link(int iData) {this.iData = iData;}public void display() {System.out.print(iData + " ");}}class FirstLastList {private Link first = null;private Link last = null;public FirstLastList() {first = null;last = null;}public void insertFirst(int key) {Link newLink = new Link(key);if (this.isEmpty())last = newLink;newLink.next = first;first = newLink;}public void insertLast(int key) {Link newLink = new Link(key);if (this.isEmpty())first = newLink;elselast.next = newLink;last = newLink;}public Link deleteFirst() {Link temp = first;if (first.next == null)last = null;first = first.next;return temp;}public boolean isEmpty() {return (first == null);}public void displayList() {System.out.print("List (first-->last): ");Link current = first;while (current != null) {current.display();current = current.next;}System.out.println("");}}class FirstLastListApp {public static void main(String[] args) {// TODO Auto-generated method stubFirstLastList theList = new FirstLastList();theList.insertFirst(22); // insert at fronttheList.insertFirst(44);theList.insertFirst(66);theList.insertLast(11); // insert at reartheList.insertLast(33);theList.insertLast(55);theList.displayList(); // display the listtheList.deleteFirst(); // delete first two itemstheList.deleteFirst();theList.displayList(); // display again }}9.有序链表package arithmetic;class Link {public int iData = 0;public Link next = null;public Link(int iData) {this.iData = iData;}public void display() {System.out.print(iData + " ");}}class SortedList {private Link first = null;public SortedList() {first = null;}public void insert(int key) {Link newLink = new Link(key);Link previous = null;Link current = first;// while的第一个条件是没有到达链表的尾端,第二个是按顺序找到一个合适的位置while (current != null && key > current.iData) {previous = current;current = current.next;}// 如果是空表或者要插入的元素最小,则在表头插入keyif (current == first)first = newLink;elseprevious.next = newLink;newLink.next = current;}/*** 删除表头的节点** @return要删除的节点*/public Link remove() {Link temp = first;first = first.next;return temp;}public boolean isEmpty() {return (first == null);}public void displayList() {System.out.print("List (first-->last): ");Link current = first; // start at beginning of listwhile (current != null) // until end of list,{current.display(); // print datacurrent = current.next; // move to next link}System.out.println("");}}class SortedListApp {public static void main(String[] args) { // create new listSortedList theSortedList = new SortedList();theSortedList.insert(20); // insert 2 itemstheSortedList.insert(40);theSortedList.displayList(); // display listtheSortedList.insert(10); // insert 3 more itemstheSortedList.insert(30);theSortedList.insert(50);theSortedList.displayList(); // display listtheSortedList.remove(); // remove an itemtheSortedList.displayList(); // display list }}10.双向链表class Link {// 双向链表,有两个指针,一个向前,一个向后public int iData = 0;public Link previous = null;public Link next = null;public Link(int iData) {this.iData = iData;}public void display() {System.out.print(iData + " ");}}class DoublyLinked {// 分别指向链表的表头和表尾private Link first = null;private Link last = null;public boolean isEmpty() {return first == null;}/*** 在表头插入数据** @param要插入的节点的数据*/public void insertFirst(int key) {Link newLink = new Link(key);// 如果开始链表为空,则插入第一个数据后,last也指向第一个数据if (this.isEmpty())last = newLink;else {// 表不为空的情况first.previous = newLink;newLink.next = first;}// 无论怎样,插入后都的让first重新指向第一个节点first = newLink;}public void insertLast(int key) {// 在尾端插入数据,同上Link newLink = new Link(key);if (this.isEmpty())first = newLink;else {last.next = newLink;newLink.previous = last;}last = newLink;}/*** 在指定的节点后插入数据** @param key* 指定的节点的值* @param iData* 要插入的数据* @return是否插入成功*/public boolean insertAfter(int key, int iData) {Link newLink = new Link(key);Link current = first;// 从first开始遍历,看能否找到以key为关键字的节点while (current.iData != key) {current = current.next;// 若能找到就跳出循环,否则返回false,插入失败if (current == null)return false;}// 如果插入点在last的位置if (current == last) {last = newLink;} else {// 非last位置,交换各个next和previous的指针newLink.next = current.next;current.next.previous = newLink;}current.next = newLink;newLink.previous = current;return true;}/*** 删除表头的节点** @return*/public Link deleteFirst() {Link temp = first;// 如果表中只有一个元素,删除后则为空表,所以last=nullif (first.next == null)last = null;else// 否则,让第二个元素的previous=nullfirst.next.previous = null;// 删除头指针,则first指向原来的secondfirst = first.next;return temp;}public Link deleteLast() {// 同上Link temp = last;if (last.previous == null)first = null;elselast.previous.next = null;last = last.previous;return temp;}public Link deleteKey(int key) {Link current = first;// 遍历整个链表查找对应的key,如果查到跳出循环,否则...while (current.iData != key) {current = current.next;// ...否则遍历到表尾,说明不存在此key,返回null,删除失败if (current == null)return null;}if (current == first)first = first.next;elsecurrent.previous.next = current.next;if (current == last)last = last.previous;elsecurrent.next.previous = current.previous;return current;}public void displayForward() {Link current = first;while (current != null) {current.display();current = current.next;}System.out.println();}public void displayBackward() {Link current = last;while (current != null) {current.display();current = current.previous;}System.out.println();}}class DoublyLinkedApp {public static void main(String[] args) { // make a new list DoublyLinked theList = new DoublyLinked();theList.insertFirst(22); // insert at fronttheList.insertFirst(44);theList.insertFirst(66);theList.insertLast(11); // insert at reartheList.insertLast(33);theList.insertLast(55);theList.displayForward(); // display list forwardtheList.displayBackward(); // display list backwardtheList.deleteFirst(); // delete first itemtheList.deleteLast(); // delete last itemtheList.deleteKey(11); // delete item with key 11theList.displayForward(); // display list forwardtheList.insertAfter(22, 77); // insert 77 after 22theList.insertAfter(33, 88); // insert 88 after 33theList.displayForward(); // display list forward}}11.实现二叉树前序遍历迭代器class TreeNode 这个类用来声明树的结点，其中有左子树、右子树和自身的内容。

算法与数据结构知识点

算法与数据结构知识点
嘿呀，咱今天就来唠唠算法与数据结构的那些知识点！
你想想看啊，算法就像是我们生活中的解题妙招一样！比如说你要去一
个地方，你得找个最快的路线吧，这就是一种算法呀！就像你去超市买东西，怎么最快找到自己想买的东西并且最快结账出来，这也是一种算法在起作用呢。

再比如说冒泡排序，嘿，那可太有意思啦！就好像一群小朋友排队，个矮的慢慢就被换到前面去了，不就排好序啦！
还有数据结构呢，就像是不同的容器一样。

比如说数组，那就是一排整
齐的格子，你放东西进去，一个个都排好啦。

栈呢，嘿，那就是个只能后进先出的地方，就跟你往一个箱子里放东西，只能最后放进去的先拿出来一样。

链表呢，就像一串串珠子，每个珠子都知道下一个珠子在哪，多神奇！
诶，你说要是没有这些算法和数据结构，那我们的电脑程序得多乱套呀！那岂不是跟没头苍蝇似的到处乱撞。

你想想，如果程序运行得慢吞吞的，你不得急死呀！有了这些知识点，我们就能让程序高效运行，就跟给机器注入了魔力一样。

咱再说说树这种数据结构，它就像一棵大树一样有根有枝有叶。

在程序里能快速查找呀什么的。

比如在一个大的文件里找个特定的信息，有了树结构，那可就容易多啦！这就好比在一个大森林里找一颗特定的树，有了标记和路径，一下子就找到啦。

总之啊，算法和数据结构这些知识点真的太重要啦！它们是让我们的程序能够又快又好地运行的秘密武器呀！它们就像我们生活中的各种工具一样，没有它们还真不行呢，你说是不是！。

数据结构与算法知识点必备

数据结构与算法知识点必备在计算机科学的广袤领域中，数据结构与算法宛如基石，支撑着各种复杂程序和系统的构建。

无论你是初涉编程的新手，还是经验丰富的开发者，深入理解和掌握数据结构与算法的知识点都是至关重要的。

首先，我们来谈谈数据结构。

数据结构是指数据在计算机中的组织和存储方式，它决定了数据的访问、插入、删除和搜索等操作的效率。

常见的数据结构包括数组、链表、栈、队列、树和图等。

数组是一种最简单也是最常用的数据结构。

它是一组连续存储的相同类型元素的集合。

通过索引可以快速访问数组中的元素，但插入和删除操作可能会比较耗时，因为需要移动大量的元素。

链表则与数组不同，它的元素在内存中不是连续存储的。

每个链表元素包含数据和指向下一个元素的指针。

链表的插入和删除操作相对简单，只需要修改指针即可，但访问特定位置的元素需要从头开始遍历。

栈和队列是两种特殊的线性数据结构。

栈遵循“后进先出”的原则，就像一个堆叠的盘子，最后放上去的盘子最先被拿走。

队列则遵循“先进先出”的原则，类似于排队买票，先来的先得到服务。

树是一种分层的数据结构，常见的有二叉树、二叉搜索树、AVL 树等。

二叉搜索树的特点是左子树的所有节点值小于根节点，右子树的所有节点值大于根节点。

这使得搜索、插入和删除操作的平均时间复杂度为 O(log n)。

图是一种更加复杂的数据结构，用于表示对象之间的关系。

图可以分为有向图和无向图。

在图的算法中，常见的有深度优先搜索和广度优先搜索，用于遍历图中的节点。

接下来，让我们走进算法的世界。

算法是解决特定问题的一系列明确步骤。

常见的算法包括排序算法、搜索算法和动态规划等。

排序算法是将一组无序的数据按照特定的顺序排列。

冒泡排序、插入排序、选择排序是简单但效率较低的排序算法。

快速排序、归并排序和堆排序则是效率较高的排序算法。

快速排序通过选择一个基准元素，将数据分为两部分，然后对这两部分分别排序。

归并排序则是将数据分成两半，分别排序后再合并。

数据结构与算法知识点必备

数据结构与算法知识点必备一、数据结构知识点1. 数组(Array)数组是一种线性数据结构，它由相同类型的元素组成，通过索引访问。

数组的特点是随机访问速度快，但插入和删除操作较慢。

常见的数组操作包括创建、访问、插入、删除和遍历。

2. 链表(Linked List)链表是一种动态数据结构，它由节点组成，每一个节点包含数据和指向下一个节点的指针。

链表的特点是插入和删除操作快，但访问速度较慢。

常见的链表类型包括单向链表、双向链表和循环链表。

3. 栈(Stack)栈是一种后进先出(LIFO)的数据结构，只能在栈顶进行插入和删除操作。

常见的栈操作包括入栈(push)和出栈(pop)。

4. 队列(Queue)队列是一种先进先出(FIFO)的数据结构，只能在队尾插入元素，在队头删除元素。

常见的队列操作包括入队(enqueue)和出队(dequeue)。

5. 树(Tree)树是一种非线性数据结构，由节点和边组成。

树的特点是层次结构、惟一根节点、每一个节点最多有一个父节点和多个子节点。

常见的树类型包括二叉树、二叉搜索树、平衡二叉树和堆。

6. 图(Graph)图是一种非线性数据结构，由节点和边组成。

图的特点是节点之间的关系可以是任意的，可以有环。

常见的图类型包括有向图、无向图、加权图和连通图。

7. 哈希表(Hash Table)哈希表是一种根据键(key)直接访问值(value)的数据结构，通过哈希函数将键映射到数组中的一个位置。

哈希表的特点是查找速度快，但内存消耗较大。

常见的哈希表操作包括插入、删除和查找。

二、算法知识点1. 排序算法(Sorting Algorithms)排序算法是将一组元素按照特定顺序罗列的算法。

常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序。

2. 查找算法(Search Algorithms)查找算法是在一组元素中寻觅特定元素的算法。

常见的查找算法包括线性查找、二分查找和哈希查找。

大数据基础-Java学习笔记

.......................................................... 3 基本数据类型 ................................................................ 3 数据类型转换 ................................................................ 3 静态变量，成员变量，局部变量的区别 .......................................... 3 关系运算符 .................................................................. 4 位运算符 .................................................................... 4 条件运算符 .................................................................. 4 三种控制结构 ................................................................ 4 一维数组 .................................................................... 5 多维数组 .................................................................... 5 类的成员变量和成员方法修饰符 ................................................ 6 构造函数 .................................................................... 6 类的权限 .................................................................... 6 类的继承性 .................................................................. 7 重载（overload）和覆盖（或者重写） .......................................... 7 抽象类和最终类 .............................................................. 7 内部类和匿名类 .............................................................. 7 接口 ........................................................................ 8 什么情况下要用到 java 中的多线程机制？ ....................................... 8 Java 中主要的数据结构 ....................................................... 9 Java web 开发的 ssh 框架？ .................................................. 10

Java数据结构和算法笔记

Java数据结构和算法第0讲综述参考教材：Java数据结构和算法（第二版），[美] Robert lafore 1. 数据结构的特性数据结构优点缺点数组插入快；如果知道下标，可以非常快地存取查找慢，删除慢，大小固定有序数组比无序的数组查找快删除和插入慢，大小固定栈提供后进先出方式的存取存取其他项很慢队列提供先进先出方式的存取存取其他项很慢链表插入快，删除快查找慢二叉树查找、插入、删除都快（如果树保持平衡）删除算法复杂红-黑树查找、插入、删除都快；树总是平衡的算法复杂2-3-4树查找、插入、删除都快；树总是平衡的；类似的树对算法复杂磁盘存储有用哈希表如果关键字已知，则存储极快；插入快删除慢，如果不知道关键字则存储很慢，对存储空间使用不充分堆插入、删除快；对大数据项的存取很对其他数据项存取慢快图对现实世界建模有些算法慢且复杂2. 经典算法总结查找算法：线性查找和二分查找排序算法：用表展示第一讲数组1.Java中数组的基础知识1）创建数组在Java中把数组当作对象来对待，因此在创建数组时必须使用new操作符：int[] intArr = new int[10];一旦创建数组，数组大小便不可改变。

2）访问数组数据项数组数据项通过方括号中的下标来访问，其中第一个数据项的下标是0：intArr[0] = 123;3）数组的初始化当创建数组之后，除非将特定的值赋给数组的数据项，否则它们一直是特殊的null对象。

int[] intArr = {1, 2, 3, 4, 5};等效于下面使用new来创建数组并初始化：int[] intArr = new int[5];intArr[0] = 1;intArr[1] = 2;intArr[2] = 3;intArr[3] = 4;intArr[4] = 5;2.面向对象编程方式1）使用自定义的类封装数组MyArray类：public class MyArray {private long[] arr;private int size; //记录数组的有效长度public MyArray() {arr = new long[10];}public MyArray(int maxSize) {arr = new long[maxSize];}//向数组中插入数据public void insert(long element) {arr[size] = element;size++;}//显示数组中的数据public void show() {for(int i=0; i<size; i++) {if(i==0) {System.out.print("[" + arr[i] + ", ");} else if(i==size-1) {System.out.println(arr[i] + "]");} else {System.out.print(arr[i] + ", ");}}}//根据值查找索引（出现该值的第一个位置）：线性查找public int queryByValue(long element) {int i;for(i=0; i<size; i++) { // linear searchif(arr[i] == element) break;}if(i == size) {return -1;} else {return i;}}//根据索引查找值public long queryByIndex(int index) {if(index >= size || index < 0) {throw new ArrayIndexOutOfBoundsException();} else {return arr[index];}}//删除数据public void delete(int index) {if(index >= size || index < 0) {throw new ArrayIndexOutOfBoundsException();} else {//当size=maxSize，删除最后一个数时，不会执行forfor(int i=index; i<size-1; i++) {arr[index] = arr[index + 1];System.out.println("for");}size--;}}//更新数据public void update(int index, long value) {if(index >= size || index < 0) {throw new ArrayIndexOutOfBoundsException();} else {arr[index] = value;}}}2）添加类方法实现数据操作测试MyArray类方法：public void testMyArray() throws Exception {MyArray myArray = new MyArray();myArray.insert(123);myArray.insert(456);myArray.insert(789);myArray.show(); //[123, 456, 789]System.out.println(myArray.queryByValue(111)); //-1System.out.println(myArray.queryByIndex(2)); //789myArray.delete(2);myArray.show(); //[123, 456]myArray.update(0, 0);myArray.show(); //[0, 456]}3.有序数组1）有序数组简介以及其优点有序数组是一种数组元素按一定的顺序排列的数组，从而方便使用二分查找来查找数组中特定的元素。

Java数据结构和算法总结-字符串相关高频面试题算法

Java数据结构和算法总结-字符串相关⾼频⾯试题算法前⾔：周末闲来⽆事，看了看字符串相关算法的讲解视频，收货颇丰，跟着视频讲解简单做了⼀下笔记，⽅便以后翻阅复习同时也很乐意分享给⼤家。

什么字符串在算法中有多重要之类的⼤路边上的客套话就不多说了，直接上笔记吧。

⼀、字符串java：String内置类型，不可更改。

（如需更改可考虑：StringBuffer, StringBuilder,char[]等）⼆、归类　字符串涉及到的相关题型通常会是以下⼏个⽅⾯：概念理解：字典序简单操作：插⼊删除字符、旋转规则判断（罗马数字转换是否是合法的整数、浮点数）数字运算（⼤数加法，⼆进制加法）排序、交换字符计数：变位词匹配（正则表达式、全串匹配、KMP、周期判断）动态规划（LCS、编辑距离、最长回⽂⼦串）搜索（单词变换、排列组合）三、例题1、交换：把⼀个只包含01的串排序，可交换任意两个数的位置，最少需要多少次交换？思路：从两头往中间扫荡，扫荡过程中在左边遇到1就和右边遇到的0交换位置，直接到左有下标相遇时结束。

具体代码如下：1public static void main(String[] strs) {2int count = 0;3int[] arrays = new int[] {0, 0, 1, 1, 1, 0, 1, 0, 0, 1};4int left = 0;5int right = arrays.length - 1;6while (true) {7while (arrays[left] == 0) {8 left++;9 }10while (arrays[right] == 1) {11 right--;12 }13if (left >= right) {14break;15 } else {16int temp = arrays[left];17 arrays[left] = arrays[right];18 arrays[right] = temp;19 count++;20 }21 }22 Logger.println("交换次数：" + count);23for (int array : arrays) {24 Logger.print(array + ", ");25 }26 }清晰起见，交换次数和排序后的的字符串输出如下：交换次数：30, 0, 0, 0, 0, 1, 1, 1, 1, 1,2、字符串替换和复制：删除⼀个字符串所有的a，并且复制所有的b（字符数组⾜够⼤）思路：详细思路见代码注释1public static void main(String[] strs) {2char[] input = new char[]{'a', 'b', 'c', 'd', 'a', 'f', 'a', 'b', 'c', 'd', 'b', 'b', 'a', 'b'};3char[] chars = new char[50];4for (int j = 0; j < input.length; j++) {5 chars[j] = input[j];6 }7 Logger.println("操作前：");8for (char c:chars9 ) {10 Logger.print(c + ", ");11 }13int countB = 0;14// 1、删除a，⽤n当做新下标，循环遍历数组，凡是不是a的元素都放到新下标的位置，由于新n增长慢，⽼下标i增长快，所以元素不会被覆盖。