提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

Day11——顺序表（一）

顺序表是什么？

1.顺序表从属于线性表这一个大类 。线性表，全名为线性存储结构，使用线性表存储数据的方式可以这样理解，即“把所有数据用一根线儿串起来，再存储到物理空间中”。
2.物理空间中的不同存储方式派生出顺序表与链表两个分集，其中顺序表的特点在于逻辑上相连的空间在物理地址上也是绝对相连的，这种绝对相连的过程构成了线性表的顺序存储，从而简称“顺序表”。
3.具体来说顺序表，其用一组地址连续的存储单元依次存储线性表中的各个元素，使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中。
即：通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。又因为地址空间的定长特点，可以实现随机存取。

一般来说，所有的编程语言模拟顺序表的方法都是通过数组，因为数组的存储与逻辑结构与顺序表几乎完全一致。

Java复习：重写与重载

1.重写(Override)

从字面上看，重写就是重新写一遍的意思。其实就是子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法，但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(除过子类中方法的返回值是父类中方法返回值的子类时) 都相同的情况下， 对方法体进行修改或重写，这就是重写。但要注意子类函数的访问修饰权限不能少于父类的。
在类中，我们往往会对构造函数进行重载。

2.重载（Overloading）

在一个类中，同名的方法如果有不同的参数列表 （参数类型不同、参数个数不同甚至是参数顺序不同） 则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。

练习代码

