数据结构与算法详解：从循环队列到哈希表
数据结构与算法
1.数组模拟循环队列
1.1. 实现的关键步骤：
1、front：指向队列的第一个元素
2、rear：指向队列的最后一个元素的后一个位置
3、maxSize：队列的最大容量，可以在初始化时定义；如果没定义，可设置默认值。
4、front 和 rear 的初始值为0
5、判空条件：(rear + 1)% maxSize == front
6、判满条件：rear == front
7、入队：判满、rear指针后移、赋值
8、出队：判空、front指针后移
9、获取队首元素：获取 front 指向的元素
10、打印队列：从 front指向的元素到 front + 队列元素的个数
11、队列元素的个数：(rear + maxSize - front) % maxSize
1.2. 实现代码
class ArrayQueue{
// 表示数组的最大容量
private int maxSize;
//front 指向队列的第一个元素
private int front;
//rear 指向队列的最后一个元素的后一个位置
private int rear;
// 模拟队列的数组，用于存放元素
private int[] arr;
public ArrayQueue(int arrMaxSize) {
// 初始化时，front 和 rear的初始值都为0，但由于int 本身默认值为 0 ，因此这里可以不用写
//最大值由外部指定（由于牺牲掉一个位置，所以例如传入4实际上只有3个位置）
maxSize = arrMaxSize;
// 创建数组存储
arr = new int[maxSize];
}
// 判断队列是否满
public boolean isFull() {
return (rear + 1) % maxSize == front;
}
// 判断队列是否为空
public boolean isEmpty() {
return rear == front;
}
// 添加数据到队列
public void addQueue(int n) {
// 判断队列是否满
if (isFull()) {
System.out.println("队列满，不能加入数据~");
return;
}
//直接将数据加入
arr[rear] = n;
//将 rear 后移, 这里必须考虑取模
rear = (rear + 1) % maxSize;
}
// 获取队列的数据, 出队列
public int getQueue() {
// 判断队列是否空
if (isEmpty()) {
// 通过抛出异常
throw new RuntimeException("队列空，不能取数据");
}
// 这里需要分析出 front是指向队列的第一个元素
// 1. 先把 front 对应的值保留到一个临时变量
// 2. 将 front 后移, 考虑取模
// 3. 将临时保存的变量返回
int value = arr[front];
front = (front + 1) % maxSize;
return value;
}
// 显示队列的所有数据
public void showQueue() {
// 遍历
if (isEmpty()) {
System.out.println("队列空的，没有数据~~");
return;
}
// 思路：从front开始遍历，遍历多少个元素
// 动脑筋
for (int i = front; i < front + size() ; i++) {
System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
}
}
// 求出当前队列有效数据的个数
public int size() {
// rear = 2
// front = 1
// maxSize = 3
return (rear + maxSize - front) % maxSize;
}
// 显示队列的头数据， 注意不是取出数据
public int headQueue() {
// 判断
if (isEmpty()) {
throw new RuntimeException("队列空的，没有数据~~");
}
return arr[front];
}
}
2. 单链表
2.1. 实现的关键步骤：
1、需要创建一个节点类（属性包括 数据域 和 指针域 next ）
2、需要创建一个链表类（属性包括头节点，初始化链表时，需要创建一个头节点，头节点没有实际意义）
3、增加–找到要插入位置的节点的前一个节点，然后先将节点与后一个节点连接，再将前面的节点连接。关键代码：node.next = temp.next;temp.next = node;
4、删除–找到要删除的节点的前一个节点，然后将引用修改为下下个节点。关键代码：temp.next = temp.next.next;
5、查看–找到要查看的节点并返回。关键代码：return temp;
6、修改–找到要修改的节点，然后修改其值即可。关键代码:temp.值 = 新值;
7、打印链表：先跳过头节点，然后遍历链表直到 temp 指向空时，打印链表的信息。
2.2. 实现代码
package com.cs.testt;
import java.util.Scanner;
/**
* @ClassName SingleLinkedListDemo
* @Description TODO
* @Author jiaqi
* @Date 2022/2/22 14:27
* @Version 1.0
**/
public class SingleLinkedListDemo {
public static void main(String[] args) {
SingleLinkedList singleLinkedList = new SingleLinkedList();
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("------------------------");
System.out.println("请输入以下字母：");
System.out.println("a(add):添加");
System.out.println("f(find):查找");
System.out.println("u(update):更新");
System.out.println("d(delete):删除");
System.out.println("p(print):打印");
System.out.println("o(out):退出程序");
System.out.println("------------------------");
String next = scanner.next();
if (next.charAt(0) == 'o') {
break;
}
switch (next.charAt(0)) {
case 'a':
System.out.println("请输入要添加的值：");
int item = scanner.nextInt();
singleLinkedList.add(item);
break;
case 'f':
System.out.println("请输入要查找的值：");
int item1 = scanner.nextInt();
Node node = singleLinkedList.find(item1);
if (node == null) {
System.out.println("没有找到对应的值");
} else {
System.out.println("找到的值为：" + node.num);
}
break;
case 'u':
System.out.println("请输入要旧的值：");
int oldN = scanner.nextInt();
System.out.println("请输入要新的值：");
int newN = scanner.nextInt();
boolean update = singleLinkedList.update(oldN, newN);
String s = update ? "更新成功" : "要更新的值根本不存在";
System.out.println(s);
break;
case 'd':
System.out.println("请输入要删除的值：");
int item3 = scanner.nextInt();
Node delete = singleLinkedList.delete(item3);
if (delete == null) {
System.out.println("没有找到对应的值");
} else {
System.out.println("已删除的值为：" + delete.num);
}
break;
case 'p':
String s1 = singleLinkedList.printList();
System.out.println(s1);
break;
default:
System.out.println("-------------------------------");
System.out.println("|您的输入格式有误，请重新输入: |");
System.out.println("-------------------------------");
break;
}
}
System.out.println("程序已退出...");
}
}
//链表类
class SingleLinkedList {
private Node head;
public SingleLinkedList() {
this.head = new Node(0, null);
}
//再链表的尾部添加一个节点
public void add(int num) {
Node temp = head;
while (true) {
if (temp.next == null) {
break;
}
temp = temp.next;
}
Node node = new Node(num, null);
temp.next = node;
}
// //根据编号添加一个节点（根据num从小到大排序）
// public void addByOrder(Node node){
// Node temp = head;
// while (true){
// if (temp.next == null){
// break;
// }
// if (temp.next.num >= node.num){
// break;
// }
// temp = temp.next;
// }
//
// node.next = temp.next;
// temp.next = node;
// }
public Node find(int num) {
Node temp = head.next;
while (true) {
if (temp == null) {
break;
}
if (temp.num == num) {
break;
}
temp = temp.next;
}
return temp;
}
public boolean update(int oldnum, int newNum) {
Node temp = head.next;
boolean flag = false;//是否找到旧值
while (true) {
if (temp == null) {
break;
}
if (temp.num == oldnum) {
flag = true;
break;
}
temp = temp.next;
}
if (flag) {
temp.num = newNum;
}
return flag;
}
public Node delete(int num) {
Node del = null;
Node temp = head;
while (true) {
if (temp.next == null) {//没有要找的节点
break;
}
if (temp.next.num == num) {
del = temp.next;
temp.next = temp.next.next;
break;
}
temp = temp.next;
}
return del;
}
public String printList() {
StringBuffer stringBuffer = new StringBuffer();
Node temp = head.next;
int count = 1;
while (true) {
if (temp == null) {
break;
}
stringBuffer.append("第" + count + "个值： " + temp.num + "\n");
temp = temp.next;
count++;
}
return stringBuffer.toString();
}
//计算节点的个数
public int NodeNum(){
int count = 0;
Node temp = head.next;
while (true){
if (temp == null){
break;
}
temp = temp.next;
count++;
}
return count;
}
//查找单链表中的倒数第k个节点（双指针法）
public Node findOrderByLast(int n){
//设置两个指针
Node temp1 = head.next;
Node temp2 = head.next;
while (true){
if (temp1 == null){
break;
}
if (n<1){
break;
}
temp1 = temp1.next;
n--;
}
while (true){
if (temp1 == null){
break;
}
temp1 = temp1.next;
temp2 = temp2.next;
}
return temp2;
}
//反转链表
public void reserve(Node head){
Node reserveHead = new Node(0,null);
Node temp = head.next;
Node cur;
while (true){
if (temp == null){
break;
}
cur = temp;
temp = temp.next;
cur.next = reserveHead.next;
reserveHead.next = cur;
}
head.next = reserveHead.next;
}
}
//节点类
class Node {
public int num;
public Node next;
public Node(int num, Node next) {
this.num = num;
this.next = next;
}
}
2.3. 拓展：
题目1：求一个单链表中节点的个数
方法：先创建一个变量作为计数器存储个数，初始值为 0 ，接着创建临时指针，循环遍历直到指针指向的节点为 null ，计数不断增加，最后跳出循环返回计数器。
题目2：查找单链表中的倒数第k个节点
方法1：双指针法。先让指针1和指针2指向第一个节点，接着指针1先走k个节点，然后让两个指针同时走，知道指针1走到null之后，指针2所指的节点即为所求。
方法2：先求出节点的个数（题目1），然后用节点个数减掉k得到需要走的步数，接着让指针走这么多步，即可。
题目3：单链表的反转。
方法：先创建一个新的头节点，然后遍历链表，当遍历到一个节点时将其放到新的头节点的后面的那个位置（每一个都如此），这样到最后的 temp == null 时停止，此时除了头节点外，其余都为所求，最后将旧的头节点指向新的头节点的下一个节点即可（即：head.next = nowHead.next;）,然后head。
题目4：从头到尾打印单链表（不可破坏原先链表的结构）
方法：用栈结构 Stack ，遍历链表，并将每个节点压入栈（stack.push），接着循环栈，当栈不为空时，出栈（stack.pop），打印出栈的元素即可。
题目5：合并两个有序的单链表，并且合并之后还是有序的
方法：先创建一个新的头节点，然后创建两个指针指向两个链表的第一个节点（非头节点），然后再创建一个指针记录指向新的头节点（用户每次添加）,循环直到有两个链表有一个指针为空为止，当哪个值比较小时，则让新链表的指针指向那个节点，并且新链表向后移动一个，指向的那个节点的指针也要向右移动，退出循环后，要将新链表的指针指向未结束的链表的指针的节点。最后返回头节点。
3. 双链表
3.1. 实现的关键步骤
1、需要创建一个节点类（属性包括 数据域 和指针域 next 和 pre ）
2、需要创建一个链表类（属性包括头节点，与单链表类似）
3、增加–节点到链表尾部：与单链表类似，通过遍历，然后连接
4、增加–节点到指定的位置：与单链表类似，找到前一个节点，然后改变指针域
5、删除–可以自我删除，这个是双链表的特点，指针 temp 可以直接指向待删除的节点，然后通过改变指针指向，即可。
6、查看和修改–与单链表类似，直接找到指定的节点进行操作
7、打印链表–与单链表一样
3.2. 实现代码：
package com.cs.testt;
/**
* @ClassName DoubleLinkedListDemo
* @Description TODO
* @Author jiaqi
* @Date 2022/2/23 14:27
* @Version 1.0
**/
//双向链表
public class DoubleLinkedListDemo {
}
class DoubleLinkedList{
private TNode head;
public DoubleLinkedList(){
this.head = new TNode(0,null,null);
}
//添加节点到尾部
public void addLast(TNode tNode){
TNode temp = head;
while (true){
if (temp.next == null){
break;
}
temp = temp.next;
}
temp.next = tNode;
tNode.pre = temp;
}
//根据值的大小（从小到大）添加节点
public void addOrder(TNode tNode){
TNode temp = head;
while (true){
if (temp.next == null){
break;
}
if (temp.next.num >=tNode.num){
break;
}
temp = temp.next;
}
if (temp.next == null){
temp.next = tNode;
tNode.pre = temp;
}else {
//没名字的先来
temp.next.pre = tNode;
tNode.next = temp.next;
temp.next = tNode;
tNode.pre = temp;
}
}
//删除指定值的节点(双向链表删除可以自删除)
public boolean delete(int num){
TNode temp = head.next;
//记录是否找到要删除的值
boolean flag = false;
while (true){
if (temp == null){
break;
}
if (temp.num == num){
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.pre.next = temp.next;
if (temp.next != null){
temp.next.pre = temp.pre;
}
}
return flag;
}
//修改节点
public boolean update(int oNum,int nNum){
//记录是否找到旧值
boolean flag = false;
TNode temp = head.next;
while (true){
if (temp == null){
//找不到
break;
}
if (temp.num == oNum){
//找到了
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.num = nNum;
}
return flag;
}
//查看
public TNode select(int num){
TNode temp = head.next;
while (true){
if (temp == null || temp.num == num){
return temp;
}
temp = temp.next;
}
}
//打印链表
public String printList(){
StringBuffer sb = new StringBuffer();
TNode temp = head.next;
int count = 1;
while (true){
if (temp == null){
break;
}
//打印节点
sb.append("第"+count+"个节点："+temp.num+"\n");
//指针移动1
temp = temp.next;
count++;
}
return sb.toString();
}
}
//(双向)节点类
class TNode{
public int num;
public TNode next;
public TNode pre;
public TNode(int num,TNode next,TNode pre){
this.num = num;
this.next = next;
this.pre = pre;
}
}
4. 单向环形链表
分为有头节点和无头节点。
经典问题：约瑟夫问题（可以用不带头节点的单向环形链表实现，用链表模拟，然后记录出圈顺序，然后改变节点的指向。）
5. 数组模拟栈（stack）
5.1. 实现的关键步骤
1、自己实现一个栈类，属性包括（栈的最大空间，栈顶指针（指向栈顶），模拟栈的数组）
2、初始化时，传入一个最大空间，然后创建一个这么大的数组，栈顶指针值为 -1
3、出栈：先 判断栈是否为空，再 int value = arr[top]; top --; return value;
4、入栈：先 判断栈是否为满，再 top++;arr[top] = value;
5、判满：top == maxSize - 1
6、判空：top == -1
7、打印栈：从栈顶打印到栈底，因此 for 循环从 位置 top 打印到 位置 0，即可。
5.2. 实现代码
略
5.3. 拓展
题目一：实现综合计算器题目。传入一个表达式字符串，返回表达式的计算结果。例如：传入字符串 7*2+5+1*5+3-4 ，返回结果为4 。
方法：
1、通过一个 index 指针，遍历这个字符串表达式
2、创建一个数字栈存数字，一个符号栈存符号
3、如果遍历到是一个数字，就直接入数栈
4、如果遍历到是一个符号，就分情况：
4.1、如果符号栈为空，直接入栈
4.2、如果符号栈不为空，就将当前符号的优先级与栈顶符号的优先级比较
4.2.1、如果当前操作符的优先级小于或等于栈顶操作符，则从数栈pop出两个数，符号栈pop出一个符号，进行运算，将运算结果存到数栈中，然后当前操作符入符号栈
4.2.2、如果当前操作符的优先级大于栈顶操作符，则直接入符号栈
5、当表达式扫描完毕，就顺序从数栈和符号栈中pop出相应的数和符号进行运算
6、最后，符号栈为空，数栈剩下一个数，这个数就是表达式的结果。
代码实现：（一位数的加减乘除）
package com.cs.testt;
/**
* @ClassName Test1
* @Description TODO
* @Author jiaqi
* @Date 2022/2/28 11:24
* @Version 1.0
**/
public class Test1 {
public static void main(String[] args) throws Exception {
//给你一个字符串表达式，返回一个表达式结果。
String s = "3+4*5+4-9-6*5";
ArrayStack numStcak = new ArrayStack(10);
ArrayStack operStack = new ArrayStack(10);
int index = 0;
while (true){
//判断index是否结束，结束就退出
if (index == s.length()){
break;
}
//先判断是否是操作符
if (isoper(s.charAt(index))){
//是操作符判断栈是否为空
if (operStack.isEmpty()){
//直接入栈
operStack.push(s.charAt(index));
}else {
//判断操作符的优先级
if (operf(s.charAt(index))>operf(operStack.peek())){
operStack.push(s.charAt(index));
}else {
int suan = suan(numStcak.pop(), numStcak.pop(), operStack.pop());
numStcak.push(suan);
operStack.push(s.charAt(index));
}
}
}else{
//是数字直接进数字栈
numStcak.push(s.charAt(index) -'0');
}
index++;
}
//index 走完之后
while (true){
if (operStack.isEmpty()){
break;
}
int suan = suan(numStcak.pop(), numStcak.pop(), operStack.pop());
numStcak.push(suan);
}
System.out.printf("%s = %d",s,numStcak.pop());
}
//判断传进来的是运算符还是数字
public static boolean isoper(int a){
if (a == '+' || a == '-' || a== '*'||a == '/'){
return true;
}else {
return false;
}
}
//传入两个数字和一个运算符，返回结果
public static int suan(int num1,int num2,int oper){
if (oper == '+'){
return num1 + num2;
}else if (oper == '-'){
return num2 - num1;
}else if (oper == '*'){
return num1 * num2;
}else if (oper == '/'){
return num2 / num1;
}else {
return -1;
}
}
//判断操作符的优先级
public static int operf(int oper){
if (oper == '*' || oper == '/'){
return 1;
}else if (oper == '+' || oper == '-'){
return 0;
}else {
return -1;
}
}
}
class ArrayStack{
private int top;
private int[] arr;
private int maxSize;
//初始化
public ArrayStack(int maxSize){
arr = new int[maxSize];
this.maxSize = maxSize;
top = -1;
}
//判断满
public boolean isFull(){
return top == maxSize - 1;
}
public boolean isEmpty(){
return top == -1;
}
//入栈
public void push(int num) throws Exception {
if (isFull()){
throw new Exception("栈满");
}
top++;
arr[top] = num;
}
//出栈
public int pop() throws Exception {
if (isEmpty()){
throw new Exception("栈空");
}
int temp = arr[top];
top--;
return temp;
}
//查看栈顶元素
public int peek() throws Exception {
if (isEmpty()){
throw new Exception("栈空");
}
return arr[top];
}
}
代码实现：（多位数的加减乘除）
package com.cs.testt;
/**
* @ClassName Test1
* @Description TODO
* @Author jiaqi
* @Date 2022/2/28 11:24
* @Version 1.0
**/
public class Test1 {
public static void main(String[] args) throws Exception {
//给你一个字符串表达式，返回一个表达式结果。
String s = "30+4*5+4-9-6*5";
ArrayStack numStcak = new ArrayStack(10);
ArrayStack operStack = new ArrayStack(10);
int index = 0;
while (true){
//判断index是否结束，结束就退出
if (index == s.length()){
break;
}
//先判断是否是操作符
if (isoper(s.charAt(index))){
//是操作符判断栈是否为空
if (operStack.isEmpty()){
//直接入栈
operStack.push(s.charAt(index));
}else {
//判断操作符的优先级
if (operf(s.charAt(index))>operf(operStack.peek())){
operStack.push(s.charAt(index));
}else {
int suan = suan(numStcak.pop(), numStcak.pop(), operStack.pop());
numStcak.push(suan);
operStack.push(s.charAt(index));
}
}
index++;
}else{
//是数字直接进数字栈
//numStcak.push(s.charAt(index) -'0');
int sum = 0;
while (true){
if (s.length() == index || isoper(s.charAt(index))){
break;
}
sum = sum * 10 + (s.charAt(index) - '0');
index++;
}
numStcak.push(sum);
}
}
//index 走完之后
while (true){
if (operStack.isEmpty()){
break;
}
int suan = suan(numStcak.pop(), numStcak.pop(), operStack.pop());
numStcak.push(suan);
}
System.out.printf("%s = %d",s,numStcak.pop());
}
//判断传进来的是运算符还是数字
public static boolean isoper(int a){
if (a == '+' || a == '-' || a== '*'||a == '/'){
return true;
}else {
return false;
}
}
//传入两个数字和一个运算符，返回结果
public static int suan(int num1,int num2,int oper){
if (oper == '+'){
return num1 + num2;
}else if (oper == '-'){
return num2 - num1;
}else if (oper == '*'){
return num1 * num2;
}else if (oper == '/'){
return num2 / num1;
}else {
return -1;
}
}
//判断操作符的优先级
public static int operf(int oper){
if (oper == '*' || oper == '/'){
return 1;
}else if (oper == '+' || oper == '-'){
return 0;
}else {
return -1;
}
}
}
class ArrayStack{
private int top;
private int[] arr;
private int maxSize;
//初始化
public ArrayStack(int maxSize){
arr = new int[maxSize];
this.maxSize = maxSize;
top = -1;
}
//判断满
public boolean isFull(){
return top == maxSize - 1;
}
public boolean isEmpty(){
return top == -1;
}
//入栈
public void push(int num) throws Exception {
if (isFull()){
throw new Exception("栈满");
}
top++;
arr[top] = num;
}
//出栈
public int pop() throws Exception {
if (isEmpty()){
throw new Exception("栈空");
}
int temp = arr[top];
top--;
return temp;
}
//查看栈顶元素
public int peek() throws Exception {
if (isEmpty()){
throw new Exception("栈空");
}
return arr[top];
}
}
前缀表达式（波兰表达式，从右向左扫描）：- * + 3 4 5 6 计算机容易理解的形式，人类不容易理解
中缀表达式：(3 + 4)*5-6 人类容易理解的形式，计算机不容易理解
后缀表达式（逆波兰表达式，从左向右扫描）：3 4 + 5 * 6 -计算机容易理解的形式，人类不容易理解
前面的扩展就是我们将中缀表达式表达给计算机，很复杂，又得考虑优先级，计算机很难理解，因此编码难度大。因此一般我们是先将中缀表达式转换成其它表达式（一般是后缀表达式，因为最容易转换）的，然后再给计算机计算。
一般是先将中缀表达式转换为后缀表达式，然后再从左到右进行计算后缀表达式，计算的规矩是：从左到右扫描表达式，遇到数字就压入栈，遇到运算符就弹出两个数字，用运算符对他们进行运算，并将结果入栈，重复上诉操作直到表达式的最右端，最后运算得到的值则为结果。
6. 递归
6.1. 递归在实际开发中可以解决什么问题？
八皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子问题，快排，归并排序，二分查找，分治查找 等等。
6.2. 递归的常见形式
个人理解：通常的递归都是 链式 或者 发散式。例如：打印 1- n 就是链式，打印二叉树就是 发散式。一般来说，一个方法包含链式或发散式中的一个节点（发散式只是多了可以选择的路径而已）。
链式：
public 返回值 方法名(第一个节点需要的数据){
//退出条件，一般是结束条件
if(结束的标志){
return xx;
}
返回值 = 方法名(一般是第一个节点的后续);
return 返回值
}
发散式：
public 返回值 方法名(第一个节点需要的数据){
//退出条件，一般是结束条件
if(结束的标志){
return xx;
}
if(满足链路1){
返回值 = 方法名(一般是第一个节点的后续);
return 返回值
}
if(满足链路2){
返回值 = 方法名(一般是第一个节点的后续);
return 返回值
}
}
6. 排序算法
6.1. 冒泡排序
package com.atguigu.sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class BubbleSort {
public static void main(String[] args) {
// int arr[] = {3, 9, -1, 10, 20};
//
// System.out.println("排序前");
// System.out.println(Arrays.toString(arr));
//为了容量理解，我们把冒泡排序的演变过程，给大家展示
//测试一下冒泡排序的速度O(n^2), 给80000个数据，测试
//创建要给80000个的随机的数组
int[] arr = new int[80000];
for(int i =0; i < 80000;i++) {
arr[i] = (int)(Math.random() * 8000000); //生成一个[0, 8000000) 数
}
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是=" + date1Str);
//测试冒泡排序
bubbleSort(arr);
Date data2 = new Date();
String date2Str = simpleDateFormat.format(data2);
System.out.println("排序后的时间是=" + date2Str);
//System.out.println("排序后");
//System.out.println(Arrays.toString(arr));
/*
// 第二趟排序，就是将第二大的数排在倒数第二位
for (int j = 0; j < arr.length - 1 - 1 ; j++) {
// 如果前面的数比后面的数大，则交换
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println("第二趟排序后的数组");
System.out.println(Arrays.toString(arr));
// 第三趟排序，就是将第三大的数排在倒数第三位
for (int j = 0; j < arr.length - 1 - 2; j++) {
// 如果前面的数比后面的数大，则交换
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println("第三趟排序后的数组");
System.out.println(Arrays.toString(arr));
// 第四趟排序，就是将第4大的数排在倒数第4位
for (int j = 0; j < arr.length - 1 - 3; j++) {
// 如果前面的数比后面的数大，则交换
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println("第四趟排序后的数组");
System.out.println(Arrays.toString(arr)); */
}
// 将前面额冒泡排序算法，封装成一个方法
public static void bubbleSort(int[] arr) {
// 冒泡排序 的时间复杂度 O(n^2), 自己写出
int temp = 0; // 临时变量
boolean flag = false; // 标识变量，表示是否进行过交换
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]) {
flag = true;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
//System.out.println("第" + (i + 1) + "趟排序后的数组");
//System.out.println(Arrays.toString(arr));
if (!flag) { // 在一趟排序中，一次交换都没有发生过
break;
} else {
flag = false; // 重置flag!!!, 进行下次判断
}
}
}
}
6.2. 插入排序
package com.atguigu.sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class InsertSort {
public static void main(String[] args) {
//int[] arr = {101, 34, 119, 1, -1, 89};
// 创建要给80000个的随机的数组
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
}
System.out.println("插入排序前");
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是=" + date1Str);
insertSort(arr); //调用插入排序算法
Date data2 = new Date();
String date2Str = simpleDateFormat.format(data2);
System.out.println("排序前的时间是=" + date2Str);
//System.out.println(Arrays.toString(arr));
}
//插入排序
public static void insertSort(int[] arr) {
int insertVal = 0;
int insertIndex = 0;
//使用for循环来把代码简化
for(int i = 1; i < arr.length; i++) {
//定义待插入的数
insertVal = arr[i];
insertIndex = i - 1; // 即arr[1]的前面这个数的下标
// 给insertVal 找到插入的位置
// 说明
// 1. insertIndex >= 0 保证在给insertVal 找插入位置，不越界
// 2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置
// 3. 就需要将 arr[insertIndex] 后移
while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
insertIndex--;
}
// 当退出while循环时，说明插入的位置找到, insertIndex + 1
// 举例：理解不了，我们一会 debug
//这里我们判断是否需要赋值
if(insertIndex + 1 != i) {
arr[insertIndex + 1] = insertVal;
}
//System.out.println("第"+i+"轮插入");
//System.out.println(Arrays.toString(arr));
}
/*
//使用逐步推导的方式来讲解，便利理解
//第1轮 {101, 34, 119, 1}; => {34, 101, 119, 1}
//{101, 34, 119, 1}; => {101,101,119,1}
//定义待插入的数
int insertVal = arr[1];
int insertIndex = 1 - 1; //即arr[1]的前面这个数的下标
//给insertVal 找到插入的位置
//说明
//1. insertIndex >= 0 保证在给insertVal 找插入位置，不越界
//2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置
//3. 就需要将 arr[insertIndex] 后移
while(insertIndex >= 0 && insertVal < arr[insertIndex] ) {
arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
insertIndex--;
}
//当退出while循环时，说明插入的位置找到, insertIndex + 1
//举例：理解不了，我们一会 debug
arr[insertIndex + 1] = insertVal;
System.out.println("第1轮插入");
System.out.println(Arrays.toString(arr));
//第2轮
insertVal = arr[2];
insertIndex = 2 - 1;
while(insertIndex >= 0 && insertVal < arr[insertIndex] ) {
arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
insertIndex--;
}
arr[insertIndex + 1] = insertVal;
System.out.println("第2轮插入");
System.out.println(Arrays.toString(arr));
//第3轮
insertVal = arr[3];
insertIndex = 3 - 1;
while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
insertIndex--;
}
arr[insertIndex + 1] = insertVal;
System.out.println("第3轮插入");
System.out.println(Arrays.toString(arr)); */
}
}
6.3. 选择排序
package com.atguigu.sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
//选择排序
public class SelectSort {
public static void main(String[] args) {
//int [] arr = {101, 34, 119, 1, -1, 90, 123};
//创建要给80000个的随机的数组
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++) {
arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
}
System.out.println("排序前");
//System.out.println(Arrays.toString(arr));
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是=" + date1Str);
selectSort(arr);
Date data2 = new Date();
String date2Str = simpleDateFormat.format(data2);
System.out.println("排序前的时间是=" + date2Str);
//System.out.println("排序后");
//System.out.println(Arrays.toString(arr));
}
//选择排序
public static void selectSort(int[] arr) {
//在推导的过程，我们发现了规律，因此，可以使用for来解决
//选择排序时间复杂度是 O(n^2)
for (int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
int min = arr[i];
for (int j = i + 1; j < arr.length; j++) {
if (min > arr[j]) { // 说明假定的最小值，并不是最小
min = arr[j]; // 重置min
minIndex = j; // 重置minIndex
}
}
// 将最小值，放在arr[0], 即交换
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
//System.out.println("第"+(i+1)+"轮后~~");
//System.out.println(Arrays.toString(arr));// 1, 34, 119, 101
}
/*
//使用逐步推导的方式来，讲解选择排序
//第1轮
//原始的数组 ： 101, 34, 119, 1
//第一轮排序 : 1, 34, 119, 101
//算法 先简单--》 做复杂， 就是可以把一个复杂的算法，拆分成简单的问题-》逐步解决
//第1轮
int minIndex = 0;
int min = arr[0];
for(int j = 0 + 1; j < arr.length; j++) {
if (min > arr[j]) { //说明假定的最小值，并不是最小
min = arr[j]; //重置min
minIndex = j; //重置minIndex
}
}
//将最小值，放在arr[0], 即交换
if(minIndex != 0) {
arr[minIndex] = arr[0];
arr[0] = min;
}
System.out.println("第1轮后~~");
System.out.println(Arrays.toString(arr));// 1, 34, 119, 101
//第2轮
minIndex = 1;
min = arr[1];
for (int j = 1 + 1; j < arr.length; j++) {
if (min > arr[j]) { // 说明假定的最小值，并不是最小
min = arr[j]; // 重置min
minIndex = j; // 重置minIndex
}
}
// 将最小值，放在arr[0], 即交换
if(minIndex != 1) {
arr[minIndex] = arr[1];
arr[1] = min;
}
System.out.println("第2轮后~~");
System.out.println(Arrays.toString(arr));// 1, 34, 119, 101
//第3轮
minIndex = 2;
min = arr[2];
for (int j = 2 + 1; j < arr.length; j++) {
if (min > arr[j]) { // 说明假定的最小值，并不是最小
min = arr[j]; // 重置min
minIndex = j; // 重置minIndex
}
}
// 将最小值，放在arr[0], 即交换
if (minIndex != 2) {
arr[minIndex] = arr[2];
arr[2] = min;
}
System.out.println("第3轮后~~");
System.out.println(Arrays.toString(arr));// 1, 34, 101, 119 */
}
}
6.4. 快速排序
package com.atguigu.sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class QuickSort {
public static void main(String[] args) {
//int[] arr = {-9,78,0,23,-567,70, -1,900, 4561};
//测试快排的执行速度
// 创建要给80000个的随机的数组
int[] arr = new int[8000000];
for (int i = 0; i < 8000000; i++) {
arr[i] = (int) (Math.random() * 8000000); // 生成一个[0, 8000000) 数
}
System.out.println("排序前");
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是=" + date1Str);
quickSort(arr, 0, arr.length-1);
Date data2 = new Date();
String date2Str = simpleDateFormat.format(data2);
System.out.println("排序前的时间是=" + date2Str);
//System.out.println("arr=" + Arrays.toString(arr));
}
public static void quickSort(int[] arr,int left, int right) {
int l = left; //左下标
int r = right; //右下标
//pivot 中轴值
int pivot = arr[(left + right) / 2];
int temp = 0; //临时变量，作为交换时使用
//while循环的目的是让比pivot 值小放到左边
//比pivot 值大放到右边
while( l < r) {
//在pivot的左边一直找,找到大于等于pivot值,才退出
while( arr[l] < pivot) {
l += 1;
}
//在pivot的右边一直找,找到小于等于pivot值,才退出
while(arr[r] > pivot) {
r -= 1;
}
//如果l >= r说明pivot 的左右两的值，已经按照左边全部是
//小于等于pivot值，右边全部是大于等于pivot值
if( l >= r) {
break;
}
//交换
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
//如果交换完后，发现这个arr[l] == pivot值 相等 r--， 前移
if(arr[l] == pivot) {
r -= 1;
}
//如果交换完后，发现这个arr[r] == pivot值 相等 l++， 后移
if(arr[r] == pivot) {
l += 1;
}
}
// 如果 l == r, 必须l++, r--, 否则为出现栈溢出
if (l == r) {
l += 1;
r -= 1;
}
//向左递归
if(left < r) {
quickSort(arr, left, r);
}
//向右递归
if(right > l) {
quickSort(arr, l, right);
}
}
}
7.查找
7.1. 二分查找
package com.atguigu.search;
import java.util.ArrayList;
import java.util.List;
//注意：使用二分查找的前提是 该数组是有序的.
public class BinarySearch {
public static void main(String[] args) {
//int arr[] = { 1, 8, 10, 89,1000,1000, 1234 };
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 , 11, 12, 13,14,15,16,17,18,19,20 };
//
// int resIndex = binarySearch(arr, 0, arr.length - 1, 1000);
// System.out.println("resIndex=" + resIndex);
List<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1, 1);
System.out.println("resIndexList=" + resIndexList);
}
// 二分查找算法
/**
*
* @param arr
* 数组
* @param left
* 左边的索引
* @param right
* 右边的索引
* @param findVal
* 要查找的值
* @return 如果找到就返回下标，如果没有找到，就返回 -1
*/
public static int binarySearch(int[] arr, int left, int right, int findVal) {
// 当 left > right 时，说明递归整个数组，但是没有找到
if (left > right) {
return -1;
}
int mid = (left + right) / 2;
int midVal = arr[mid];
if (findVal > midVal) { // 向 右递归
return binarySearch(arr, mid + 1, right, findVal);
} else if (findVal < midVal) { // 向左递归
return binarySearch(arr, left, mid - 1, findVal);
} else {
return mid;
}
}
//完成一个课后思考题:
/*
* 课后思考题： {1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中，
* 有多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000
*
* 思路分析
* 1. 在找到mid 索引值，不要马上返回
* 2. 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
* 3. 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
* 4. 将Arraylist返回
*/
public static List<Integer> binarySearch2(int[] arr, int left, int right, int findVal) {
System.out.println("hello~");
// 当 left > right 时，说明递归整个数组，但是没有找到
if (left > right) {
return new ArrayList<Integer>();
}
int mid = (left + right) / 2;
int midVal = arr[mid];
if (findVal > midVal) { // 向 右递归
return binarySearch2(arr, mid + 1, right, findVal);
} else if (findVal < midVal) { // 向左递归
return binarySearch2(arr, left, mid - 1, findVal);
} else {
// * 思路分析
// * 1. 在找到mid 索引值，不要马上返回
// * 2. 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
// * 3. 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
// * 4. 将Arraylist返回
List<Integer> resIndexlist = new ArrayList<Integer>();
//向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
int temp = mid - 1;
while(true) {
if (temp < 0 || arr[temp] != findVal) {//退出
break;
}
//否则，就temp 放入到 resIndexlist
resIndexlist.add(temp);
temp -= 1; //temp左移
}
resIndexlist.add(mid); //
//向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
temp = mid + 1;
while(true) {
if (temp > arr.length - 1 || arr[temp] != findVal) {//退出
break;
}
//否则，就temp 放入到 resIndexlist
resIndexlist.add(temp);
temp += 1; //temp右移
}
return resIndexlist;
}
}
}
8. 哈希表
8.1. 模拟HashTable代码
package com.cs.testt;
/**
* @ClassName HashDemo
* @Description TODO
* @Author jiaqi
* @Date 2022/3/7 0:03
* @Version 1.0
**/
public class HashDemo {
public static void main(String[] args) {
MyHashTable myHashTable = new MyHashTable(7);
System.out.println(myHashTable.print());
myHashTable.add(new Student(1,"jack",21));
myHashTable.add(new Student(2,"jack",21));
myHashTable.add(new Student(3,"oo",21));
myHashTable.add(new Student(4,"jack",21));
myHashTable.add(new Student(5,"jack",21));
myHashTable.add(new Student(6,"jack",21));
myHashTable.add(new Student(7,"jack",21));
myHashTable.add(new Student(8,"jack",21));
myHashTable.deleteById(7);
myHashTable.updete(new Student(4,"tom",11));
System.out.println(myHashTable.get(3));
System.out.println(myHashTable.print());
}
}
//数组类
class MyHashTable{
private LinkedList[] linkedLists;
private int size;//多少条链表
public MyHashTable(int size){
this.size = size;
linkedLists = new LinkedList[size];
}
//添加元素
public void add(Student stu){
//根据id获取到散列的位置
int i = myHash(stu.getId());
if (linkedLists[i] == null){
linkedLists[i] = new LinkedList();
}
linkedLists[i].add(stu);
}
//根据id获取到学生的值(默认id是不重复的)
public Student get(int id){
int i = myHash(id);
if (linkedLists[i] == null){
return null;
}
Student student = linkedLists[i].get(id);
return student;
}
//遍历元素
public String print(){
StringBuffer stringBuffer = new StringBuffer();
for (int i = 0; i < size; i++) {
if (linkedLists[i] == null){
continue;
}
stringBuffer.append(linkedLists[i].print());
}
return stringBuffer.toString();
}
//散列方法
private int myHash(int id){
return id % size;
}
//根据id删除一个学生
public Student deleteById(int id){
int i = myHash(id);
if (linkedLists[i] == null){
return null;
}
Student delete = linkedLists[i].delete(id);
return delete;
}
//修改一个学生的数据
public boolean updete(Student stu){
//根据id找到数据并更新，找到返回true，找不到返回false
int i = myHash(stu.getId());
if (linkedLists[i] == null){
return false;
}
boolean upd = linkedLists[i].upd(stu);
return upd;
}
}
//链表类
class LinkedList{
//头节点：表示第一个数据，默认为空
private Student head;
public LinkedList(){
head = null;
}
//添加数据:根据一个值，添加到链表的尾部
public void add(Student stu){
//临时指针
Student temp = head;
//头节点都为空
if (temp == null){
head = stu;
return;
}
while (true){
if (temp.next == null){
temp.next = stu;
break;
}
temp = temp.next;
}
}
//根据id获取数据
public Student get(int id){
//临时指针
Student temp = head;
while (true){
if (temp == null || temp.getId() == id){
return temp;
}
temp = temp.next;
}
}
public StringBuffer print(){
StringBuffer sb = new StringBuffer();
Student temp = head;
while (true){
if (temp == null){
break;
}
sb.append(temp.toString());
temp = temp.next;
}
return sb;
}
//根据id删除一个学生
public Student delete(int id){
Student temp = head;
//如果头节点为空
if (temp == null){
return temp;
}
//如果删除的是头节点
if (temp.getId() == id){
Student result = temp;
head = temp.next;
return result;
}
while (true){
if (temp.next == null){
return temp.next;
}
if (temp.next.getId() == id){
Student result = temp.next;
temp.next =temp.next.next;
return result;
}
temp = temp.next;
}
}
public boolean upd(Student stu){
Student temp = head;
while (true){
if (temp == null){
return false;
}
if (temp.getId() == stu.getId()){
temp.setName(stu.getName());
temp.setAge(stu.getAge());
return true;
}
temp = temp.next;
}
}
}
//封装学生数据
class Student{
private int id;
private String name;
private int age;
public Student next;
public Student(int id,String name,int age){
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}' +
'\n';
}
}
9. 二叉树
9.1. 代码实现二叉树/中前后序遍历/打印二叉树
package com.cs.testt;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName BinaryTree
* @Description TODO 二叉树
* @Author jiaqi
* @Date 2022/3/7 15:26
* @Version 1.0
**/
public class BinaryTree {
private TreeNode root; //根节点
public BinaryTree(){
root = null;
}
//按关键字查找节点
public TreeNode find(int key){
TreeNode cur = root; //从根节点开始查找
if(cur == null){ //如果树为空，直接返回null
return null;
}
while(cur.age != key){
if(key < cur.age){
cur = cur.leftChild; //如果关键字比当前节点小，转向左子节点
}else{
cur = cur.leftChild; //如果关键字比当前节点大，转向右子节点
}
if(cur == null){ //没有找到结果，搜索结束
return null;
}
}
return cur;
}
//插入新节点
public void insert(TreeNode node){
if(root == null){
root = node; //如果树为空，则新插入的节点为根节点
}else{
TreeNode cur = root;
while(true){
if(node.age < cur.age){
if(cur.leftChild == null){ //找到了要插入节点的父节点
cur.leftChild = node;
return;
}
cur = cur.leftChild;
}else{
if(cur.rightChild == null){ //找到了要插入节点的父节点
cur.rightChild = node;
return;
}
cur = cur.rightChild;
}
}
}
}
//删除指定节点
public boolean delete(TreeNode node){
if(root == null){
return false; //如果为空树，直接返回false
}
boolean isLeftChild = true; //记录目标节点是否为父节点的左子节点
TreeNode cur= root; //要删除的节点
TreeNode parent = null; //要删除节点的父节点
while(cur.age != node.age){ //确定要删除节点和它的父节点
parent = cur;
if(node.age < cur.age){ //目标节点小于当前节点，跳转左子节点
cur = cur.leftChild;
}else{//目标节点大于当前节点，跳转右子节点
isLeftChild = false;
cur = cur.rightChild;
}
if(cur == null){
return false; //没有找到要删除的节点
}
}
if(cur.leftChild == null && cur.rightChild == null){ //目标节点为叶子节点（无子节点）
if(cur == root){ //要删除的为根节点
root = null;
}else if(isLeftChild){
//要删除的不是根节点，则该节点肯定有父节点，该节点删除后，需要将父节点指向它的引用置空
parent.leftChild = null;
}else{
parent.rightChild = null;
}
}else if(cur.leftChild == null){ //只有一个右子节点
if(cur == root){
root = cur.rightChild;
}else if(isLeftChild){
parent.leftChild = cur.rightChild;
}else{
parent.rightChild = cur.rightChild;
}
}else if(cur.rightChild == null){ //只有一个左子节点
if(cur == root){
root = cur.leftChild;
}else if(isLeftChild){
parent.leftChild = cur.leftChild;
}else{
parent.rightChild = cur.leftChild;
}
}else{ //有两个子节点
//第一步要找到欲删除节点的后继节点
TreeNode successor = cur.rightChild;
TreeNode successorParent = null;
while(successor.leftChild != null){
successorParent = successor;
successor = successor.leftChild;
}
//欲删除节点的右子节点就是它的后继，证明该后继无左子节点，则将以后继节点为根的子树上移即可
if(successorParent == null){
if(cur == root){ //要删除的为根节点，则将后继设置为根，且根的左子节点设置为欲删除节点的做左子节点
root = successor;
root.leftChild = cur.leftChild;
}else if(isLeftChild){
parent.leftChild = successor;
successor.leftChild = cur.leftChild;
}else{
parent.rightChild = successor;
successor.leftChild = cur.leftChild;
}
}else{ //欲删除节点的后继不是它的右子节点
successorParent.leftChild = successor.rightChild;
successor.rightChild = cur.rightChild;
if(cur == root){
root = successor;
root.leftChild = cur.leftChild;
}else if(isLeftChild){
parent.leftChild = successor;
successor.leftChild = cur.leftChild;
}else{
parent.rightChild = successor;
successor.leftChild = cur.leftChild;
}
}
}
return true;
}
public static final int PREORDER = 1; //前序遍历
public static final int INORDER = 2; //中序遍历
public static final int POSTORDER = 3; //中序遍历
//遍历
public void traverse(int type){
switch(type){
case 1:
System.out.print("前序遍历：\t");
preorder(root);
System.out.println();
break;
case 2:
System.out.print("中序遍历：\t");
inorder(root);
System.out.println();
break;
case 3:
System.out.print("后序遍历：\t");
postorder(root);
System.out.println();
break;
}
}
//前序遍历
public void preorder(TreeNode currentRoot){
if(currentRoot != null){
System.out.print(currentRoot.age+"\t");
preorder(currentRoot.leftChild);
preorder(currentRoot.rightChild);
}
}
//中序遍历，这三种遍历都用了迭代的思想
public void inorder(TreeNode currentRoot){
if(currentRoot != null){
inorder(currentRoot.leftChild); //先对当前节点的左子树对进行中序遍历
System.out.print(currentRoot.age+"\t"); //然后访问当前节点
inorder(currentRoot.rightChild); //最后对当前节点的右子树对进行中序遍历
}
}
//后序遍历
public void postorder(TreeNode currentRoot){
if(currentRoot != null){
postorder(currentRoot.leftChild);
postorder(currentRoot.rightChild);
System.out.print(currentRoot.age+"\t");
}
}
//私有方法，用迭代方法来获取左子树和右子树的最大深度，返回两者最大值
private int getDepth(TreeNode currentNode,int initDeep){
int deep = initDeep; //当前节点已到达的深度
int leftDeep = initDeep;
int rightDeep = initDeep;
if(currentNode.leftChild != null){ //计算当前节点左子树的最大深度
leftDeep = getDepth(currentNode.leftChild, deep+1);
}
if(currentNode.rightChild != null){ //计算当前节点右子树的最大深度
rightDeep = getDepth(currentNode.rightChild, deep+1);
}
return Math.max(leftDeep, rightDeep);
}
//获取树的深度
public int getTreeDepth(){
if(root == null){
return 0;
}
return getDepth(root,1);
}
//返回关键值最大的节点
public TreeNode getMax(){
if(isEmpty()){
return null;
}
TreeNode cur = root;
while(cur.rightChild != null){
cur = cur.rightChild;
}
return cur;
}
//返回关键值最小的节点
public TreeNode getMin(){
if(isEmpty()){
return null;
}
TreeNode cur = root;
while(cur.leftChild != null){
cur = cur.leftChild;
}
return cur;
}
//以树的形式打印出该树
public void displayTree(){
int depth = getTreeDepth();
ArrayList<TreeNode> currentLayerNodes = new ArrayList<TreeNode> ();
currentLayerNodes.add(root); //存储该层所有节点
int layerIndex = 1;
while(layerIndex <= depth){
int NodeBlankNum = (int)Math.pow(2, depth-layerIndex)-1; //在节点之前和之后应该打印几个空位
for(int i = 0;i<currentLayerNodes.size();i++){
TreeNode node = currentLayerNodes.get(i);
printBlank(NodeBlankNum); //打印节点之前的空位
if(node == null){
System.out.print("*\t"); //如果该节点为null，用空位代替
}else{
System.out.print("* "+node.age+"\t"); //打印该节点
}
printBlank(NodeBlankNum); //打印节点之后的空位
System.out.print("*\t"); //补齐空位
}
System.out.println();
layerIndex++;
currentLayerNodes = getAllNodeOfThisLayer(currentLayerNodes); //获取下一层所有的节点
}
}
//获取指定节点集合的所有子节点
private ArrayList getAllNodeOfThisLayer(List parentNodes){
ArrayList list = new ArrayList<Node>();
TreeNode parentNode;
for(int i=0;i<parentNodes.size();i++){
parentNode = (TreeNode)parentNodes.get(i);
if(parentNode != null){
if(parentNode.leftChild != null){ //如果上层的父节点存在左子节点，加入集合
list.add(parentNode.leftChild);
}else{
list.add(null); //如果上层的父节点不存在左子节点，用null代替，一样加入集合
}
if(parentNode.rightChild != null){
list.add(parentNode.rightChild);
}else{
list.add(null);
}
}else{ //如果上层父节点不存在，用两个null占位，代表左右子节点
list.add(null);
list.add(null);
}
}
return list;
}
//打印指定个数的空位
private void printBlank(int num){
for(int i=0;i<num;i++){
System.out.print("*\t");
}
}
//判空
public boolean isEmpty(){
return (root == null);
}
//判断是否为叶子节点
public boolean isLeaf(TreeNode node){
return (node.leftChild != null || node.rightChild != null);
}
//获取根节点
public TreeNode getRoot(){
return root;
}
}
//树节点的封装类
class TreeNode{
int age;
String name;
TreeNode leftChild; //左子节点的引用
TreeNode rightChild; //右子节点的引用
public TreeNode(int age,String name){
this.age = age;
this.name = name;
}
//打印该节点的信息
public void displayNode(){
System.out.println("name:"+name+",age:"+age);
}
}
参考自：https://www.jianshu.com/p/bb0c12b34f2a
9.2. 树的相关操作
树的前中后序遍历
树的前中后序查找
打印树
二叉排序树
霍夫曼树
AVL树
B树
B+树
顺序存储二叉树（求他的前中后序的数组）
10. 分治算法
经典的：汉诺塔问题、快排、二分查找等等。
11.动态规划
0 - 1背包问题（限制每个物品只能一个）
完全背包问题（每个物品不限个数）
区别：分治算法分解得到的小问题是相互独立的，而动态规划算法分解的问题是相互不独立的。
12. 字符串匹配问题
12.1. 暴力匹配
package Algorithm;
public class ViolenceMatch {
public static void main(String[] args) {
String str1="addgadfhfgsfgs";
String str2="fhf";
int index = violenceMatch(str1, str2);
System.out.println("index="+index);
}
//暴力匹配算法实现
public static int violenceMatch(String str1,String str2){
char[] s1 = str1.toCharArray();
char[] s2 = str2.toCharArray();
int s1len = s1.length;
int s2len = s2.length;
//两个索引
int i = 0;//指向字符串str1
int j = 0;//指向字符串str2
while (i<s1len && j<s2len) {//保证匹配不越界
if (s1[i] == s2[j]) {
i++;
j++;
}else {
i = i-(j-1);
j=0;
}
}
//判断是否匹配成功
if (j == s2len) {
return i-j;
}else {
return -1;
}
}
}
12.2. KMP 算法
13. 贪心算法
13.1. 集合覆盖问题
动态规划、贪心、回溯、递归、分治、深度优先/广度优先搜索
几个排序算法（冒泡、插入、选择、快排）、二分查找、双指针、滑动窗口、数据结构
五大常用算法之一：分治算法
五大常用算法之二：动态规划算法
五大常用算法之三：贪心算法
五大常用算法之四：回溯法
五大常用算法之五：分支限界法
14. 额外
如何理解「分治算法」？
比如说二分查找这个问题的思路是如下：
1、我们的目的是什么：找到一个数组中的某个指定的值，那么方法的参数和返回值我们就可以确定了（参数是数组，返回值是找到的值）
2、如何分解：每个分治题目的分解方式都不太一样，在这道题的分治是通过对半分（原因是数组有序），那么对半分后的数组需要做什么呢？答案是重复 1 的操作，即我们的目的还是一样的：找到对半分的数组的指定值，那么方法还是第1中的方法，那么这里就是写递归方法的地方。
3、递归方法写完之后，我们需要获取其返回值，根据左右两个半数组的返回值，择优返回一个最优的返回。
4、当然在方法之初，需要一个退出条件（配合return使用），这个条件一般是「不可再分的情况」。
基本上所有的分治算法都遵循上面的思路，不同的地方主要是在第 2 点，难点也是在第 2 点，因为你不知道对于一道陌生的题，你到底应该怎么分解（对半？还是去一？等等）而且第 3 有时候某些分支也不需要递归（因为分解的足够小后已经成为了特殊情况，可以直接处理）。
如何理解「动态规划」？
动态规划和分治的区别：分治是把大问题「分裂」成若干个小问题，直到小问题不可再分，直接处理后返回，所以，思想上是自大到小处理，用到递归。动态规划也是把大问题「分裂」成若干个小问题，但是它是从小问题处理到大问题的过程，会有一个状态方程和一个维护的数组(可能一维或者二维)以及几个初始条件，状态方程反映了前后步骤的关系，数组存储各个步骤的数据。
冒泡排序：让第k个和第k+1个进行比较，然后交换，一直交换，到最后一个就是最大值（最小值），然后再重新比较。（联想：最后一个就像泡泡一样冒出来了）。
选择排序：先假设第一个就是最小的，接着遍历后面，找到一个比第一个还小的，就交换，这样，第一个就是最小的。接着第二个。。
插入排序：假定第一个是排好的，接着从第二个开始，往前找，看要插入到哪里。
快速排序
扫一扫
1252
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