package datastructure;/*** Sequential list.* * @author Wanxiang Luo 2858442831@qq.com*/public class SequentialList {/*** The maximal length of the list. It is a constant.*/public static final int MAX_LENGTH = 10;/*** The actual length not exceeding MAX_LENGTH. Attention: length is not only the* member variable of Sequential list, but also the member variable of Array. In* fact, a name can be the member variable of different classes.*/int length;/*** The data stored in an array.*/int[] data;public SequentialList() {length = 0;data = new int[MAX_LENGTH];}// Of the first constructor/************************ Construct a sequential list using an array.* * @param paraArray The given array. Its length should not exceed MAX_LENGTH.*                  For simplicity now we do not check it.**********************/public SequentialList(int[] paraArray) {data = new int[MAX_LENGTH];length = paraArray.length;// Copy data.for (int i = 0; i < paraArray.length; i++) {data[i] = paraArray[i];} // Of for i}// Of the second constructor/************************ Overrides the method claimed in Object, the superclass of any class.**********************/public String toString() {String resultString = "";if (length == 0) {return "empty";} // Of iffor (int i = 0; i < length - 1; i++) {resultString += data[i] + ",";} // Of for iresultString += data[length - 1];return resultString;}// Of toString/************************ Reset to emppty**********************/public void reset() {length = 0;}// Of resetpublic static void main(String args[]) {int[] tempArray = { 1, 4, 6, 7 };SequentialList tempFirstList = new SequentialList(tempArray);System.out.println("Initialized, the list is: " + tempFirstList.toString());System.out.println("Again, the list is: " + tempFirstList);tempFirstList.reset();System.out.println("After reset, the list is: " + tempFirstList);}// Of main}// Of class SequentialList

1.对构造函数SequentialList()进行了重载，无参构造器用于初始化顺序表，有参构造器用于数据的快速复制
2.对Object类中的toString方法进行了重写，两次输出分别是直接调用对象本身的方法toString()与toString()本身重写特征下影响的println()方法中对于此对象的识别。

运行结果

小结

顺序表很容易被人脑接受，是因为人的思考模式本身是按照一定顺序，提取围绕目标或问题的相关信息。但是它却要进过一定的程序抽象才能被计算机接受。因为顺序表要对仅仅局限于一对一的存储结构中，实现对于全局数据的感知。很多逻辑结构，人为感知很简单，因为人脑可以快速提取一个顺序段的信息，但是，用程序抽象却格外困难。因为，本质上，这是逻辑丰富与物理存储单一的矛盾。
而机器学习正是对能通过经验自动改进的计算机算法的研究。

---

Day12——顺序表(二)

查找

1.含义：给出任意一个数，在顺序表中查找此元素首次出现时的下标号。
2.默认的顺序查找方法就是从头到尾遍历数据（什么方向都行），一但发现合适的数据就返回下标即可，如果结束遍历后都没有发现合适元素就返回一个定义内的下标非法的数值（比如-1）
3.若表为顺序表，可用二分法O(logn)，来提高查找效率

/************************ Find the index of the given value. If it appears in multiple positions,* simply return the first one.* * @param paraValue The given value.* @return The position. -1 for not found.**********************/public int indexOf(int paraValue) {int tempPosition = -1;for (int i = 0; i < length; i++) {if (data[i] == paraValue) {tempPosition = i;break;} // Of if} // Of forreturn tempPosition;}// Of indexOf

使用for循环将传入值与顺序表的值一一比对，匹配上则将数据位置赋值给tempPosition并返回，返回值为-1时表明未找到

插入

1.插入前需注意：顺序表是否满，插入位置是否合理
2.插入数据时：从尾到头遍历至该位置paraPosition，data[i] = data[i - 1];不断用 前一个元素覆盖当前元素。
3.然后只需要在图中的原paraValue位置修改为我们的插入元素即可实现前插入

public boolean insert(int paraPosition, int paraValue) {if (length == MAX_LENGTH) {System.out.println("List full.");return false;} // Of ifif ((paraPosition < 0) || (paraPosition > length)) {System.out.println("The position " + paraPosition + " is out of bound.");return false;}// From tail to head. The last one is moved to a new position.// Because length < MAX_LENGTH, no exceeding occurs.for (int i = length; i > paraPosition; i--) {data[i] = data[i - 1];} // Of for idata[paraPosition] = paraValue;length++;return true;}// Of insert

删除

1.从paraPosition位置开始遍历，遍历过程中：data[i] = data[i + 1];,后一位的数据据直接覆盖前一位,(需使用从前向后遍历，否则无法实现向前覆盖)
2.操作完成，末尾元素出现了重复，因此需要我们逻辑上对其进行删除（令length-1）

/************************ Delete a value at a position.* * @param paraPosition The given position.* @return Success or not.**********************/public boolean delete(int paraPosition) {if ((paraPosition < 0) || (paraPosition >= length)) {System.out.println("The position " + paraPosition + " is out of bounds.");return false;} // Of if// From head to tailfor (int i = paraPosition; i < length - 1; i++) {data[i] = data[i + 1];} // Of for ilength--;return true;}// Of delete

代码主体

/************************ The entrance of the program.* * @param args Not used now.**********************/public static void main(String args[]) {int[] tempArray = { 1, 4, 5, 9 };SequentialList tempFirstList = new SequentialList(tempArray);System.out.println("After initialization, the list is: " + tempFirstList.toString());System.out.println("Again, the list is: " + tempFirstList);int tempValue = 4;int tempPosition = tempFirstList.indexOf(tempValue);System.out.println("The position of " + tempValue + " is " + tempPosition);tempValue = 5;tempPosition = tempFirstList.indexOf(tempValue);System.out.println("The position of " + tempValue + " is " + tempPosition);tempPosition = 2;tempValue = 5;tempFirstList.insert(tempPosition, tempValue);System.out.println("After inserting " + tempValue + " to position " + ", the list is: " + tempFirstList);tempPosition = 8;tempValue = 10;tempFirstList.insert(tempPosition, tempValue);System.out.println("After inserting " + tempValue + " to position " + tempPosition + ", the list is: " + tempFirstList);for (int i = 0; i < 8; i++) {tempFirstList.insert(i, i);System.out.println("After inserting " + i + " to position " + i + ", the list is: " + tempFirstList);} // Of for itempFirstList.reset();System.out.println("After reset, the list is: " + tempFirstList);}// Of main

运行结果

总结

1.顺序表的插入，删除，查找的时间复杂度都是O(n)
2.要注意把握逻辑结构与物理结构之间的度。我们谈论一个算法时，其逻辑结构更多是完成算法的设计，而实际的物理结构是完成算法的实现，因此在算法的实现过程中，我们必须时刻警惕计算机物理结构的特性，因为这种特性可能时时刻刻都会与我们的常规逻辑思维作对

---

Day13——链表

数据结构中的链表

特点：
1.逻辑上相邻的元素不一定在物理的位置上也相邻
2.实现插入和删除的效率更高，其插入只需要创建一个新结点并且修改链表中某逻辑上相连的两个结点之间的链接指针的关系即可，故时间复杂度为O(1)。
3.无法实现随机存取，这导致其无法像顺序表那样轻松用O(1)去访问特定位置，从而必须采用顺序存取对数据进行访问，访问的时间复杂度为O(1)。

Java中链表的实现

C语言提供的“指针”，更加类似于汇编语言的间接寻址能力，可以赋予程序员对内存操作的极大的灵活性，它使得程序员可以更直接地“操纵”硬件，获得高性能用 。C 语言比较容易获得地址信息,但用 Java 却做不到。Java中是如何实现链表的呢？

Java中用引用(Reference) 代替指针的作用，引用的声明类似与声明变量。声明一个孤单的对象时，会在内存中为其单独开辟一个小空间，这个空间内部是用于存放后期使用new为其分配空间后，用于存放分配空间的起始地址的。

下面的代码用于定义节点

 /*** An inner class*/class Node {/*** The data*/int data;/*** The reference to the next node*/Node next;/********************* * The constructor* * @param paraValue The data.******************* */public Node(int paraValue) {data = paraValue;next = null;}// Of the constructor}// Of class Node

链表的其他基本属性和构造函数:

 /*** The header node. The data is never used.*/Node header;/************************ Construct an empty linked list.**********************/public LinkedList() {header = new Node(0);}// Of the first constructor

链表的清空

让头节点的next指向null即可
对于Java来说，若系统发现不能通过引用访问的空间，则系统会自动将其回收。

 /************************ Reset to empty. Free the space through garbage collection.**********************/public void reset() {header.next = null;}// Of reset

链表的遍历

打印出链表数据：重写toString方法，先判断该链表是否为空，为空返回empty。第一步是创建工作结点，因为我们遍历只要求访问有效数据区域，因此工作结点是头指针的下个位置Node tempNode = header.next;第二步，通过while操作完成有效区域的迭代并输入到输出字符。最后返回输出字符。

 /************************ Overrides the method claimed in Object, the superclass of any class.**********************/public String toString() {String resultString = "";if (header.next == null) {return "empty";} // Of ifNode tempNode = header.next;while (tempNode != null) {resultString += tempNode.data + ", ";tempNode = tempNode.next;} // Of whilereturn resultString;}// Of toString

链表数据的查找

1.可与顺序表的查找作比较，相同点是都先设置默认下标值tempPosition为-1，若在空表情况下，while()循环不会执行，则直接跳过while直接返回时返回非法值告诫查无此数之作用。
2.不同点是在原来遍历基础上同步更新一个计数器，每进过一个节点，计算器自加一。我们的代码定义为头结点不纳入有效计数，那么第一个有效结点就是下标0（全链的第二个结点）,即计算器初始值为0.

 /************************ Locate the given value. If it appears in multiple positions, simply return* the first one.* * @param paraValue The given value.* @return The position. -1 for not found.**********************/public int locate(int paraValue) {int tempPosition = -1;Node tempNode = header.next;int tempCurrentPosition = 0;while (tempNode != null) {if (tempNode.data == paraValue) {tempPosition = tempCurrentPosition;break;} // Of iftempNode = tempNode.next;tempCurrentPosition++;} // Of whilereturn tempPosition;}// Of locate

链表的删除与插入

1. 删除操作

将前驱结点0的next指向我们的目标结点1的下一个结点

 public boolean delete(int paraPosition) {if (header.next == null) {System.out.println("Cannot delete element from an empty list.");return false;} // Of ifNode tempNode = header;for (int i = 0; i < paraPosition; i++) {if (tempNode.next.next == null) {System.out.println("The position " + paraPosition + " is illegal.");return false;} // Of iftempNode = tempNode.next;} // Of for itempNode.next = tempNode.next.next;return true;}// Of delete

2.插入操作

1.找到位置的复杂度为O(n),插入的复杂度为O(1)
2.例如：在结点2和结点1之间插入结点5，需先找到结点2的位置，后将新结点5的next指向我们的目标结点(结点2)，前结点1的next指针指向新结点5。

注：若操作顺序颠倒，会导致结点5无法找到后续结点

public boolean insert(int paraPosition, int paraValue) {Node tempNode = header;Node tempNewNode;for (int i = 0; i < paraPosition; i++) {if (tempNode.next == null) {System.out.println("The position " + paraPosition + " is illegal.");return false;} // Of iftempNode = tempNode.next;} // Of for i// Construct a new node.tempNewNode = new Node(paraValue);// Now link them.tempNewNode.next = tempNode.next;tempNode.next = tempNewNode;return true;}// Of insert

模拟

 public static void main(String args[]) {LinkedList tempFirstList = new LinkedList();System.out.println("Initialized, the list is: " + tempFirstList.toString());for (int i = 0; i < 5; i++) {tempFirstList.insert(0, i);} // Of for iSystem.out.println("Inserted, the list is: " + tempFirstList.toString());tempFirstList.insert(5, 100);//      tempFirstList.delete(4);//      tempFirstList.delete(2);System.out.println("Deleted, the list is: " + tempFirstList.toString());tempFirstList.delete(0);System.out.println("Deleted, the list is: " + tempFirstList.toString());for (int i = 0; i < 5; i++) {tempFirstList.delete(0);System.out.println("Looped delete, the list is: " + tempFirstList.toString());} // Of for i}// Of main

运行结果

---

Day14——栈

深入理解栈的特性

前两天的任务中分别复习，且加深印象了数据结构中的顺序表和链表。今天将开启对栈的深入学习

计算机中的“ 栈 ”(Stack)可以理解为暂时存储的容器。比如在函数调用时，底层编译器会把我们当前的数据放于这个临时的容器中存储，避免在进入函数后当前上下文环境的信息丢失，之后，待到函数返回后再从Stack中取出。

栈和队列是两种重要的线性结构。从数据结构角度看，栈和队列也是线性表，其特殊性在于栈和队列是线性表操作的子集，它们是操作受限的线性表。而栈按照后进先出(Last In First Out，简称LIFO)或先进后出(First In Last Out，简称FILO)的原则进行线性表，因此，栈又称为LIFO表或FILO表。

栈的操作

栈的创建

由于栈可看成“ 运算受限的线性表 ”，故按照创建线性表相似的方法创建栈
由构造函数完成栈深度（长度）初始化，空间开辟遵循静态链表开辟的方法——使用new开辟固定“MAX_DEPTH”大小的空间。
因为栈是有栈顶处进行插入和删除操作，故定义数组的最右侧为栈顶

 /*** The depth.*/public static final int MAX_DEPTH = 10;/*** The actual*/int depth;/*** The data*/char[] data;/************************ Construct an empty char stack.**********************/public CharStack() {depth = 0;data = new char[MAX_DEPTH];}// Of the first constructor/************************ Overrides the method claimed in Object, the superclass of any class.**********************/public String toString() {String resultString = "";for (int i = 0; i < depth; i++) {resultString += data[i];} // Of for ireturn resultString;}// Of toString

入栈操作

入栈操作是一个非常单纯的输入型函数，理论上是不会有返回值的。但是不同的语言的库可能会有不同的策略来对待，总之，我们在代码设置上，在函数返回后给用户提供了栈是否满的布尔信息，以方便用户对函数的处理。

 /************************ Push an element.* * @param paraChar The given char.* @return Success or not.**********************/public boolean push(char paraChar) {if (depth == MAX_DEPTH) {System.out.println("Stack full.");return false;} // Of ifdata[depth] = paraChar;depth++;return true;}// Of push

补充两种表示形式：
1.depth默认指向尾元素后面的空位
data[depth] = paraChar;
depth++;
2.栈顶指针指向末尾元素本身
top++
data[top] = paraChar;

出栈操作

出栈操作可以看做入栈的逆过程

 public char pop() {if (depth == 0) {System.out.println("Nothing to pop.");return '\0';} // Of ifchar resultChar = data[depth - 1];depth--;//栈顶指针指向栈顶有效元素的上方的一个无数据位return resultChar;}// Of pop

代码模拟

 public static void main(String args[]) {CharStack tempStack = new CharStack();for (char ch = 'a'; ch < 'm'; ch++) {tempStack.push(ch);System.out.println("The current stack is: " + tempStack);} // Of for chchar tempChar;for (int i = 0; i < 12; i++) {tempChar = tempStack.pop();System.out.println("Poped: " + tempChar);System.out.println("The current stack is: " + tempStack);} // Of for i}// Of main

运行结果

---

Day15——栈的应用：括号匹配

任务描述

1.检查一个字符串的括号是否匹配. 所谓匹配, 是指每个左括号有相应的一个右括号与之对应, 且左括号不可以出现在右括号右边. 可以修改测试字符串, 检查不同情况下的运行.
2.例如[]{}是正常匹配。(]不算，]][[不算，(({{[]}}))是匹配，(([[]}))不算。
当然我们的符号中间可以加任何其余干扰数字，(1 + 3 / ( 90 % {1 + {99 + [3 - 1] + 3} / 9} - 9) * 101)是匹配。

代码实现

package good_better;import org.omg.CORBA.PUBLIC_MEMBER;/*** Is the bracket matching?** @author Wanxiang Luo 2858442831@qq.com* @return Match or not.*/public class E_zhan {public static final int MAX_DEPTH = 10 ;int depth;char[] data;public  E_zhan() {depth = 0;data = new char [MAX_DEPTH];}public String toString() {String resultString = " ";for (int i = 0; i < data.length; i++) {resultString += data[i];}return resultString;}public boolean push (char paraChar) {if (depth == MAX_DEPTH) {System.out.println("Stack full.");return false;}//of ifdata[depth] = paraChar;depth++;return true;}public char pop() {if (depth == 0) {System.out.println("Nothing to pop.");return '\0';}//of if char resultChar = data[depth-1];depth--;return resultChar;}public static boolean bracketMatching(String paraString) {// Step 1. Initialize the stack through pushing a '#' at the bottom.E_zhan tempStack = new E_zhan();tempStack.push('#');char tempChar, tempPopedChar;// Step 2. Process the string. For a string, length() is a method// instead of a member variable.for (int i = 0; i < paraString.length(); i++) {tempChar = paraString.charAt(i);switch (tempChar) {case '(':case '[':case '{':tempStack.push(tempChar);break;case ')':tempPopedChar = tempStack.pop();if (tempPopedChar != '(') {return false;} // Of ifbreak;case ']':tempPopedChar = tempStack.pop();if (tempPopedChar != '[') {return false;} // Of ifbreak;case '}':tempPopedChar = tempStack.pop();if (tempPopedChar != '{') {return false;} // Of ifbreak;default:// Do nothing.}// Of switch} // Of fortempPopedChar = tempStack.pop();if (tempPopedChar != '#') {return false;} // Of ifreturn true;}// Of bracketMatchingpublic static void main(String[] args) {// TODO Auto-generated method stub
//          E_zhan tempStack = new E_zhan();/*for(char ch = 'a'; ch < 'm'; ch++) {tempStack.push(ch);System.out.println("The current stack is :" + tempStack);}//of for chchar tempChar ;for (int i = 0; i < 12; i++) {tempChar = tempStack.pop();System.out.println("Poped: " + tempChar);System.out.println("The current stack is : "+ tempStack );}//of for i*/boolean tempMatch;String tempExpression = "[2 + (1 - 3)] * 4";tempMatch = bracketMatching(tempExpression);System.out.println("Is the expression " + tempExpression + " bracket matching? " + tempMatch);tempExpression = "()  )";tempMatch = bracketMatching(tempExpression);System.out.println("Is the expression " + tempExpression + " bracket matching? " + tempMatch);tempExpression = "()()(())";tempMatch = bracketMatching(tempExpression);System.out.println("Is the expression " + tempExpression + " bracket matching? " + tempMatch);tempExpression = "({}[])";tempMatch = bracketMatching(tempExpression);System.out.println("Is the expression " + tempExpression + " bracket matching? " + tempMatch);tempExpression = ")(";tempMatch = bracketMatching(tempExpression);System.out.println("Is the expression " + tempExpression + " bracket matching? " + tempMatch);}//of for main }

运行结果

小结

1.当第1个括号到达时，它期待第4个括号与它匹配，但第2个括号会先到达，因此第1个括号会暂时等待。第2个括号期待第3个括号，第3个括号到达后，与第2个括号匹配，消掉一对括号，如此循环匹配下去。
2.我们使用栈暂存待匹配的括号。遇到左括号时，将其先压入栈；遇到右括号，从栈弹出一个元素，比较两是否匹配。
3.本代码使用前可以预先在栈底填入一个非法字符，可以方便避免一些空栈的麻烦判断，是一种非常常用的栈技巧

---

Day16——递归

1. 什么是递归？

答：递归，就是在运行的过程中调用自己。

2.递归的必要条件

其一：子问题须与原始问题为同样的事，且更为简单；
其二：不能无限制地调用本身，须有个出口，化简为非递归状况处理。

递归模板:
我们知道递归必须具备两个条件，一个是调用自己，一个是有终止条件。这两个条件必须同时具备，且一个都不能少。并且终止条件必须是在递归最开始的地方，也就是下面这样

public void recursion(参数0) {if (终止条件) {return;}recursion(参数1);
}

下面的代码是错误案例，不能把终止条件写在递归结束的位置
如果这样的话，递归永远退不出来了，就会出现堆栈溢出异常(StackOverflowError)

public void recursion(参数0) {recursion(参数1);if (终止条件) {return;}
}

但实际上递归可能调用自己不止一次，并且很多递归在调用之前或调用之后都会有一些逻辑上的处理，比如下面这样

public void recursion(参数0) {if (终止条件) {return;}可能有一些逻辑运算recursion(参数1)可能有一些逻辑运算recursion(参数2)……recursion(参数n)可能有一些逻辑运算
}

3.实例分析

0到N的相加

 /************************ Sum to N. No loop, however a stack is used* * @param paraN The given value.* @return The sum.**********************/public static int sumToN(int paraN) {if (paraN <= 0) {// Basisreturn 0;} // Of ifreturn sumToN(paraN - 1) + paraN;}// Of sumToN

斐波那契数列

我们知道斐波那契数列当前的值是前两个值的和，也就是fibonacci(n) =fibonacci(n - 1) + fibonacci(n - 2)
所以引出代码

 /************************ Fibonacci sequence.* * @param paraN The given value.* @return**********************/public static int fibonacci(int paraN) {if (paraN <= 0) {// Negative value are invalid. Index 0 corresponds to the first elementreturn 0;}if (paraN == 1) {// Basis.return 1;} // Of ifreturn fibonacci(paraN - 1) + fibonacci(paraN - 1);}// Of fibonacci

数据模拟

/************************ The entrance of the program.* * @param args Not used now.**********************/public static void main(String args[]) {int tempValue = 5;System.out.println("0 sum to " + tempValue + " = " + sumToN(tempValue));tempValue = -1;System.out.println("0 sum to " + tempValue + " = " + sumToN(tempValue));for (int i = 0; i < 10; i++) {System.out.println("Fibonacci " + i + ": " + fibonacci(i));} // Of for i}// Of main

运行结果

---

Day17——链表实现队列

队列的底层逻辑

定义：
队列是一种运算受限的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。当队列中没有元素时称为空队列

1.队列的基本操作近似于生活中无处不在的排队，对于每一个排队的人来说，来插队的家伙都不是那么人喜欢。
2.队列的基本操作中不允许有中途插队的选手，而对于线性表来说是可以在队中插入并麻烦之后的所有人都后退一步，故队列是运算受限的线性表。
3.队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队（enqueue），从队列中删除一个队列元素称为出队（Dequeue）。因为队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出（FIFO—first in first out）线性表。

用链表实现队列

1.定义结点

class Node {int data;Node next;/********************* * The constructor.* * @param paraValue The data.******************* */public Node(int paraValue) {data = paraValue;next = null;}// Of the constructor}// Of class Node

2.链队列的基本属性

 Node header;Node tail;/************************ Construct an empty sequential list.**********************/public LinkedQueue() {header = new Node(-1);tail = header;}// Of the first constructor@overridepublic String toString() {String resultString = "";if (header.next == null) {return "empty";} // Of ifNode tempNode = header.next;while (tempNode != null) {resultString += tempNode.data + ", ";tempNode = tempNode.next;} // Of whilereturn resultString;}// Of toString

3.入队

 /************************ Enqueue.* * @param paraValue The value of the new node.**********************/public void enqueue(int paraValue) {Node tempNode = new Node(paraValue);tail.next = tempNode;tail = tempNode;}// Of enqueue

4.出队

 public int dequeue() {if (header == tail) {System.out.println("No element in the queue");return -1;} // Of ifint resultValue = header.next.data;header.next = header.next.next;// The queue becomes empty.if (header.next == null) {tail = header;} // Of ifreturn resultValue;}// Of dequeu}// Of enqueue

代码模拟

/************************ The entrance of the program.* * @param args Not used now.**********************/public static void main(String args[]) {LinkedQueue tempQueue = new LinkedQueue();System.out.println("Initialized, the list is: " + tempQueue.toString());for (int i = 0; i < 5; i++) {tempQueue.enqueue(i + 1);} // Of for iSystem.out.println("Enqueue, the queue is: " + tempQueue.toString());tempQueue.dequeue();System.out.println("Dequeue, the queue is: " + tempQueue.toString());int tempValue;for (int i = 0; i < 5; i++) {tempValue = tempQueue.dequeue();System.out.println("Looped delete " + tempValue + ", the new queue is: " + tempQueue.toString());} // Of for ifor (int i = 0; i < 3; i++) {tempQueue.enqueue(i + 10);} // Of for iSystem.out.println("Enqueue, the queue is: " + tempQueue.toString());}// Of mainpublic static void main(String args[]) {LinkedQueue tempQueue = new LinkedQueue();System.out.println("Initialized, the list is: " + tempQueue.toString());for (int i = 0; i < 5; i++) {tempQueue.enqueue(i + 1);} // Of for iSystem.out.println("Enqueue, the queue is: " + tempQueue.toString());tempQueue.dequeue();System.out.println("Dequeue, the queue is: " + tempQueue.toString());int tempValue;for (int i = 0; i < 5; i++) {tempValue = tempQueue.dequeue();System.out.println("Looped delete " + tempValue + ", the new queue is: " + tempQueue.toString());} // Of for ifor (int i = 0; i < 3; i++) {tempQueue.enqueue(i + 10);} // Of for iSystem.out.println("Enqueue, the queue is: " + tempQueue.toString());}// Of main

运行结果

Day18——循环队列

寻常队列队头删除，队尾插入。对头元素出队后可能出现队头空间被浪费的情况。如果不断对队列进行入队、出队、入队、出队…首尾指针位置最终会变得非常大，但是队列内的数据却还是非常少，而且之前出队后空余的位置无法被重复使用，照成极大浪费。

特点

1、循环队列是队列的顺序存储结构
2、循环队列用判断是否为空利用 Q.front=Q.rear
3、循环队列头指针始终指向队列头元素，而尾指针始终指向队列尾元素的下一个位置
4、循环队列通过浪费一个空间，利用(Q.rear+1)%maxSize=Q.front判断队列是否为满，以此解决队列空间浪费问题（如下图所示）

代码实现

1.类的属性，构造器与遍历方法

 /*** The total space. One space can never can never be used*/public static final int TOTAL_SPACE = 10;int[] data;/*** The index for calculating the head. The actual head is head % TOTAL_SPACE.*/int head;/*** The index for caluculating the tail.*/int tail;/********************* * The constructor******************* */public CircleIntQueue() {data = new int[TOTAL_SPACE];head = 0;tail = 0;}// Of the first constructor/************************ Overrides the method claimed in Object, the superclass of any class.**********************/public String toString() {String resultString = "";if (head == tail) {return "empty";} // Of iffor (int i = head; i < tail; i++) {resultString += data[i % TOTAL_SPACE] + ", ";} // Of for ireturn resultString;}// Of toString

入队

 /************************ * @param paraValue The value of the new node.**********************/public void enqueue(int paraValue) {if((tail + 1)% TOTAL_SPACE ==  head ) {System.out.println("Queue full.");return;}// Of ifdata[tail % TOTAL_SPACE] = paraValue;tail++;}//Of enqueue

出队

 /************************ * @return The value at the head.**********************/public int dequeue() {if(head == tail) {System.out.println("No element in the queue");return -1;}//Of ifint resultValue = data[head % TOTAL_SPACE];head++;return resultValue;}//Of dequeue

main方法部分

 /************************ The entrance of the program.* * @param args Not used now.**********************/public static void main(String args[]) {CircleIntQueue tempQueue = new CircleIntQueue();System.out.println("Initialized, the list is: " + tempQueue.toString());for (int i = 0; i < 5; i++) {tempQueue.enqueue(i + 1);} // Of for iSystem.out.println("Enqueue, the queue is: " + tempQueue.toString());int tempValue = tempQueue.dequeue();System.out.println("Dequeue " + tempValue + ", the queue is: " + tempQueue.toString());for (int i = 0; i < 6; i++) {tempQueue.enqueue(i + 10);System.out.println("Enqueue, the queue is: " + tempQueue.toString());} // Of for ifor (int i = 0; i < 3; i++) {tempValue = tempQueue.dequeue();System.out.println("Dequeue " + tempValue + ", the queue is: " + tempQueue.toString());} // Of for ifor (int i = 0; i < 6; i++) {tempQueue.enqueue(i + 100);System.out.println("Enqueue, the queue is: " + tempQueue.toString());} // Of for i}// Of main

运行结果

小结

1.虽然循环队列的使用不像普通链表那样方便，却极适用与空间有限的硬件条件。
2.循环队列就体现其对于环对空间最大化利用的特性，弥补了单一顺序表使用队列时前端空间的浪费

---

Day19——自定义字符串

1 String 是 Java 常用的类, 这里重新实现下部分功能.
2 转义符 , 有了它才能正常打印引号.
3 简单的越界检查.

定义构造器与遍历方法

鉴于字符串的单个字符本身信息很少，用链表实现字符串冗余度大。故使用顺序表实现字符串。

    /*** The maximal length.*/public static final int MAX_LENGTH = 10;/*** The actual length*/int length;/*** The data.*/char[] data;/************************ Construct an empty char array.**********************/public MyString() {length = 0;data = new char[MAX_LENGTH];}// Of the first constructor

遍历方法：

    /************************ Overrides the method claimed in Object, the superclass of any class.**********************/public String toString() {String resultString = "";for (int i = 0; i < length; i++) {resultString += data[i];} // Of for ireturn resultString;}// Of toString/**

查找子串的方法

1.规定主串长度为(1 ≤ mainLength ≤ N)，字串长度为(1 ≤ patternLength ≤ mainLength),且模式串可以吻合到主串的任何一个不越界的连续部分
2.模式串逐个与主串切合去试着查看是否可以全部匹配。移动贴合的次数是mainLength - patternLength + 1。
3.每次贴合时都要对模式串进行循环，进行patternLength次逐个字符的从串遍历。
4.总执行次数是（mainLength - patternLength + 1）× patternLength，主串长度为N，模式串长度为M，那么这个算法的时间复杂度就是O(MN)

 /************************ Locate the position of a substring.* * @param paraMyString *                 The given substring.* @return The first position.*                 -1 for no matching.**********************/public int locate(MyString paraMyString) {boolean tempMatch = false;for (int i = 0; i < length - paraMyString.length + 1; i++) {// Initialize.tempMatch = true;for (int j = 0; j < paraMyString.length; j++) {if (data[i + j] != paraMyString.data[j]) {tempMatch = false;break;} // Of if} // Of for jif (tempMatch) {return i;} // Of of} // Of for ireturn -1;}// Of locate

外层循环负责模式串移动位置，mainLength - patternLength + 1显示剩余移动次数。内层循环负责检测当前主串的部分与模式串全体是否连续相等，一旦一次不等，那就取false返回，但凡又一次全等，tempMatch会保持不变，从而可以返回匹配，i刚好是本轮位置的第一个字符位。

字符串分片

给定第一个字符下标，然后给出片长

 /************************ Get a substring* * @param paraStartPosition *                The start position in the original string.* @param paraLength        *                 The length of the new string.* @return The first position. *               -1 for no matching.**********************/public MyString substring(int paraStartPosition, int paraLength) {//判断字串长度是否超过原字符串长度if (paraStartPosition + paraLength > length) {System.out.println("The bound is exceeded.");return null;} // Of ifMyString resultMyString = new MyString();resultMyString.length = paraLength;for (int i = 0; i < paraLength; i++) {resultMyString.data[i] = data[paraStartPosition + i];} // Of for ireturn resultMyString;}// Of substring

main方法部分

    /************************ The entrance of the program.* * @param args*            Not used now.**********************/public static void main(String args[]) {MyString tempFirstString = new MyString("I like ik.");MyString tempSecondString = new MyString("ik");int tempPosition = tempFirstString.locate(tempSecondString);System.out.println("The position of \"" + tempSecondString + "\" in \"" + tempFirstString+ "\" is: " + tempPosition);MyString tempThirdString = new MyString("ki");tempPosition = tempFirstString.locate(tempThirdString);System.out.println("The position of \"" + tempThirdString + "\" in \"" + tempFirstString + "\" is: " + tempPosition);tempThirdString = tempFirstString.substring(1, 2);System.out.println("The substring is: \"" + tempThirdString + "\"");tempThirdString = tempFirstString.substring(5, 5);System.out.println("The substring is: \"" + tempThirdString + "\"");tempThirdString = tempFirstString.substring(5, 6);System.out.println("The substring is: \"" + tempThirdString + "\"");}// Of main

运行结果

分析：
1.寻找模式串“ik" 在"I like ik”中的位置，返回的结果是3，字符串中的空格也算一个位置
2.寻找模式串“ki" 在"I like ik”中的位置，因为不存在，故返回-1
3.substring方法传入两个实参分别代表从原数组何位置开始和录入开始位置往后多少位。
传入（1，2）,则从"I like ik.”的第一位开始，即第一个I后的空格位。往后录入两为，故返回" l"
3.最后一个案例查询超过原字符串的长度，故报错

小结

1.字符串在计算机领域有着非常大的作用，个人认为可以把字符串看成，计算机世界和现实世界交流和传递信息的桥梁。字符串将不同模样，千奇百怪的数据统一起来（预处理），然后交付给计算机进行高速度机械式地计算，最后输出到我们现实中来。可以认为，字符串就是现实世界到我们计算机世界的第一层抽象。
2.11到19节的主要内容到此为止，线性表在计算机领域的应用远远不止与此。个人认为只有在不断的代码练习中，不断地接触不熟悉的领域，才能在机器学习算法的路上走远。

Day20——小结

1.面向对象与面向过程相比, 有哪些优势?

答：个人认为有以下几点：
1.面向过程编程难以在大型的复杂的程序开发中发挥作用，实际应用开发中往往是互相嵌套互相调用的程序占据主导，程序之间的关系更加复杂联系更紧密，而非以单一一条主线的形式出现。
2.面向对象编程则把复杂问题简单化，将现实世界不同的群体的共同特性和行为抽象出来，模拟成一个个逻辑设计的类。例如将’呼吸’、‘能直立行走’、'能用语言交流’等共性从人这个事物中抽象出来，形成一个类，称作人‘类’,那么‘呼吸’是其方法（行为），‘能直立行走’和‘能用语言交流’是其属性。再者不同的人种或者肤色可以独立出来，成为人类的子类。继续归类下去，能形成更多的子类，也就有更多的属性被囊括。最后不难推断出，在存储允许的条件下，人和其相关的事物都会归类其中。同样，理论上现实世界所有可以用语言描述的物种全可封装于某个类中。‘面向对象编程’记良方专治解决多元的，复杂多变的，庞大的问题。
3.面向对象编程相比面向过程编程，具有更加丰富的特性（封装、抽象、继承、多态）。
4.面向对象编程语言比起面向过程编程语言，更加人性化、更加高级、更加智能。
5.面向对象的代码更符合人的思维。代码，更加易扩展、易复用、易维护。

2.比较顺序表和链表的异同.

不同点：
1.线性表的储存采用连续的存储空间，链表采用链式的存储空间
2.顺序表支持随机访问，链表不支持随机访问
3.顺序表的插入和删除时间复杂度为O（n），链表的时间复杂度为O（1）
相同点：
1.查找的时间复杂度都为O（n）

3.分析顺序表和链表的优缺点.

顺序表的优点：
1.数据在物理上连续存储，方便使用
2.可随机访问
3.存储长期不改动数据占优势
缺点：
1.不适用数据经常改动的场景
2.易造成小空间的浪费
3.插入和删除操作效率低

链表的优点：
1.存储在逻辑上连续，节省空间
2.插入和删除方便
3.适用于数据经常改动的场景
缺点：
1.不可随机访问
2.频繁访问时效率低

4.分析调试程序常见的问题及解决方案

1.编译错误：通过返回的错误信息就能找出错误。并且记住错误，下次注意。
2.运行错误：检查代码的循环和递归处设置是否合理，是否有合理加入break。
3.输出错误：检查代码的逻辑是否符合题意，重新分析需要解决的问题，找到逻辑不通畅的位置，用自己的语言再捋一遍，最后反映到代码上

5.分析链队列与循环队列的优缺点.

链队列：
优点：链表存储，不用判断表是否满，操作方便
缺点：容易出现首尾指针位置最终非常大`，但是队列内的数据却还是非常少的情况，造成空间冗余

循环队列：
优点：空间利用高，不会造成冗余，
缺点：顺序表存储，整体大小是有限的，需要判断是否满

6.第 18 天建立的两个队列, 其区别仅在于基础数据不同, 一个是 int, 一个是 char. 按这种思路, 对于不同的基础数据类型, 都需要重写一个类, 这样合理吗? 你想怎么样?

不合理，这样处理不适合在两种数据类型差别不大的情况下，不满足面向对象思想，且会显得代码冗杂。可以使用泛型处理。

Java 11~~20相关推荐

1. java11 是长期支持_这里有你不得不了解的Java 11版本特性说明

   「MoreThanJava」 宣扬的是 「学习,不止 CODE」,本系列 Java 基础教程是自己在结合各方面的知识之后,对 Java 基础的一个总回顾,旨在 「帮助新朋友快速高质量的学习」. 当然 ...

2. Java 11 正式发布！

   有多少语言在提刀想反超 Java 的路上?但万万没想到,人家并未当回事,如今这款常青藤甚至越跑越欢,当我们还在使用 Java 7/8 时,它已经一路跑到了 11. 和预期的时间差不多,北京时间 9 月 ...

3. 顽皮狗 多线程分享_谁去过顽皮，谁去过尼斯？ 圣诞老人为您提供Java 11建议！...

   顽皮狗 多线程分享 有没有想过圣诞老人如何为世界各地的孩子们提供节日礼物? 有20亿个孩子,每个孩子都有自己的愿望清单,他会在24小时内完成. 这意味着平均每个孩子43微秒,他需要检查每个孩子是否顽皮 ...

4. java掌握_掌握Java 11的Constantdynamic

   java掌握 为了使JVM对动态语言更具吸引力,该平台的第七版已将invokedynamic引入了其指令集. Java开发人员通常不会注意到此功能,因为该功能已隐藏在Java字节码中. 简而言之,通过 ...

5. Java 11快多少？

   尽管大多数开发人员仍然使用Java 8 ,但Java 11还是在不久前发布的. 让我们看看其中哪个对OptaPlanner更快. 找出答案的最佳方法当然是运行OptaPlanner基准测试. 本文是我 ...

6. 谁去过顽皮，谁去过尼斯？ 圣诞老人为您提供Java 11建议！

   有没有想过圣诞老人如何为世界各地的孩子们送上节日礼物? 有20亿个孩子,每个孩子都有自己的愿望清单,他会在24小时内完成. 这意味着每个孩子平均需要43微秒,他需要检查每个孩子是否顽皮或好. 您无需再 ...

7. Java 11的期望

   过去的几年对Java世界一直是动荡不安的,在相当多的发行版中添加了各种各样的功能. 在开发人员社区中,人们逐渐意识到Java的开发速度不够快. 在最初的20年中,Java平台和Java开发工具包(JD ...

8. 掌握Java 11的Constantdynamic

   为了使JVM对动态语言更具吸引力,该平台的第七版已将invokedynamic引入了其指令集. Java开发人员通常不会注意到此功能,因为它隐藏在Java字节码中. 简而言之,通过使用invokedy ...

9. Eclipse 4.10.0 正式发布，全面拥抱 Java 11！

   近日,Eclipse 官方团队于推特正式宣布推出号称"史上最强"的版本更新--Eclipse IDE 2018-12,此前有过"路透"的新特性亦如约而至,其中就 ...

最新文章

1. spring cloud快速搭建
2. hdfs日志上传脚本(三)
3. python语言程序设计基础网课-宜昌2020年_高校邦_Python程序设计基础【实境编程】...
4. MapReduce-流量统计求和-排序-FlowBean编写
5. MapReduce-Combiner规约-原理分析
6. Lua_第17 章 数学库
7. 惠普再“卖身”，软件业务卖给了这家鼻祖级公司
8. 软件：推荐五款超级好用的电脑小众软件，值得收藏！
9. 读取数量不定的输入数据
10. CUDA C编程权威指南 第一章
11. 解决 ImportError: No module named 'pip._internal'问题
12. Golang系列（四）之面向接口编程
13. 手把手接入高德地图API——POI周边搜索功能实现
14. 企业经营核心要素框架
15. .net服务端渲染_驳：服务端命令 VS 表间公式
16. 高性能 MySQL实战
17. 如何判断计算机硬盘坏,电脑硬盘坏了会出现什么情况？怎么判断电脑是不是硬盘坏了...
18. execl批量创建文件夹乱码解决方案
19. 防汛数字孪生，厦门走在元宇宙前端！ | 专栏
20. linux 提取文件出错,pacman 错误：无法从 ××××获取文件 'core.db'

热门文章

1. 随机产生10个整数;设计一个算法找其中的最大的元素和最小的元素，并统计元素之间的比较次数
2. sun 公司的java 认证
3. C语言编程学习打造——做题游戏
4. Java压缩图片大小
5. 彩色图像、灰度图像、二值图像和索引图像
6. 【分享视频资源】React JS教程
7. oracle根据约束名查找具体信息，如是哪张表的哪个字段约束信息
8. http请求digest auth认证
9. 计算机考研要考科目,2022考研：计算机专业需要准备哪些科目？
10. 【GANs学习笔记】（一）初步了解GANs