数据结构与算法笔记（java）

0 度

0.1 时间复杂度

• 度量一个程序(算法)执行时间的两种方法

  1. 事后统计法

     两个问题：一是要想对设计的算法的运行性能进行评测，需要实际运行该程序；二是所得时间的统计量依赖于计算机的硬件、软件等环境因素, 这种方式，要在同一台计算机的相同状态下运行，才能比较那个算法速度更快

  2. 事前估算的方法
     通过分析某个算法的时间复杂度来判断哪个算法更优

0.2 时间频度

• 基本介绍

  一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度，记为 T(n)

• 总结

  • 忽略常数项
  • 忽略低次项
  • 忽略系数（注：n的三次方往上不可忽略）

• 计算方法：

• 常见的时间复杂度

  1. 常数阶 O(1)
  2. 对数阶 O(log2n)
  3. 线性阶 O(n)
  4. 线性对数阶
  5. 平方阶 O(n^2)【两个for循环】
  6. 立方阶 O(n^3)【三个for循环】
  7. k 次方阶 O(n^k)【n个for循环】
  8. 指数阶O(2^n)

0.3 空间复杂度

空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。

1.0 稀疏数组和队列

1.1 稀疏数组

• 基本介绍

  当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

  稀疏数组的处理方法是：

  1）记录数组一共有几行几列，有多少个不同的值

  2）把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

• 二维数组 转 稀疏数组的思路

  1. 遍历 原始的二维数组，得到有效数据的个数 sum
  2. 根据sum就可以创建 稀疏数组 sparse Arr int[sum+1] [3]
  3. 将二维数组的有效数据存入到 稀疏数组

• 稀疏数组转原始的二维数组的思路

  1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int[11] [11]
  2. 在读取稀疏数组后几行的数据，并赋给原始的二维数组即可

• 代码实现

  public class SparseArray {
  	public static void main(String[] args) {
  		// 创建一个原始的二维数组 11 * 11
  		// 0: 表示没有棋子， 1 表示 黑子 2 表蓝子
  		int chessArr1[][] = new int[11][11];
  		chessArr1[1][2] = 1;
  		chessArr1[2][3] = 2;
  		chessArr1[4][5] = 2;
  		// 输出原始的二维数组
  		System.out.println("原始的二维数组~~");
  		for (int[] row : chessArr1) {
  			for (int data : row) {
  				System.out.printf("%d\t", data);
  			}
  			System.out.println();
  		}
  
  		// 将二维数组 转 稀疏数组的思
  		// 1. 先遍历二维数组 得到非0数据的个数
  		int sum = 0;
  		for (int i = 0; i < 11; i++) {
  			for (int j = 0; j < 11; j++) {
  				if (chessArr1[i][j] != 0) {
  					sum++;
  				}
  			}
  		}
  
  		// 2. 创建对应的稀疏数组
  		int sparseArr[][] = new int[sum + 1][3];
      
  		// 给稀疏数组赋值
  		sparseArr[0][0] = 11;
  		sparseArr[0][1] = 11;
  		sparseArr[0][2] = sum;
  		
  		// 遍历二维数组，将非0的值存放到 sparseArr中
  		int count = 0; //count 用于记录是第几个非0数据
  		for (int i = 0; i < 11; i++) {
  			for (int j = 0; j < 11; j++) {
  				if (chessArr1[i][j] != 0) {
  					count++;
  					sparseArr[count][0] = i;
  					sparseArr[count][1] = j;
  					sparseArr[count][2] = chessArr1[i][j];
  				}
  			}
  		}
  		
  		// 输出稀疏数组的形式
  		System.out.println();
  		System.out.println("得到稀疏数组为~~~~");
  		for (int i = 0; i < sparseArr.length; i++) {
  			System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]);
  		}
  		System.out.println();
      
      
  		
  		//将稀疏数组 恢复成 原始的二维数组
  		/*
  		 *  1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的  chessArr2 = int [11][11]
  			  2. 在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可.
  		 */
  		
  		//1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
  		
  		int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
  		
  		//2. 在读取稀疏数组后几行的数据(从第二行开始)，并赋给 原始的二维数组 即可
  		
  		for(int i = 1; i < sparseArr.length; i++) {
  			chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
  		}
  		
  		// 输出恢复后的二维数组
  		System.out.println();
  		System.out.println("恢复后的二维数组");
  		
  		for (int[] row : chessArr2) {
  			for (int data : row) {
  				System.out.printf("%d\t", data);
  			}
  			System.out.println();
  		}
  	}
  }
  

1.2 队列

• 基本介绍
  1. 队列是一个有序列表，可以用数组或是链表来实现
  2. 遵循先入先出原则。即：先存入队列的数据，要先取出。后存入的要后取出
  3. 示意图（使用数组模拟队列示意图）

1.2.1 数组模拟队列

• 思路分析

  1. fornt：队列第一个元素的前一位
  2. rear：队列最后元素
  3. maxsize：队列的最大容量
  • 队列本身是有序列表，若使用数组的结构来存储队列的数据，其中 MaxSize 是该队列的最大容量
  • 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front 和 rear 分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear 则是随着数据输入而改变
  • 当我们将数据存入队列时称为" addQueue" , addQueue 的处理需要有两个步骤：
    1. 将尾指针往后移：rear + 1，当 front == rear 【空】
    2. 若尾指针 rear 小于队列的最大下标 maxSize - 1 ，则将数据存入 rear 所指的数组元素中，否则无法存入数据。 rear == maxSize - 1 【队列满】

• 代码实现

  public class ArrayQueueDemo {
  	public static void main(String[] args) {
  		//测试一把
  		//创建一个队列
  		ArrayQueue queue = new ArrayQueue(3);
  		char key = ' '; //接收用户输入
  		Scanner scanner = new Scanner(System.in);//
  		boolean loop = true;
  		//输出一个菜单
  		while(loop) {
  			System.out.println("s(show): 显示队列");
  			System.out.println("e(exit): 退出程序");
  			System.out.println("a(add): 添加数据到队列");
  			System.out.println("g(get): 从队列取出数据");
  			System.out.println("h(head): 查看队列头的数据");
  			key = scanner.next().charAt(0);//接收一个字符
  			switch (key) {
  			case 's':
  				queue.showQueue();
  				break;
  			case 'a':
  				System.out.println("输出一个数");
  				int value = scanner.nextInt();
  				queue.addQueue(value);
  				break;
  			case 'g': //取出数据
  				try {
  					int res = queue.getQueue();
  					System.out.printf("取出的数据是%d\n", res);
  				} catch (Exception e) {
  					// TODO: handle exception
  					System.out.println(e.getMessage());
  				}
  				break;
  			case 'h': //查看队列头的数据
  				try {
  					int res = queue.headQueue();
  					System.out.printf("队列头的数据是%d\n", res);
  				} catch (Exception e) {
  					// TODO: handle exception
  					System.out.println(e.getMessage());
  				}
  				break;
  			case 'e': //退出
  				scanner.close();
  				loop = false;
  				break;
  			default:
  				break;
  			}
  		}
  		System.out.println("程序退出~~");
  	}
  }
  
  // 使用数组模拟队列-编写一个ArrayQueue类
  class ArrayQueue {
  	private int maxSize; // 表示数组的最大容量
  	private int front; // 队列头
  	private int rear; // 队列尾
  	private int[] arr; // 该数据用于存放数据, 模拟队列
  
  	// 创建队列的构造器
  	public ArrayQueue(int arrMaxSize) {
  		maxSize = arrMaxSize;
  		arr = new int[maxSize];
  		front = -1; // 指向队列头部，分析出front是指向队列头的前一个位置.
  		rear = -1; // 指向队列尾，指向队列尾的数据(即就是队列最后一个数据)
  	}
  
  	// 判断队列是否满
  	public boolean isFull() {
  		return rear == maxSize - 1;
  	}
  
  	// 判断队列是否为空
  	public boolean isEmpty() {
  		return rear == front;
  	}
  
  	// 添加数据到队列
  	public void addQueue(int n) {
  		// 判断队列是否满
  		if (isFull()) {
  			System.out.println("队列满，不能加入数据~");
  			return;
  		}
  		rear++; // 让rear 后移
  		arr[rear] = n;
  	}
  
  	// 获取队列的数据, 出队列
  	public int getQueue() {
  		// 判断队列是否空
  		if (isEmpty()) {
  			// 通过抛出异常
  			throw new RuntimeException("队列空，不能取数据");
  		}
  		front++; // front后移
  		return arr[front];
  
  	}
  
  	// 显示队列的所有数据
  	public void showQueue() {
  		// 遍历
  		if (isEmpty()) {
  			System.out.println("队列空的，没有数据~~");
  			return;
  		}
  		for (int i = 0; i < arr.length; i++) {
  			System.out.printf("arr[%d]=%d\n", i, arr[i]);
  		}
  	}
  
  	// 显示队列的头数据， 注意不是取出数据
  	public int headQueue() {
  		// 判断
  		if (isEmpty()) {
  			throw new RuntimeException("队列空的，没有数据~~");
  		}
  		return arr[front + 1];
  	}
  }
  

1.2.2 数组模拟环形队列

• 思路分析

  对前面的数组模拟队列的优化，充分利用数组，通过取模的方式来实现。

  1. front就指向队列的第一个元素，也就是0说arr[front]就是队列的第一个元素，front的初始值=0
  2. rear指向队列的最后一个元泰的后一个位置，因为希望空出一个空间做为约定，rear 的初始值=0
  3. 队列满： (rear +1) % maxsize == front
  4. 队列空：rear == front
  5. 队列中有效的数据的个数： (rear + maxsize - front) % maxSize
  

• 代码实现

  public class CircleArrayQueueDemo {
  
  	public static void main(String[] args) {
  		
  		System.out.println("测试数组模拟环形队列的案例~~~");
  		
  		// 创建一个环形队列
  		CircleArray queue = new CircleArray(4); //说明设置4, 其队列的有效数据最大是3
  		char key = ' '; // 接收用户输入
  		Scanner scanner = new Scanner(System.in);//
  		boolean loop = true;
  		// 输出一个菜单
  		while (loop) {
  			System.out.println("s(show): 显示队列");
  			System.out.println("e(exit): 退出程序");
  			System.out.println("a(add): 添加数据到队列");
  			System.out.println("g(get): 从队列取出数据");
  			System.out.println("h(head): 查看队列头的数据");
  			key = scanner.next().charAt(0);// 接收一个字符
  			switch (key) {
  			case 's':
  				queue.showQueue();
  				break;
  			case 'a':
  				System.out.println("输出一个数");
  				int value = scanner.nextInt();
  				queue.addQueue(value);
  				break;
  			case 'g': // 取出数据
  				try {
  					int res = queue.getQueue();
  					System.out.printf("取出的数据是%d\n", res);
  				} catch (Exception e) {
  					// TODO: handle exception
  					System.out.println(e.getMessage());
  				}
  				break;
  			case 'h': // 查看队列头的数据
  				try {
  					int res = queue.headQueue();
  					System.out.printf("队列头的数据是%d\n", res);
  				} catch (Exception e) {
  					// TODO: handle exception
  					System.out.println(e.getMessage());
  				}
  				break;
  			case 'e': // 退出
  				scanner.close();
  				loop = false;
  				break;
  			default:
  				break;
  			}
  		}
  		System.out.println("程序退出~~");
  	}
  
  }
  
  
  class CircleArray {
  	private int maxSize; // 表示数组的最大容量
  	//front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素 
  	//front 的初始值 = 0
  	private int front; 
  	//rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
  	//rear 的初始值 = 0
  	private int rear; // 队列尾
  	private int[] arr; // 该数据用于存放数据, 模拟队列
  	
  	public CircleArray(int arrMaxSize) {
  		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.0 链表

• 基本介绍
  1. 链表是以节点的方式来存储，是链式存储
  2. 每个节点包含 data 域， next 域：指向下一个节点
  3. 如图：发现链表的各个节点不一定是连续存储
  4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

2.1 单向链表

• 基本介绍

• 应用实例

  使用带head头的单向链表实现 -水浒英雄排行榜管理完成对英雄人物的增删改查操作。

  思路分析

  定义

  //定义HeroNode ， 每个HeroNode 对象就是一个节点
  class HeroNode {
     public int no;
     public String name;
     public String nickname;
     public HeroNode next; //指向下一个节点
     //构造器
     public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
     }
     //为了显示方法，我们重新toString
     @Override
     public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
     }
  }
  

  遍历显示

  //显示链表[遍历]
  	public void list() {
  		//判断链表是否为空
  		if(head.next == null) {
  			System.out.println("链表为空");
  			return;
  		}
  		//因为头节点，不能动，因此我们需要一个辅助变量来遍历
  		HeroNode temp = head.next;
  		while(true) {
  			//判断是否到链表最后
  			if(temp == null) {
  				break;
  			}
  			//输出节点的信息
  			System.out.println(temp);
  			//将temp后移， 一定小心
  			temp = temp.next;
  		}
  

  • 添加

    • 第一种方法在添加英雄时，直接添加到链表的尾部

      //添加节点到单向链表
      
      	//思路，当不考虑编号顺序时
      	//1. 找到当前链表的最后节点
      	//2. 将最后这个节点的next 指向 新的节点
      	public void add(HeroNode heroNode) {
      		
      		//因为head节点不能动，因此我们需要一个辅助遍历 temp
      		HeroNode temp = head;
      		//遍历链表，找到最后
      		while(true) {
      			//找到链表的最后
      			if(temp.next == null) {//
      				break;
      			}
      			//如果没有找到最后, 将将temp后移
      			temp = temp.next;
      		}
      		//当退出while循环时，temp就指向了链表的最后
      		//将最后这个节点的next 指向 新的节点
      		temp.next = heroNode;
      	}
      

    • 第二种方式在添加英雄时，根据排名将英雄插入到指定位置

      //第二种方式在添加英雄时，根据排名将英雄插入到指定位置
      	//(如果有这个排名，则添加失败，并给出提示)
      	public void addByOrder(HeroNode heroNode) {
      		//因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
      		//因为单链表，因为我们找的temp 是位于 添加位置的前一个节点，否则插入不了
      		HeroNode temp = head;
      		boolean flag = false; // flag标志添加的编号是否存在，默认为false
      		while(true) {
      			if(temp.next == null) {//说明temp已经在链表的最后
      				break; //
      			} 
      			if(temp.next.no > heroNode.no) { //位置找到，就在temp的后面插入
      				break;
      			} else if (temp.next.no == heroNode.no) {//说明希望添加的heroNode的编号已然存在
      				
      				flag = true; //说明编号存在
      				break;
      			}
      			temp = temp.next; //后移，遍历当前链表
      		}
      		//判断flag 的值
      		if(flag) { //不能添加，说明编号存在
      			System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
      		} else {
      			//插入到链表中, temp的后面
      			heroNode.next = temp.next;
      			temp.next = heroNode;
      		}
      	}
      

  • 修改节点功能

    1）先找到该节点，通过遍历

    2）temp.name = newHeroNode.name; temp.nickname = newHeroNode.nickname

    //修改节点的信息, 根据no编号来修改，即no编号不能改.
    	//说明
    	//1. 根据 newHeroNode 的 no 来修改即可
    	public void update(HeroNode newHeroNode) {
    		//判断是否空
    		if(head.next == null) {
    			System.out.println("链表为空~");
    			return;
    		}
    		//找到需要修改的节点, 根据no编号
    		//定义一个辅助变量
    		HeroNode temp = head.next;
    		boolean flag = false; //表示是否找到该节点
    		while(true) {
    			if (temp == null) {
    				break; //已经遍历完链表
    			}
    			if(temp.no == newHeroNode.no) {
    				//找到
    				flag = true;
    				break;
    			}
    			temp = temp.next;
    		}
    		//根据flag 判断是否找到要修改的节点
    		if(flag) {
    			temp.name = newHeroNode.name;
    			temp.nickname = newHeroNode.nickname;
    		} else { //没有找到
    			System.out.printf("没有找到 编号 %d 的节点，不能修改\n", newHeroNode.no);
    		}
    	}
    

  • 删除节点

    //删除节点
    //思路
    //1. head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2. 说明我们在比较时，是temp.next.no 和  需要删除的节点的no比较
    public void del(int no) {
       HeroNode temp = head;
       boolean flag = false; // 标志是否找到待删除节点的
       while(true) {
          if(temp.next == null) { //已经到链表的最后
             break;
          }
          if(temp.next.no == no) {
             //找到的待删除节点的前一个节点temp
             flag = true;
             break;
          }
          temp = temp.next; //temp后移，遍历
       }
       //判断flag
       if(flag) { //找到
          //可以删除
          temp.next = temp.next.next;
       }else {
          System.out.printf("要删除的 %d 节点不存在\n", no);
       }
    }
    

2.1.2 面试题

• 新浪面试题获取单链表的节点个数

  //方法：获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)
     /**
      * 
      * @param head 链表的头节点
      * @return 返回的就是有效节点的个数
      */
     public static int getLength(HeroNode head) {
        if(head.next == null) { //空链表
           return 0;
        }
        int length = 0;
        //定义一个辅助的变量, 这里我们没有统计头节点
        HeroNode cur = head.next;
        while(cur != null) {
           length++;
           cur = cur.next; //遍历
        }
        return length;
     }
  }
  

• 腾讯面试题获取单链表倒数第k个结点

  //查找单链表中的倒数第k个结点 【新浪面试题】
  //思路
  //1. 编写一个方法，接收head节点，同时接收一个index 
  //2. index 表示是倒数第index个节点
  //3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
  //4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
  //5. 如果找到了，则返回该节点，否则返回nulll
  public static HeroNode findLastIndexNode(HeroNode head, int index) {
     //判断如果链表为空，返回null
     if(head.next == null) {
        return null;//没有找到
     }
     //第一个遍历得到链表的长度(节点个数)
     int size = getLength(head);
     //第二次遍历  size-index 位置，就是我们倒数的第K个节点
     //先做一个index的校验
     if(index <=0 || index > size) {
        return null; 
     }
     //定义给辅助变量， for 循环定位到倒数的index
     HeroNode cur = head.next; //3 // 3 - 1 = 2
     for(int i =0; i< size - index; i++) {
        cur = cur.next;
     }
     return cur;
  }
  

• 单链表反转

  public static void reversetList(HeroNode head) {
     //如果当前链表为空，或者只有一个节点，无需反转，直接返回
     if(head.next == null || head.next.next == null) {
        return ;
     }
     
     //定义一个辅助的指针(变量)，帮助我们遍历原来的链表
     HeroNode cur = head.next;
     HeroNode next = null;// 指向当前节点[cur]的下一个节点
     HeroNode reverseHead = new HeroNode(0, "", "");
     //遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端
     
     while(cur != null) { 
        next = cur.next;//先暂时保存当前节点的下一个节点，因为后面需要使用
        cur.next = reverseHead.next;//将cur的下一个节点指向新的链表的头节点的下一个
        reverseHead.next = cur; //将cur 连接到新的链表上
        cur = next;//让cur后移
     }
     //将head.next 指向 reverseHead.next , 实现单链表的反转
     head.next = reverseHead.next;
  }
  

• 从尾到头打印单链表

  //方式2
          //可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出特点
          //实现逆序打印
          public static void reversePrint(HeroNode head){
              if(head.next == null){
                  return;//空链表，不能打印
              }
              //创建一个栈，将各个节点压入栈
              Stack<HeroNode> stack = new Stack<>();
              HeroNode cur = head.next;
              //将链表的所有节点压入栈
              while (cur != null){
                  stack.push(cur);
                  cur = cur.next;//cur后移，这样就可以压入下一个节点
  
              }
              //将栈中的节点进行打印，pop 出栈
              while (stack.size() > 0){
                  System.out.println(stack.pop());//stack 的特点是先进后出
              }
          }
  

• 合并两个有序列表

  //合并两个有序链表
      public static void combineList(HeroNode l1,HeroNode l2){
          HeroNode preHead = new HeroNode(-1,"","");
  
          HeroNode cur = preHead;
          while (l1 != null && l2 != null){
              if (l1.no <= l2.no){
                  cur.next = l1;
                  l1 = l1.next;
              } else {
                  cur.next = l2;
                  l2 = l2.next;
              }
              cur = cur.next;
          }
          cur.next = l1 == null ? l2 : l1;
      }
  

2.2 双向链表

• 思路[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hBVNUJXK-1682753464167)(C:\Users\vito\Desktop\java学习资料\数据结构和算法\双向链表思路.jpg)]

• 定义

  // 定义HeroNode2 ， 每个HeroNode 对象就是一个节点
  class HeroNode2 {
     public int no;
     public String name;
     public String nickname;
     public HeroNode2 next; // 指向下一个节点, 默认为null
     public HeroNode2 pre; // 指向前一个节点, 默认为null
     // 构造器
  
     public HeroNode2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
     }
  
     // 为了显示方法，我们重新toString
     @Override
     public String toString() {
        return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
     }
  }
  

• 尾部直接添加

  // 添加一个节点到双向链表的最后.
  public void add(HeroNode2 heroNode) {
  
     // 因为head节点不能动，因此我们需要一个辅助遍历 temp
     HeroNode2 temp = head;
     // 遍历链表，找到最后
     while (true) {
        // 找到链表的最后
        if (temp.next == null) {//
           break;
        }
        // 如果没有找到最后, 将将temp后移
        temp = temp.next;
     }
     // 当退出while循环时，temp就指向了链表的最后
     // 形成一个双向链表
     temp.next = heroNode;
     heroNode.pre = temp;
  }
  

• 按照编号顺序添加

  //有序加入
  public void addByOrder(Node2 node2) {
      Node2 temp = head;
      boolean flag = false;
      while (true) {
          if (temp.next == null) {
              break;
          }
          if (temp.next.no > node2.no) {
              break;
          } else if (temp.next.no == node2.no) {
              flag = true;
              break;
          }
          temp = temp.next;
      }
      if (flag == true) {
          System.out.println("已存在" + node2.no);
      } else {
          node2.next = temp.next;
          if (temp.next != null) {
              temp.next.pre = node2;
          }
          temp.next = node2;
          node2.pre = temp;
      }
  }
  

• 修改节点

  // 修改一个节点的内容, 可以看到双向链表的节点内容修改和单向链表一样
  // 只是 节点类型改成 HeroNode2
  public void update(HeroNode2 newHeroNode) {
     // 判断是否空
     if (head.next == null) {
        System.out.println("链表为空~");
        return;
     }
     // 找到需要修改的节点, 根据no编号
     // 定义一个辅助变量
     HeroNode2 temp = head.next;
     boolean flag = false; // 表示是否找到该节点
     while (true) {
        if (temp == null) {
           break; // 已经遍历完链表
        }
        if (temp.no == newHeroNode.no) {
           // 找到
           flag = true;
           break;
        }
        temp = temp.next;
     }
     // 根据flag 判断是否找到要修改的节点
     if (flag) {
        temp.name = newHeroNode.name;
        temp.nickname = newHeroNode.nickname;
     } else { // 没有找到
        System.out.printf("没有找到 编号 %d 的节点，不能修改\n", newHeroNode.no);
     }
  }
  

• 删除节点

  // 从双向链表中删除一个节点,
     // 说明
     // 1 对于双向链表，我们可以直接找到要删除的这个节点
     // 2 找到后，自我删除即可
     public void del(int no) {
  
        // 判断当前链表是否为空
        if (head.next == null) {// 空链表
           System.out.println("链表为空，无法删除");
           return;
        }
  
        HeroNode2 temp = head.next; // 辅助变量(指针)
        boolean flag = false; // 标志是否找到待删除节点的
        while (true) {
           if (temp == null) { // 已经到链表的最后
              break;
           }
           if (temp.no == no) {
              // 找到的待删除节点的前一个节点temp
              flag = true;
              break;
           }
           temp = temp.next; // temp后移，遍历
        }
        // 判断flag
        if (flag) { // 找到
           // 可以删除
           // temp.next = temp.next.next;[单向链表]
           temp.pre.next = temp.next;
           // 这里我们的代码有问题?
           // 如果是最后一个节点，就不需要执行下面这句话，否则出现空指针
           if (temp.next != null) {
              temp.next.pre = temp.pre;
           }
        } else {
           System.out.printf("要删除的 %d 节点不存在\n", no);
        }
     }
  }
  

2.3 单向环形链表

• 思路分析[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4Qnmq8wk-1682753464168)(C:\Users\vito\Desktop\java学习资料\数据结构和算法\单项环形链表思路02.jpg)]

• 代码实现

  // 创建一个环形的单向链表
  class CircleSingleLinkedList {
     // 创建一个first节点,当前没有编号
     private Boy first = null;
  
     // 添加小孩节点，构建成一个环形的链表
     public void addBoy(int nums) {
        // nums 做一个数据校验
        if (nums < 1) {
           System.out.println("nums的值不正确");
           return;
        }
        Boy curBoy = null; // 辅助指针，帮助构建环形链表
        // 使用for来创建我们的环形链表
        for (int i = 1; i <= nums; i++) {
           // 根据编号，创建小孩节点
           Boy boy = new Boy(i);
           // 如果是第一个小孩
           if (i == 1) {
              first = boy;
              first.setNext(first); // 构成环
              curBoy = first; // 让curBoy指向第一个小孩
           } else {
              curBoy.setNext(boy);//
              boy.setNext(first);//
              curBoy = boy;
           }
        }
     }
  
     // 遍历当前的环形链表
     public void showBoy() {
        // 判断链表是否为空
        if (first == null) {
           System.out.println("没有任何小孩~~");
           return;
        }
        // 因为first不能动，因此我们仍然使用一个辅助指针完成遍历
        Boy curBoy = first;
        while (true) {
           System.out.printf("小孩的编号 %d \n", curBoy.getNo());
           if (curBoy.getNext() == first) {// 说明已经遍历完毕
              break;
           }
           curBoy = curBoy.getNext(); // curBoy后移
        }
     }
  
     // 根据用户的输入，计算出小孩出圈的顺序
     /**
      * 
      * @param startNo
      *            表示从第几个小孩开始数数
      * @param countNum
      *            表示数几下
      * @param nums
      *            表示最初有多少小孩在圈中
      */
     public void countBoy(int startNo, int countNum, int nums) {
        // 先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums) {
           System.out.println("参数输入有误， 请重新输入");
           return;
        }
        // 创建要给辅助指针,帮助完成小孩出圈
        Boy helper = first;
        // 需求创建一个辅助指针(变量) helper , 事先应该指向环形链表的最后这个节点
        while (true) {
           if (helper.getNext() == first) { // 说明helper指向最后小孩节点
              break;
           }
           helper = helper.getNext();
        }
        //小孩报数前，先让 first 和  helper 移动 k - 1次
        for(int j = 0; j < startNo - 1; j++) {
           first = first.getNext();
           helper = helper.getNext();
        }
        //当小孩报数时，让first 和 helper 指针同时 的移动  m  - 1 次, 然后出圈
        //这里是一个循环操作，知道圈中只有一个节点
        while(true) {
           if(helper == first) { //说明圈中只有一个节点
              break;
           }
           //让 first 和 helper 指针同时 的移动 countNum - 1
           for(int j = 0; j < countNum - 1; j++) {
              first = first.getNext();
              helper = helper.getNext();
           }
           //这时first指向的节点，就是要出圈的小孩节点
           System.out.printf("小孩%d出圈\n", first.getNo());
           //这时将first指向的小孩节点出圈
           first = first.getNext();
           helper.setNext(first); //
           
        }
        System.out.printf("最后留在圈中的小孩编号%d \n", first.getNo());   
     }
  }
  
  // 创建一个Boy类，表示一个节点
  class Boy {
     private int no;// 编号
     private Boy next; // 指向下一个节点,默认null
  
     public Boy(int no) {
        this.no = no;
     }
  
     public int getNo() {
        return no;
     }
  
     public void setNo(int no) {
        this.no = no;
     }
  
     public Boy getNext() {
        return next;
     }
  
     public void setNext(Boy next) {
        this.next = next;
     }
  }
  

3.0 栈

3.1 栈的基本介绍

1. 栈的英文为(stack)

2. 栈是一个先入后出的有序列表

3. )栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)

4. 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

3.2 栈的应用场景

1. 子程序的调用：在跳往子程序前，先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中
2. 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆中
3. 表达式的转换【中缀表达式转后缀表达式】与求值
4. 二叉树的遍历
5. 图形的深度优化（depth-first)搜索法

3.3 数组模拟栈

public class ArrayStackDemo {

    public static void main(String[] args) {
        //测试一下ArrayStack 是否正确
        //先创建一个ArrayStack对象->表示栈
        ArrayStack stack = new ArrayStack(4);
        String key = "";
        boolean loop = true; //控制是否退出菜单
        Scanner scanner = new Scanner(System.in);

        while (loop) {
            System.out.println("show: 表示显示栈");
            System.out.println("exit: 退出程序");
            System.out.println("push: 表示添加数据到栈(入栈)");
            System.out.println("pop: 表示从栈取出数据(出栈)");
            System.out.println("请输入你的选择");
            key = scanner.next();
            switch (key) {
                case "show":
                    stack.list();
                    break;
                case "push":
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try {
                        int res = stack.pop();
                        System.out.printf("出栈的数据是 %d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }

        System.out.println("程序退出~~~");
    }

}

//定义一个 ArrayStack 表示栈
class ArrayStack {
    private int maxSize; // 栈的大小
    private int[] stack; // 数组，数组模拟栈，数据就放在该数组
    private int top = -1;// top表示栈顶，初始化为-1

    //构造器
    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    //栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    //栈空
    public boolean isEmpty() {
        return top == -1;
    }

    //入栈-push
    public void push(int value) {
        //先判断栈是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    //出栈-pop, 将栈顶的数据返回
    public int pop() {
        //先判断栈是否空
        if (isEmpty()) {
            //抛出异常
            throw new RuntimeException("栈空，没有数据~");
        }
        int value = stack[top];
        top--;
        return value;
    }

    //显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据~~");
            return;
        }
        //需要从栈顶开始显示数据
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }
}

3.4 栈实现综合计算器（中缀表达式）

• 思路分析

  public class Calculator {
  
      public static void main(String[] args) {
          //完成表达式的运算
          String expression = "7*2*2-5+1-5+3-4"; // 15//如何处理多位数的问题？
          //创建两个栈，数栈，一个符号栈
          ArrayStack2 numStack = new ArrayStack2(10);
          ArrayStack2 operStack = new ArrayStack2(10);
          //定义需要的相关变量
          int index = 0;//用于扫描
          int num1 = 0;
          int num2 = 0;
          int oper = 0;
          int res = 0;
          char ch = ' '; //将每次扫描得到char保存到ch
          String keepNum = ""; //用于拼接 多位数
          //开始while循环的扫描expression
          while (true) {
              //依次得到expression 的每一个字符
              ch = expression.substring(index, index + 1).charAt(0);
              //判断ch是什么，然后做相应的处理
              if (operStack.isOper(ch)) {//如果是运算符
                  //判断当前的符号栈是否为空
                  if (!operStack.isEmpty()) {
                      //如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数,
                      //在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
                      if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                          num1 = numStack.pop();
                          num2 = numStack.pop();
                          oper = operStack.pop();
                          res = numStack.cal(num1, num2, oper);
                          //把运算的结果如数栈
                          numStack.push(res);
                          //然后将当前的操作符入符号栈
                          operStack.push(ch);
                      } else {
                          //如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
                          operStack.push(ch);
                      }
                  } else {
                      //如果为空直接入符号栈..
                      operStack.push(ch); // 1 + 3
                  }
              } else { //如果是数，则直接入数栈
  
                  //numStack.push(ch - 48); //? "1+3" '1' => 1
                  //分析思路
                  //1. 当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
                  //2. 在处理数，需要向expression的表达式的index 后再看一位,如果是数就进行扫描，如果是符号才入栈
                  //3. 因此我们需要定义一个变量 字符串，用于拼接
  
                  //处理多位数
                  keepNum += ch;
  
                  //如果ch已经是expression的最后一位，就直接入栈
                  if (index == expression.length() - 1) {
                      numStack.push(Integer.parseInt(keepNum));
                  } else {
  
                      //判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
                      //注意是看后一位，不是index++
                      if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                          //如果后一位是运算符，则入栈 keepNum = "1" 或者 "123"
                          numStack.push(Integer.parseInt(keepNum));
                          //重要的!!!!!!, keepNum清空
                          keepNum = "";
  
                      }
                  }
              }
              //让index + 1, 并判断是否扫描到expression最后.
              index++;
              if (index >= expression.length()) {
                  break;
              }
          }
  
          //当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行.
          while (true) {
              //如果符号栈为空，则计算到最后的结果, 数栈中只有一个数字【结果】
              if (operStack.isEmpty()) {
                  break;
              }
              num1 = numStack.pop();
              num2 = numStack.pop();
              oper = operStack.pop();
              res = numStack.cal(num1, num2, oper);
              numStack.push(res);//入栈
          }
          //将数栈的最后数，pop出，就是结果
          int res2 = numStack.pop();
          System.out.printf("表达式 %s = %d", expression, res2);
      }
  
  }
  
  //先创建一个栈,直接使用前面创建好
  //定义一个 ArrayStack2 表示栈, 需要扩展功能
  class ArrayStack2 {
      private int maxSize; // 栈的大小
      private int[] stack; // 数组，数组模拟栈，数据就放在该数组
      private int top = -1;// top表示栈顶，初始化为-1
  
      //构造器
      public ArrayStack2(int maxSize) {
          this.maxSize = maxSize;
          stack = new int[this.maxSize];
      }
  
      //增加一个方法，可以返回当前栈顶的值, 但是不是真正的pop
      public int peek() {
          return stack[top];
      }
  
      //栈满
      public boolean isFull() {
          return top == maxSize - 1;
      }
  
      //栈空
      public boolean isEmpty() {
          return top == -1;
      }
  
      //入栈-push
      public void push(int value) {
          //先判断栈是否满
          if (isFull()) {
              System.out.println("栈满");
              return;
          }
          top++;
          stack[top] = value;
      }
  
      //出栈-pop, 将栈顶的数据返回
      public int pop() {
          //先判断栈是否空
          if (isEmpty()) {
              //抛出异常
              throw new RuntimeException("栈空，没有数据~");
          }
          int value = stack[top];
          top--;
          return value;
      }
  
      //显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
      public void list() {
          if (isEmpty()) {
              System.out.println("栈空，没有数据~~");
              return;
          }
          //需要从栈顶开始显示数据
          for (int i = top; i >= 0; i--) {
              System.out.printf("stack[%d]=%d\n", i, stack[i]);
          }
      }
  
      //返回运算符的优先级，优先级是程序员来确定, 优先级使用数字表示
      //数字越大，则优先级就越高.
      public int priority(int oper) {
          if (oper == '*' || oper == '/') {
              return 1;
          } else if (oper == '+' || oper == '-') {
              return 0;
          } else {
              return -1; // 假定目前的表达式只有 +, - , * , /
          }
      }
  
      //判断是不是一个运算符
      public boolean isOper(char val) {
          return val == '+' || val == '-' || val == '*' || val == '/';
      }
  
      //计算方法
      public int cal(int num1, int num2, int oper) {
          int res = 0; // res 用于存放计算的结果
          switch (oper) {
              case '+':
                  res = num1 + num2;
                  break;
              case '-':
                  res = num2 - num1;// 注意顺序
                  break;
              case '*':
                  res = num1 * num2;
                  break;
              case '/':
                  res = num2 / num1;
                  break;
              default:
                  break;
          }
          return res;
      }
  }
  

3.5 中缀-》后缀表达式

• 思路分析

• 代码实现

  public class PolandNotation {
  
      public static void main(String[] args) {
          //完成将一个中缀表达式转成后缀表达式的功能
          //说明
          //1. 1+((2+3)×4)-5 => 转成  1 2 3 + 4 × + 5 –
          //2. 因为直接对str 进行操作，不方便，因此 先将  "1+((2+3)×4)-5" =》 中缀的表达式对应的List
          //   即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
          //3. 将得到的中缀表达式对应的List => 后缀表达式对应的List
          //   即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
  
          String expression = "1+((2+3)*4)-5";//注意表达式 
          List<String> infixExpressionList = toInfixExpressionList(expression);
          System.out.println("中缀表达式对应的List=" + infixExpressionList); // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
          List<String> suffixExpreesionList = parseSuffixExpreesionList(infixExpressionList);
          System.out.println("后缀表达式对应的List" + suffixExpreesionList); //ArrayList [1,2,3,+,4,*,+,5,–] 
  
          System.out.printf("expression=%d", calculate(suffixExpreesionList)); // ?
  		
  		
  		
  		/*
  		
  		//先定义给逆波兰表达式
  		//(30+4)×5-6  => 30 4 + 5 × 6 - => 164
  		// 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / + 
  		//测试 
  		//说明为了方便，逆波兰表达式 的数字和符号使用空格隔开
  		//String suffixExpression = "30 4 + 5 * 6 -";
  		String suffixExpression = "4 5 * 8 - 60 + 8 2 / +"; // 76
  		//思路
  		//1. 先将 "3 4 + 5 × 6 - " => 放到ArrayList中
  		//2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算
  		
  		List<String> list = getListString(suffixExpression);
  		System.out.println("rpnList=" + list);
  		int res = calculate(list);
  		System.out.println("计算的结果是=" + res);
  		
  		*/
      }
  
  
      //即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
      //方法：将得到的中缀表达式对应的List => 后缀表达式对应的List
      public static List<String> parseSuffixExpreesionList(List<String> ls) {
          //定义两个栈
          Stack<String> s1 = new Stack<String>(); // 符号栈
          //说明：因为s2 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
          //因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> s2
          //Stack<String> s2 = new Stack<String>(); // 储存中间结果的栈s2
          List<String> s2 = new ArrayList<String>(); // 储存中间结果的Lists2
  
          //遍历ls
          for (String item : ls) {
              //如果是一个数，加入s2
              if (item.matches("\\d+")) {
                  s2.add(item);
              } else if (item.equals("(")) {
                  s1.push(item);
              } else if (item.equals(")")) {
                  //如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
                  while (!s1.peek().equals("(")) {
                      s2.add(s1.pop());
                  }
                  s1.pop();//!!! 将 ( 弹出 s1栈， 消除小括号
              } else {
                  //当item的优先级小于等于s1栈顶运算符, 将s1栈顶的运算符弹出并加入到s2中，再次转到(4.1)与s1中新的栈顶运算符相比较
                  //问题：我们缺少一个比较优先级高低的方法
                  while (s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item)) {
                      s2.add(s1.pop());
                  }
                  //还需要将item压入栈
                  s1.push(item);
              }
          }
  
          //将s1中剩余的运算符依次弹出并加入s2
          while (s1.size() != 0) {
              s2.add(s1.pop());
          }
          return s2; //注意因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List
      }
  
      //方法：将 中缀表达式转成对应的List
      //  s="1+((2+3)×4)-5";
      public static List<String> toInfixExpressionList(String s) {
          //定义一个List,存放中缀表达式 对应的内容
          List<String> ls = new ArrayList<String>();
          int i = 0; //这时是一个指针，用于遍历 中缀表达式字符串
          String str; // 对多位数的拼接
          char c; // 每遍历到一个字符，就放入到c
          do {
              //如果c是一个非数字，我需要加入到ls
              if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
                  ls.add("" + c);
                  i++; //i需要后移
              } else { //如果是一个数，需要考虑多位数
                  str = ""; //先将str 置成"" '0'[48]->'9'[57]
                  while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                      str += c;//拼接
                      i++;
                  }
                  ls.add(str);
              }
          } while (i < s.length());
          return ls;//返回
      }
  
      //将一个逆波兰表达式， 依次将数据和运算符 放入到 ArrayList中
      public static List<String> getListString(String suffixExpression) {
          //将 suffixExpression 分割
          String[] split = suffixExpression.split(" ");
          List<String> list = new ArrayList<String>();
          for (String ele : split) {
              list.add(ele);
          }
          return list;
  
      }
  
      //完成对逆波兰表达式的运算
  	/*
  	 * 1)从左至右扫描，将3和4压入堆栈；
  		2)遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
  		3)将5入栈；
  		4)接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
  		5)将6入栈；
  		6)最后是-运算符，计算出35-6的值，即29，由此得出最终结果
  	 */
  
      public static int calculate(List<String> ls) {
          // 创建给栈, 只需要一个栈即可
          Stack<String> stack = new Stack<String>();
          // 遍历 ls
          for (String item : ls) {
              // 这里使用正则表达式来取出数
              if (item.matches("\\d+")) { // 匹配的是多位数
                  // 入栈
                  stack.push(item);
              } else {
                  // pop出两个数，并运算， 再入栈
                  int num2 = Integer.parseInt(stack.pop());
                  int num1 = Integer.parseInt(stack.pop());
                  int res = 0;
                  if (item.equals("+")) {
                      res = num1 + num2;
                  } else if (item.equals("-")) {
                      res = num1 - num2;
                  } else if (item.equals("*")) {
                      res = num1 * num2;
                  } else if (item.equals("/")) {
                      res = num1 / num2;
                  } else {
                      throw new RuntimeException("运算符有误");
                  }
                  //把res 入栈
                  stack.push("" + res);
              }
  
          }
          //最后留在stack中的数据是运算结果
          return Integer.parseInt(stack.pop());
      }
  }
  
  //编写一个类 Operation 可以返回一个运算符 对应的优先级
  class Operation {
      private static int ADD = 1;
      private static int SUB = 1;
      private static int MUL = 2;
      private static int DIV = 2;
  
      //写一个方法，返回对应的优先级数字
      public static int getValue(String operation) {
          int result = 0;
          switch (operation) {
              case "+":
                  result = ADD;
                  break;
              case "-":
                  result = SUB;
                  break;
              case "*":
                  result = MUL;
                  break;
              case "/":
                  result = DIV;
                  break;
              default:
                  System.out.println("不存在该运算符" + operation);
                  break;
          }
          return result;
      }
  }
  

4.0 递归

• 基本介绍

  递归就是方法自己调用自己,每次调用时传入不同的变量

• 规则

  1. 执行一个方法时，就创建一个新的受保护的独立空间（栈空间）
  2. 方法的局部变量是独立的，不会相互影响
  3. 如果方法中使用的是引用类型变量（比如数组），就会共享该引用类型的数据
  4. 递归必须向退出递归的条件逼近，否则就是无限递归（死龟，StackOverflowError)
  5. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕

• 递归调用机制

• 迷宫

  public class MiGong {
  
      public static void main(String[] args) {
          //先创建一个二维数组，模拟迷宫
          //地图
          int[][] map = new int[8][7];
          //使用1表示墙
          //上下全部置为1
          
          for (int i = 0; i < 7; i++) {
              map[0][i] = 1;
              map[7][i] = 1;
          }
  		//左右全部置为1
          
          for (int i = 0; i < 8; i++) {
              map[i][0] = 1;
              map[i][6] = 1;
          }
          
          map[3][1] = 1;
          map[3][2] = 1;
  //		map[1][2] = 1;
  //		map[2][2] = 1;
  
          //输出地图
          System.out.println("地图");
          for (int i = 0; i < 8; i++) {
              for (int j = 0; j < 7; j++) {
                  System.out.print(map[i][j] + " ");
              }
              System.out.println();
          }
  		//使用递归回溯给小球找路
          //setWay(map, 1, 1);
          setWay2(map, 1, 1);
  
          //输出小球走过的新地图
          System.out.println("路径");
          for (int i = 0; i < 8; i++) {
              for (int j = 0; j < 7; j++) {
                  System.out.print(map[i][j] + " ");
              }
              System.out.println();
          }
      }
  		//使用递归回溯来给小球找路
      	//说明
      	//map 表示地图
      	//i,j表示从地图的哪个位置开始出发 （1，1）
      	//如果小球能到 map[6][5] 位置，则说明通路找到
      	//约定：当map[i][j] 为0表示该点没有走过；为1表示墙；2表示通路可走；3表示该点已经走过，但是走不通
      	//在走迷宫时，需要确定一个策略（方法）
      public static boolean setWay(int[][] map, int i, int j) {
          if (map[6][5] == 2) { //通路已经找到
              return true;
          } else {
              if (map[i][j] == 0) { //当前这个点没有走过，按照策略走
                 
                  map[i][j] = 2; //假定该店是可以走通
                  if (setWay(map, i + 1, j)) {//向下走
                      return true;
                  } else if (setWay(map, i, j + 1)) { //向右走
                      return true;
                  } else if (setWay(map, i - 1, j)) { //向左走
                      return true;
                  } else if (setWay(map, i, j - 1)) { //向下走
                      return true;
                  } else {
                      //死路
                      map[i][j] = 3;
                      return false;
                  }
              } else { //如果map[i][j] != 0，可能是1，2，3
                  return false;
              }
          }
      }
  	//修改策略
      public static boolean setWay2(int[][] map, int i, int j) {
          if (map[6][5] == 2) { 
              return true;
          } else {
              if (map[i][j] == 0) { 
                  
                  map[i][j] = 2; 
                  if (setWay2(map, i - 1, j)) {
                      return true;
                  } else if (setWay2(map, i, j + 1)) { 
                      return true;
                  } else if (setWay2(map, i + 1, j)) { 
                      return true;
                  } else if (setWay2(map, i, j - 1)) { 
                      return true;
                  } else {
                      map[i][j] = 3;
                      return false;
                  }
              } else { 
                  return false;
              }
          }
      }
  }
  

• 八皇后

  public class Queue8 {
  
     //定义一个max表示共有多少个皇后
     int max = 8;
     //定义数组array, 保存皇后放置位置的结果,比如 arr = {0 , 4, 7, 5, 2, 6, 1, 3} 
     int[] array = new int[max];
     static int count = 0;
     static int judgeCount = 0;
     public static void main(String[] args) {
        //测试一把 ， 8皇后是否正确
        Queue8 queue8 = new Queue8();
        queue8.check(0);
        System.out.printf("一共有%d解法", count);
        System.out.printf("一共判断冲突的次数%d次", judgeCount); // 1.5w
        
     }
     
     
     
     //编写一个方法，放置第n个皇后
     //特别注意： check 是 每一次递归时，进入到check中都有  for(int i = 0; i < max; i++)，因此会有回溯
     private void check(int n) {
        if(n == max) {  //n = 8 , 其实8个皇后就既然放好
           print();
           return;
        }
        
        //依次放入皇后，并判断是否冲突
        for(int i = 0; i < max; i++) {
           //先把当前这个皇后 n , 放到该行的第1列
           array[n] = i;
           //判断当放置第n个皇后到i列时，是否冲突
           if(judge(n)) { // 不冲突
              //接着放n+1个皇后,即开始递归
              check(n+1); //  
           }
           //如果冲突，就继续执行 array[n] = i; 即将第n个皇后，放置在本行得 后移的一个位置
        }
     }
     
     //查看当我们放置第n个皇后, 就去检测该皇后是否和前面已经摆放的皇后冲突
     /**
      * 
      * @param n 表示第n个皇后
      * @return
      */
     private boolean judge(int n) {
        judgeCount++;
        for(int i = 0; i < n; i++) {
           // 说明
           //1. array[i] == array[n]  表示判断 第n个皇后是否和前面的n-1个皇后在同一列
           //2. Math.abs(n-i) == Math.abs(array[n] - array[i]) 表示判断第n个皇后是否和第i皇后是否在同一斜线
           // n = 1  放置第 2列 1 n = 1 array[1] = 1
           // Math.abs(1-0) == 1  Math.abs(array[n] - array[i]) = Math.abs(1-0) = 1
           //3. 判断是否在同一行, 没有必要，n 每次都在递增
           if(array[i] == array[n] || Math.abs(n-i) == Math.abs(array[n] - array[i]) ) {
              return false;
           }
        }
        return true;
     }
     
     //写一个方法，可以将皇后摆放的位置输出
     private void print() {
        count++;
        for (int i = 0; i < array.length; i++) {
           System.out.print(array[i] + " ");
        }
        System.out.println();
     }
  }
  

5 排序

• 基本介绍

  排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程

• 常见排序

5.1 冒泡排序

• 思路分析

  通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部

• 代码实现

  // 将前面额冒泡排序算法，封装成一个方法
  	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!!!, 进行下次判断
  			}
  		}
  	}
  

5.2 选择排序

• 基本介绍

  选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的

• 思路分析

• 代码实现

  //选择排序
      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
          }
  

5.3 插入排序

• 思路分析

  把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表

• 代码实现

  //插入排序
  	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));
  		}
  

5.4 希尔排序

• 基本介绍

  希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。

• 思路分析

  希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1

• 代码实现

  // 希尔排序时， 对有序序列在插入时采用交换法, 
  	// 思路(算法) ===> 代码
  	public static void shellSort(int[] arr) {
  		
  		int temp = 0;
  		int count = 0;
  		// 根据前面的逐步分析，使用循环处理
  		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
  			for (int i = gap; i < arr.length; i++) {
  				// 遍历各组中所有的元素(共gap组，每组有个元素), 步长gap
  				for (int j = i - gap; j >= 0; j -= gap) {
  					// 如果当前元素大于加上步长后的那个元素，说明交换
  					if (arr[j] > arr[j + gap]) {
  						temp = arr[j];
  						arr[j] = arr[j + gap];
  						arr[j + gap] = temp;
  					}
  				}
  			}
  			//System.out.println("希尔排序第" + (++count) + "轮 =" + Arrays.toString(arr));
  		}
  	}
  	
  	//对交换式的希尔排序进行优化->移位法
  	public static void shellSort2(int[] arr) {
  		
  		// 增量gap, 并逐步的缩小增量
  		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
  			// 从第gap个元素，逐个对其所在的组进行直接插入排序
  			for (int i = gap; i < arr.length; i++) {
  				int j = i;
  				int temp = arr[j];
  				if (arr[j] < arr[j - gap]) {
  					while (j - gap >= 0 && temp < arr[j - gap]) {
  						//移动
  						arr[j] = arr[j-gap];
  						j -= gap;
  					}
  					//当退出while后，就给temp找到插入的位置
  					arr[j] = temp;
  				}
  			}
  		}
  	}
  

5.5 快速排序

• 基本介绍

  是对冒泡排序的一种改进。

• 思路分析

  通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

• 代码实现

  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);
  		}			
  	}
  

5.6 归并排序

• 基本介绍

  利用归并的思想实现的排序方法，该算法采用经典的分治策略，分治法将问题分成一些小的问题然后递归求解。而治的阶段则将分的阶段得到的各答案”修补“在一起。

• 思路分析

  

• 代码实现

  //分+合方法
  	public static void mergeSort(int[] arr, int left, int right, int[] temp) {
  		if(left < right) {
  			int mid = (left + right) / 2; //中间索引
  			//向左递归进行分解
  			mergeSort(arr, left, mid, temp);
  			//向右递归进行分解
  			mergeSort(arr, mid + 1, right, temp);
  			//合并
  			merge(arr, left, mid, right, temp);
  			
  		}
  	}
  	
  	//合并的方法
  	/**
  	 * 
  	 * @param arr 排序的原始数组
  	 * @param left 左边有序序列的初始索引
  	 * @param mid 中间索引
  	 * @param right 右边索引
  	 * @param temp 做中转的数组
  	 */
  	public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
  		
  		int i = left; // 初始化i, 左边有序序列的初始索引
  		int j = mid + 1; //初始化j, 右边有序序列的初始索引
  		int t = 0; // 指向temp数组的当前索引
  		
  		//(一)
  		//先把左右两边(有序)的数据按照规则填充到temp数组
  		//直到左右两边的有序序列，有一边处理完毕为止
  		while (i <= mid && j <= right) {//继续
  			//如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
  			//即将左边的当前元素，填充到 temp数组 
  			//然后 t++, i++
  			if(arr[i] <= arr[j]) {
  				temp[t] = arr[i];
  				t += 1;
  				i += 1;
  			} else { //反之,将右边有序序列的当前元素，填充到temp数组
  				temp[t] = arr[j];
  				t += 1;
  				j += 1;
  			}
  		}
  		
  		//(二)
  		//把有剩余数据的一边的数据依次全部填充到temp
  		while( i <= mid) { //左边的有序序列还有剩余的元素，就全部填充到temp
  			temp[t] = arr[i];
  			t += 1;
  			i += 1;	
  		}
  		
  		while( j <= right) { //右边的有序序列还有剩余的元素，就全部填充到temp
  			temp[t] = arr[j];
  			t += 1;
  			j += 1;	
  		}
  		
  		
  		//(三)
  		//将temp数组的元素拷贝到arr
  		//注意，并不是每次都拷贝所有
  		t = 0;
  		int tempLeft = left; // 
  		//第一次合并 tempLeft = 0 , right = 1 //  tempLeft = 2  right = 3 // tL=0 ri=3
  		//最后一次 tempLeft = 0  right = 7
  		while(tempLeft <= right) { 
  			arr[tempLeft] = temp[t];
  			t += 1;
  			tempLeft += 1;
  		}	
  	}
  

5.7 基数排序

• 基本介绍

  用空间换时间

• 思路分析

  

• 代码实现

  public static void radixSort(int[] arr) {
  		
  		//根据前面的推导过程，我们可以得到最终的基数排序代码
  		
  		//1. 得到数组中最大的数的位数
  		int max = arr[0]; //假设第一数就是最大数
  		for(int i = 1; i < arr.length; i++) {
  			if (arr[i] > max) {
  				max = arr[i];
  			}
  		}
  		//得到最大数是几位数
  		int maxLength = (max + "").length();
  		
  		
  		//定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
  		//说明
  		//1. 二维数组包含10个一维数组
  		//2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length
  		//3. 名明确，基数排序是使用空间换时间的经典算法
  		int[][] bucket = new int[10][arr.length];
  		
  		//为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
  		//可以这里理解
  		//比如：bucketElementCounts[0] , 记录的就是  bucket[0] 桶的放入数据个数
  		int[] bucketElementCounts = new int[10];
  		
  		
  		//这里我们使用循环将代码处理
  		
  		for(int i = 0 , n = 1; i < maxLength; i++, n *= 10) {
  			//(针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位..
  			for(int j = 0; j < arr.length; j++) {
  				//取出每个元素的对应位的值
  				int digitOfElement = arr[j] / n % 10;
  				//放入到对应的桶中
  				bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
  				bucketElementCounts[digitOfElement]++;
  			}
  			//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
  			int index = 0;
  			//遍历每一桶，并将桶中是数据，放入到原数组
  			for(int k = 0; k < bucketElementCounts.length; k++) {
  				//如果桶中，有数据，我们才放入到原数组
  				if(bucketElementCounts[k] != 0) {
  					//循环该桶即第k个桶(即第k个一维数组), 放入
  					for(int l = 0; l < bucketElementCounts[k]; l++) {
  						//取出元素放入到arr
  						arr[index++] = bucket[k][l];
  					}
  				}
  				//第i+1轮处理后，需要将每个 bucketElementCounts[k] = 0 ！！！！
  				bucketElementCounts[k] = 0;
  				
  			}
  			//System.out.println("第"+(i+1)+"轮，对个位的排序处理 arr =" + Arrays.toString(arr));		
  		}
  

• 说明

  1. 基数排序是对传统桶排序的扩展，速度很快
  2. 基数排序是经典的空间换时间的方式，占用内存很大，当对海量数据排序时，容易造成 OutOfMemoryError
  3. 基数排序是稳定的
  4. 有负数的数组，我们不用基数排序来进行排序

5.8 堆排序

• 思路分析

• 代码实现

  public class HeapSort {
  
  	public static void main(String[] args) {
  		//要求将数组进行升序排序
  		//int arr[] = {4, 6, 8, 5, 9};
  		// 创建要给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);
  		
  		heapSort(arr);
  		
  		Date data2 = new Date();
  		String date2Str = simpleDateFormat.format(data2);
  		System.out.println("排序前的时间是=" + date2Str);
  		//System.out.println("排序后=" + Arrays.toString(arr));
  	}
  
  	//编写一个堆排序的方法
  	public static void heapSort(int arr[]) {
  		int temp = 0;
  		System.out.println("堆排序!!");
  		
  //		//分步完成
  //		adjustHeap(arr, 1, arr.length);
  //		System.out.println("第一次" + Arrays.toString(arr)); // 4, 9, 8, 5, 6
  //		
  //		adjustHeap(arr, 0, arr.length);
  //		System.out.println("第2次" + Arrays.toString(arr)); // 9,6,8,5,4
  		
  		//完成我们最终代码
  		//将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
  		for(int i = arr.length / 2 -1; i >=0; i--) {
  			adjustHeap(arr, i, arr.length);
  		}
  		
  		/*
  		 * 2).将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
  　　			3).重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
  		 */
  		for(int j = arr.length-1;j >0; j--) {
  			//交换
  			temp = arr[j];
  			arr[j] = arr[0];
  			arr[0] = temp;
  			adjustHeap(arr, 0, j); 
  		}
  		
  		//System.out.println("数组=" + Arrays.toString(arr)); 
  		
  	}
  	
  	//将一个数组(二叉树), 调整成一个大顶堆
  	/**
  	 * 功能： 完成 将 以 i 对应的非叶子结点的树调整成大顶堆
  	 * 举例  int arr[] = {4, 6, 8, 5, 9}; => i = 1 => adjustHeap => 得到 {4, 9, 8, 5, 6}
  	 * 如果我们再次调用  adjustHeap 传入的是 i = 0 => 得到 {4, 9, 8, 5, 6} => {9,6,8,5, 4}
  	 * @param arr 待调整的数组
  	 * @param i 表示非叶子结点在数组中索引
  	 * @param lenght 表示对多少个元素继续调整， length 是在逐渐的减少
  	 */
  	public  static void adjustHeap(int arr[], int i, int lenght) {
  		
  		int temp = arr[i];//先取出当前元素的值，保存在临时变量
  		//开始调整
  		//说明
  		//1. k = i * 2 + 1 k 是 i结点的左子结点
  		for(int k = i * 2 + 1; k < lenght; k = k * 2 + 1) {
  			if(k+1 < lenght && arr[k] < arr[k+1]) { //说明左子结点的值小于右子结点的值
  				k++; // k 指向右子结点
  			}
  			if(arr[k] > temp) { //如果子结点大于父结点
  				arr[i] = arr[k]; //把较大的值赋给当前结点
  				i = k; //!!! i 指向 k,继续循环比较
  			} else {
  				break;//!
  			}
  		}
  		//当for 循环结束后，我们已经将以i 为父结点的树的最大值，放在了 最顶(局部)
  		arr[i] = temp;//将temp值放到调整后的位置
  	}	
  }
  

6 查照算法

• 常用方法
  1. 顺序（线性）查找
  2. 二分查找/折半查找
  3. 插值查找
  4. 斐波那契查找

6.1 线性查找

按照顺序逐一查找

6.2 二分查找

• 思路分析

  注意：使用二分查找前提数组是有序的

• 代码实现

  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;
  		}
  
  	}
  

6.3 插值查找

• 基本介绍

  插值算法类似于二分查找，不同的是插值查找每次从自适应mid处开始查找，要求数组为有序。

• 公式

• 代码实现

  public static int insertValueSearch(int[] arr, int left, int right, int findVal) { 
  
  		System.out.println("插值查找次数~~");
  		
  		//注意：findVal < arr[0]  和  findVal > arr[arr.length - 1] 必须需要
  		//否则我们得到的 mid 可能越界
  		if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
  			return -1;
  		}
  
  		// 求出mid, 自适应
  		int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
  		int midVal = arr[mid];
  		if (findVal > midVal) { // 说明应该向右边递归
  			return insertValueSearch(arr, mid + 1, right, findVal);
  		} else if (findVal < midVal) { // 说明向左递归查找
  			return insertValueSearch(arr, left, mid - 1, findVal);
  		} else {
  			return mid;
  		}
  	}
  

6.4 斐波那契查找

• 基本介绍

  注意：数组需为有序数列

  

• 代码实现

  //因为后面我们mid=low+F(k-1)-1，需要使用到斐波那契数列，因此我们需要先获取到一个斐波那契数列
  	//非递归方法得到一个斐波那契数列
  	public static int[] fib() {
  		int[] f = new int[maxSize];
  		f[0] = 1;
  		f[1] = 1;
  		for (int i = 2; i < maxSize; i++) {
  			f[i] = f[i - 1] + f[i - 2];
  		}
  		return f;
  	}
  	
  	//编写斐波那契查找算法
  	//使用非递归的方式编写算法
  	/**
  	 * 
  	 * @param a  数组
  	 * @param key 我们需要查找的关键码(值)
  	 * @return 返回对应的下标，如果没有-1
  	 */
  	public static int fibSearch(int[] a, int key) {
  		int low = 0;
  		int high = a.length - 1;
  		int k = 0; //表示斐波那契分割数值的下标
  		int mid = 0; //存放mid值
  		int f[] = fib(); //获取到斐波那契数列
  		//获取到斐波那契分割数值的下标
  		while(high > f[k] - 1) {
  			k++;
  		}
  		//因为 f[k] 值 可能大于 a 的 长度，因此我们需要使用Arrays类，构造一个新的数组，并指向temp[]
  		//不足的部分会使用0填充
  		int[] temp = Arrays.copyOf(a, f[k]);
  		//实际上需求使用a数组最后的数填充 temp
  		//举例:
  		//temp = {1,8, 10, 89, 1000, 1234, 0, 0}  => {1,8, 10, 89, 1000, 1234, 1234, 1234,}
  		for(int i = high + 1; i < temp.length; i++) {
  			temp[i] = a[high];
  		}
  		
  		// 使用while来循环处理，找到我们的数 key
  		while (low <= high) { // 只要这个条件满足，就可以找
  			mid = low + f[k - 1] - 1;
  			if(key < temp[mid]) { //我们应该继续向数组的前面查找(左边)
  				high = mid - 1;
  				//为甚是 k--
  				//说明
  				//1. 全部元素 = 前面的元素 + 后边元素
  				//2. f[k] = f[k-1] + f[k-2]
  				//因为 前面有 f[k-1]个元素,所以可以继续拆分 f[k-1] = f[k-2] + f[k-3]
  				//即 在 f[k-1] 的前面继续查找 k--
  				//即下次循环 mid = f[k-1-1]-1
  				k--;
  			} else if ( key > temp[mid]) { // 我们应该继续向数组的后面查找(右边)
  				low = mid + 1;
  				//为什么是k -=2
  				//说明
  				//1. 全部元素 = 前面的元素 + 后边元素
  				//2. f[k] = f[k-1] + f[k-2]
  				//3. 因为后面我们有f[k-2] 所以可以继续拆分 f[k-1] = f[k-3] + f[k-4]
  				//4. 即在f[k-2] 的前面进行查找 k -=2
  				//5. 即下次循环 mid = f[k - 1 - 2] - 1
  				k -= 2;
  			} else { //找到
  				//需要确定，返回的是哪个下标
  				if(mid <= high) {
  					return mid;
  				} else {
  					return high;
  				}
  			}
  		}
  		return -1;
  	}
  

7 哈希表

• 基本介绍

  散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表

• 例题

  public class HashTabDemo {
  
      public static void main(String[] args) {
  
          //创建哈希表
          HashTab hashTab = new HashTab(7);
  
          //写一个简单的菜单
          String key = "";
          Scanner scanner = new Scanner(System.in);
          while (true) {
              System.out.println("add:  添加雇员");
              System.out.println("list: 显示雇员");
              System.out.println("find: 查找雇员");
              System.out.println("exit: 退出系统");
  
              key = scanner.next();
              switch (key) {
                  case "add":
                      System.out.println("输入id");
                      int id = scanner.nextInt();
                      System.out.println("输入名字");
                      String name = scanner.next();
                      //创建 雇员
                      Emp emp = new Emp(id, name);
                      hashTab.add(emp);
                      break;
                  case "list":
                      hashTab.list();
                      break;
                  case "find":
                      System.out.println("请输入要查找的id");
                      id = scanner.nextInt();
                      hashTab.findEmpById(id);
                      break;
                  case "exit":
                      scanner.close();
                      System.exit(0);
                  default:
                      break;
              }
          }
      }
  }
  
  //创建HashTab 管理多条链表
  class HashTab {
      private EmpLinkedList[] empLinkedListArray;
      private int size; //表示有多少条链表
  
      //构造器
      public HashTab(int size) {
          this.size = size;
          //初始化empLinkedListArray
          empLinkedListArray = new EmpLinkedList[size];
          //？留一个坑, 这时不要分别初始化每个链表
          for (int i = 0; i < size; i++) {
              empLinkedListArray[i] = new EmpLinkedList();
          }
      }
  
      //添加雇员
      public void add(Emp emp) {
          //根据员工的id ,得到该员工应当添加到哪条链表
          int empLinkedListNO = hashFun(emp.id);
          //将emp 添加到对应的链表中
          empLinkedListArray[empLinkedListNO].add(emp);
  
      }
  
      //遍历所有的链表,遍历hashtab
      public void list() {
          for (int i = 0; i < size; i++) {
              empLinkedListArray[i].list(i);
          }
      }
  
      //根据输入的id,查找雇员
      public void findEmpById(int id) {
          //使用散列函数确定到哪条链表查找
          int empLinkedListNO = hashFun(id);
          Emp emp = empLinkedListArray[empLinkedListNO].findEmpById(id);
          if (emp != null) {//找到
              System.out.printf("在第%d条链表中找到 雇员 id = %d\n", (empLinkedListNO + 1), id);
          } else {
              System.out.println("在哈希表中，没有找到该雇员~");
          }
      }
  
      //编写散列函数, 使用一个简单取模法
      public int hashFun(int id) {
          return id % size;
      }
  
  
  }
  
  //表示一个雇员
  class Emp {
      public int id;
      public String name;
      public Emp next; //next 默认为 null
  
      public Emp(int id, String name) {
          super();
          this.id = id;
          this.name = name;
      }
  }
  
  //创建EmpLinkedList ,表示链表
  class EmpLinkedList {
      //头指针，执行第一个Emp,因此我们这个链表的head 是直接指向第一个Emp
      private Emp head; //默认null
  
      //添加雇员到链表
      //说明
      //1. 假定，当添加雇员时，id 是自增长，即id的分配总是从小到大
      //   因此我们将该雇员直接加入到本链表的最后即可
      public void add(Emp emp) {
          //如果是添加第一个雇员
          if (head == null) {
              head = emp;
              return;
          }
          //如果不是第一个雇员，则使用一个辅助的指针，帮助定位到最后
          Emp curEmp = head;
          while (true) {
              if (curEmp.next == null) {//说明到链表最后
                  break;
              }
              curEmp = curEmp.next; //后移
          }
          //退出时直接将emp 加入链表
          curEmp.next = emp;
      }
  
      //遍历链表的雇员信息
      public void list(int no) {
          if (head == null) { //说明链表为空
              System.out.println("第 " + (no + 1) + " 链表为空");
              return;
          }
          System.out.print("第 " + (no + 1) + " 链表的信息为");
          Emp curEmp = head; //辅助指针
          while (true) {
              System.out.printf(" => id=%d name=%s\t", curEmp.id, curEmp.name);
              if (curEmp.next == null) {//说明curEmp已经是最后结点
                  break;
              }
              curEmp = curEmp.next; //后移，遍历
          }
          System.out.println();
      }
  
      //根据id查找雇员
      //如果查找到，就返回Emp, 如果没有找到，就返回null
      public Emp findEmpById(int id) {
          //判断链表是否为空
          if (head == null) {
              System.out.println("链表为空");
              return null;
          }
          //辅助指针
          Emp curEmp = head;
          while (true) {
              if (curEmp.id == id) {//找到
                  break;//这时curEmp就指向要查找的雇员
              }
              //退出
              if (curEmp.next == null) {//说明遍历当前链表没有找到该雇员
                  curEmp = null;
                  break;
              }
              curEmp = curEmp.next;//以后
          }
          return curEmp;
      }
  }
  

8 树

8.1 二叉树

• 基本介绍

  1. 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
  2. 二叉树的子节点分为左节点和右节点
  3. 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树
  4. 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树

• 遍历

  1. 前序遍历: 先输出父节点，再遍历左子树和右子树

  2. 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树

  3. 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p3nYeDfo-1682753464169)(https://zuimeiweidebingqilin-1317588512.cos.ap-shanghai.myqcloud.com/lj/%E4%BA%8C%E5%8F%89%E6%A0%91%E9%81%8D%E5%8E%86%E6%96%B9%E6%B3%95.jpg)]

• 查找节点

• 删除节点

• 代码实现

  public class BinaryTreeDemo {
  
      public static void main(String[] args) {
          //先需要创建一颗二叉树
          BinaryTree binaryTree = new BinaryTree();
          //创建需要的结点
          HeroNode root = new HeroNode(1, "宋江");
          HeroNode node2 = new HeroNode(2, "吴用");
          HeroNode node3 = new HeroNode(3, "卢俊义");
          HeroNode node4 = new HeroNode(4, "林冲");
          HeroNode node5 = new HeroNode(5, "关胜");
  
          //说明，我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树
          root.setLeft(node2);
          root.setRight(node3);
          node3.setRight(node4);
          node3.setLeft(node5);
          binaryTree.setRoot(root);
  
          //测试
  //		System.out.println("前序遍历"); // 1,2,3,5,4
  //		binaryTree.preOrder();
  
          //测试 
  //		System.out.println("中序遍历");
  //		binaryTree.infixOrder(); // 2,1,5,3,4
  //		
  //		System.out.println("后序遍历");
  //		binaryTree.postOrder(); // 2,5,4,3,1
  
          //前序遍历
          //前序遍历的次数 ：4 
  //		System.out.println("前序遍历方式~~~");
  //		HeroNode resNode = binaryTree.preOrderSearch(5);
  //		if (resNode != null) {
  //			System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
  //		} else {
  //			System.out.printf("没有找到 no = %d 的英雄", 5);
  //		}
  
          //中序遍历查找
          //中序遍历3次
  //		System.out.println("中序遍历方式~~~");
  //		HeroNode resNode = binaryTree.infixOrderSearch(5);
  //		if (resNode != null) {
  //			System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
  //		} else {
  //			System.out.printf("没有找到 no = %d 的英雄", 5);
  //		}
  
          //后序遍历查找
          //后序遍历查找的次数  2次
  //		System.out.println("后序遍历方式~~~");
  //		HeroNode resNode = binaryTree.postOrderSearch(5);
  //		if (resNode != null) {
  //			System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
  //		} else {
  //			System.out.printf("没有找到 no = %d 的英雄", 5);
  //		}
  
          //测试一把删除结点
  
          System.out.println("删除前,前序遍历");
          binaryTree.preOrder(); //  1,2,3,5,4
          binaryTree.delNode(5);
          //binaryTree.delNode(3);
          System.out.println("删除后，前序遍历");
          binaryTree.preOrder(); // 1,2,3,4
  
  
      }
  
  }
  
  //定义BinaryTree 二叉树
  class BinaryTree {
      private HeroNode root;
  
      public void setRoot(HeroNode root) {
          this.root = root;
      }
  
      //删除结点
      public void delNode(int no) {
          if (root != null) {
              //如果只有一个root结点, 这里立即判断root是不是就是要删除结点
              if (root.getNo() == no) {
                  root = null;
              } else {
                  //递归删除
                  root.delNode(no);
              }
          } else {
              System.out.println("空树，不能删除~");
          }
      }
  
      //前序遍历
      public void preOrder() {
          if (this.root != null) {
              this.root.preOrder();
          } else {
              System.out.println("二叉树为空，无法遍历");
          }
      }
  
      //中序遍历
      public void infixOrder() {
          if (this.root != null) {
              this.root.infixOrder();
          } else {
              System.out.println("二叉树为空，无法遍历");
          }
      }
  
      //后序遍历
      public void postOrder() {
          if (this.root != null) {
              this.root.postOrder();
          } else {
              System.out.println("二叉树为空，无法遍历");
          }
      }
  
      //前序遍历
      public HeroNode preOrderSearch(int no) {
          if (root != null) {
              return root.preOrderSearch(no);
          } else {
              return null;
          }
      }
  
      //中序遍历
      public HeroNode infixOrderSearch(int no) {
          if (root != null) {
              return root.infixOrderSearch(no);
          } else {
              return null;
          }
      }
  
      //后序遍历
      public HeroNode postOrderSearch(int no) {
          if (root != null) {
              return this.root.postOrderSearch(no);
          } else {
              return null;
          }
      }
  }
  
  //先创建HeroNode 结点
  class HeroNode {
      private int no;
      private String name;
      private HeroNode left; //默认null
      private HeroNode right; //默认null
  
      public HeroNode(int no, String name) {
          this.no = no;
          this.name = name;
      }
  
      public int getNo() {
          return no;
      }
  
      public void setNo(int no) {
          this.no = no;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public HeroNode getLeft() {
          return left;
      }
  
      public void setLeft(HeroNode left) {
          this.left = left;
      }
  
      public HeroNode getRight() {
          return right;
      }
  
      public void setRight(HeroNode right) {
          this.right = right;
      }
  
      @Override
      public String toString() {
          return "HeroNode [no=" + no + ", name=" + name + "]";
      }
  
      //递归删除结点
      //1.如果删除的节点是叶子节点，则删除该节点
      //2.如果删除的节点是非叶子节点，则删除该子树
      public void delNode(int no) {
  
          //思路
  		/*
  		 * 	1. 因为我们的二叉树是单向的，所以我们是判断当前结点的子结点是否需要删除结点，而不能去判断当前这个结点是不是需要删除结点.
  			2. 如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null; 并且就返回(结束递归删除)
  			3. 如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将this.right= null ;并且就返回(结束递归删除)
  			4. 如果第2和第3步没有删除结点，那么我们就需要向左子树进行递归删除
  			5.  如果第4步也没有删除结点，则应当向右子树进行递归删除.
  
  		 */
          //2. 如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null; 并且就返回(结束递归删除)
          if (this.left != null && this.left.no == no) {
              this.left = null;
              return;
          }
          //3.如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将this.right= null ;并且就返回(结束递归删除)
          if (this.right != null && this.right.no == no) {
              this.right = null;
              return;
          }
          //4.我们就需要向左子树进行递归删除
          if (this.left != null) {
              this.left.delNode(no);
          }
          //5.则应当向右子树进行递归删除
          if (this.right != null) {
              this.right.delNode(no);
          }
      }
  
      //编写前序遍历的方法
      public void preOrder() {
          System.out.println(this); //先输出父结点
          //递归向左子树前序遍历
          if (this.left != null) {
              this.left.preOrder();
          }
          //递归向右子树前序遍历
          if (this.right != null) {
              this.right.preOrder();
          }
      }
  
      //中序遍历
      public void infixOrder() {
  
          //递归向左子树中序遍历
          if (this.left != null) {
              this.left.infixOrder();
          }
          //输出父结点
          System.out.println(this);
          //递归向右子树中序遍历
          if (this.right != null) {
              this.right.infixOrder();
          }
      }
  
      //后序遍历
      public void postOrder() {
          if (this.left != null) {
              this.left.postOrder();
          }
          if (this.right != null) {
              this.right.postOrder();
          }
          System.out.println(this);
      }
  
      //前序遍历查找
  
      /**
       * @param no 查找no
       * @return 如果找到就返回该Node ,如果没有找到返回 null
       */
      public HeroNode preOrderSearch(int no) {
          System.out.println("进入前序遍历");
          //比较当前结点是不是
          if (this.no == no) {
              return this;
          }
          //1.则判断当前结点的左子节点是否为空，如果不为空，则递归前序查找
          //2.如果左递归前序查找，找到结点，则返回
          HeroNode resNode = null;
          if (this.left != null) {
              resNode = this.left.preOrderSearch(no);
          }
          if (resNode != null) {//说明我们左子树找到
              return resNode;
          }
          //1.左递归前序查找，找到结点，则返回，否继续判断，
          //2.当前的结点的右子节点是否为空，如果不空，则继续向右递归前序查找
          if (this.right != null) {
              resNode = this.right.preOrderSearch(no);
          }
          return resNode;
      }
  
      //中序遍历查找
      public HeroNode infixOrderSearch(int no) {
          //判断当前结点的左子节点是否为空，如果不为空，则递归中序查找
          HeroNode resNode = null;
          if (this.left != null) {
              resNode = this.left.infixOrderSearch(no);
          }
          if (resNode != null) {
              return resNode;
          }
          System.out.println("进入中序查找");
          //如果找到，则返回，如果没有找到，就和当前结点比较，如果是则返回当前结点
          if (this.no == no) {
              return this;
          }
          //否则继续进行右递归的中序查找
          if (this.right != null) {
              resNode = this.right.infixOrderSearch(no);
          }
          return resNode;
  
      }
  
      //后序遍历查找
      public HeroNode postOrderSearch(int no) {
  
          //判断当前结点的左子节点是否为空，如果不为空，则递归后序查找
          HeroNode resNode = null;
          if (this.left != null) {
              resNode = this.left.postOrderSearch(no);
          }
          if (resNode != null) {//说明在左子树找到
              return resNode;
          }
  
          //如果左子树没有找到，则向右子树递归进行后序遍历查找
          if (this.right != null) {
              resNode = this.right.postOrderSearch(no);
          }
          if (resNode != null) {
              return resNode;
          }
          System.out.println("进入后序查找");
          //如果左右子树都没有找到，就比较当前结点是不是
          if (this.no == no) {
              return this;
          }
          return resNode;
      }
  
  }
  

8.2 顺序存储二叉树

• 特点

  1. 顺序二叉树通常只考虑完全二叉树
  2. 第 n 个元素的左子节点为 2 * n + 1
  3. 第 n 个元素的右子节点为 2 * n + 2
  4. 第 n 个元素的父节点为 (n-1) / 2
  5. n : 表示二叉树中的第几个元素(按0开始编号）

• 代码实现

  public class ArrBinaryTreeDemo {
  
      public static void main(String[] args) {
          int[] arr = {1, 2, 3, 4, 5, 6, 7};
          //创建一个 ArrBinaryTree
          ArrBinaryTree arrBinaryTree = new ArrBinaryTree(arr);
          arrBinaryTree.preOrder(); // 1,2,4,5,3,6,7
      }
  
  }
  
  //编写一个ArrayBinaryTree, 实现顺序存储二叉树遍历
  
  class ArrBinaryTree {
      private int[] arr;//存储数据结点的数组
  
      public ArrBinaryTree(int[] arr) {
          this.arr = arr;
      }
  
      //重载preOrder
      public void preOrder() {
          this.preOrder(0);
      }
  
      //编写一个方法，完成顺序存储二叉树的前序遍历
  
      /**
       * @param index 数组的下标
       */
      public void preOrder(int index) {
          //如果数组为空，或者 arr.length = 0
          if (arr == null || arr.length == 0) {
              System.out.println("数组为空，不能按照二叉树的前序遍历");
          }
          //输出当前这个元素
          System.out.println(arr[index]);
          //向左递归遍历
          if ((index * 2 + 1) < arr.length) {
              preOrder(2 * index + 1);
          }
          //向右递归遍历
          if ((index * 2 + 2) < arr.length) {
              preOrder(2 * index + 2);
          }
      }
  }
  

8.3 线索二叉树

• 基本介绍

  1. n 个结点的二叉链表中含有 n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）

  2. 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种

  3. 一个结点的前一个结点，称为前驱结点

  4. 一个结点的后一个结点，称为后继结点

• 代码实现

  package com.atguigu.tree.threadedbinarytree;
  
  import java.util.concurrent.SynchronousQueue;
  
  public class ThreadedBinaryTreeDemo {
  
      public static void main(String[] args) {
          //测试一把中序线索二叉树的功能
          HeroNode root = new HeroNode(1, "tom");
          HeroNode node2 = new HeroNode(3, "jack");
          HeroNode node3 = new HeroNode(6, "smith");
          HeroNode node4 = new HeroNode(8, "mary");
          HeroNode node5 = new HeroNode(10, "king");
          HeroNode node6 = new HeroNode(14, "dim");
  
          //二叉树，后面我们要递归创建, 现在简单处理使用手动创建
          root.setLeft(node2);
          root.setRight(node3);
          node2.setLeft(node4);
          node2.setRight(node5);
          node3.setLeft(node6);
  
          //测试中序线索化
          ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
          threadedBinaryTree.setRoot(root);
          threadedBinaryTree.threadedNodes();
  
          //测试: 以10号节点测试
          HeroNode leftNode = node5.getLeft();
          HeroNode rightNode = node5.getRight();
          System.out.println("10号结点的前驱结点是 =" + leftNode); //3
          System.out.println("10号结点的后继结点是=" + rightNode); //1
  
          //当线索化二叉树后，能在使用原来的遍历方法
          //threadedBinaryTree.infixOrder();
          System.out.println("使用线索化的方式遍历 线索化二叉树");
          threadedBinaryTree.threadedList(); // 8, 3, 10, 1, 14, 6
  
      }
  
  }
  
  
  //定义ThreadedBinaryTree 实现了线索化功能的二叉树
  class ThreadedBinaryTree {
      private HeroNode root;
  
      //为了实现线索化，需要创建要给指向当前结点的前驱结点的指针
      //在递归进行线索化时，pre 总是保留前一个结点
      private HeroNode pre = null;
  
      public void setRoot(HeroNode root) {
          this.root = root;
      }
  
      //重载一把threadedNodes方法
      public void threadedNodes() {
          this.threadedNodes(root);
      }
  
      //遍历线索化二叉树的方法
      public void threadedList() {
          //定义一个变量，存储当前遍历的结点，从root开始
          HeroNode node = root;
          while (node != null) {
              //循环的找到leftType == 1的结点，第一个找到就是8结点
              //后面随着遍历而变化,因为当leftType==1时，说明该结点是按照线索化
              //处理后的有效结点
              while (node.getLeftType() == 0) {
                  node = node.getLeft();
              }
  
              //打印当前这个结点
              System.out.println(node);
              //如果当前结点的右指针指向的是后继结点,就一直输出
              while (node.getRightType() == 1) {
                  //获取到当前结点的后继结点
                  node = node.getRight();
                  System.out.println(node);
              }
              //替换这个遍历的结点
              node = node.getRight();
  
          }
      }
  
      //编写对二叉树进行中序线索化的方法
  
      /**
       * @param node 就是当前需要线索化的结点
       */
      public void threadedNodes(HeroNode node) {
  
          //如果node==null, 不能线索化
          if (node == null) {
              return;
          }
  
          //(一)先线索化左子树
          threadedNodes(node.getLeft());
          //(二)线索化当前结点[有难度]
  
          //处理当前结点的前驱结点
          //以8结点来理解
          //8结点的.left = null , 8结点的.leftType = 1
          if (node.getLeft() == null) {
              //让当前结点的左指针指向前驱结点 
              node.setLeft(pre);
              //修改当前结点的左指针的类型,指向前驱结点
              node.setLeftType(1);
          }
  
          //处理后继结点
          if (pre != null && pre.getRight() == null) {
              //让前驱结点的右指针指向当前结点
              pre.setRight(node);
              //修改前驱结点的右指针类型
              pre.setRightType(1);
          }
          //!!! 每处理一个结点后，让当前结点是下一个结点的前驱结点
          pre = node;
  
          //(三)在线索化右子树
          threadedNodes(node.getRight());
  
  
      }
  
      //删除结点
      public void delNode(int no) {
          if (root != null) {
              //如果只有一个root结点, 这里立即判断root是不是就是要删除结点
              if (root.getNo() == no) {
                  root = null;
              } else {
                  //递归删除
                  root.delNode(no);
              }
          } else {
              System.out.println("空树，不能删除~");
          }
      }
  
      //前序遍历
      public void preOrder() {
          if (this.root != null) {
              this.root.preOrder();
          } else {
              System.out.println("二叉树为空，无法遍历");
          }
      }
  
      //中序遍历
      public void infixOrder() {
          if (this.root != null) {
              this.root.infixOrder();
          } else {
              System.out.println("二叉树为空，无法遍历");
          }
      }
  
      //后序遍历
      public void postOrder() {
          if (this.root != null) {
              this.root.postOrder();
          } else {
              System.out.println("二叉树为空，无法遍历");
          }
      }
  
      //前序遍历
      public HeroNode preOrderSearch(int no) {
          if (root != null) {
              return root.preOrderSearch(no);
          } else {
              return null;
          }
      }
  
      //中序遍历
      public HeroNode infixOrderSearch(int no) {
          if (root != null) {
              return root.infixOrderSearch(no);
          } else {
              return null;
          }
      }
  
      //后序遍历
      public HeroNode postOrderSearch(int no) {
          if (root != null) {
              return this.root.postOrderSearch(no);
          } else {
              return null;
          }
      }
  }
  
  //先创建HeroNode 结点
  class HeroNode {
      private int no;
      private String name;
      private HeroNode left; //默认null
      private HeroNode right; //默认null
      //说明
      //1. 如果leftType == 0 表示指向的是左子树, 如果 1 则表示指向前驱结点
      //2. 如果rightType == 0 表示指向是右子树, 如果 1表示指向后继结点
      private int leftType;
      private int rightType;
  
  
      public int getLeftType() {
          return leftType;
      }
  
      public void setLeftType(int leftType) {
          this.leftType = leftType;
      }
  
      public int getRightType() {
          return rightType;
      }
  
      public void setRightType(int rightType) {
          this.rightType = rightType;
      }
  
      public HeroNode(int no, String name) {
          this.no = no;
          this.name = name;
      }
  
      public int getNo() {
          return no;
      }
  
      public void setNo(int no) {
          this.no = no;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public HeroNode getLeft() {
          return left;
      }
  
      public void setLeft(HeroNode left) {
          this.left = left;
      }
  
      public HeroNode getRight() {
          return right;
      }
  
      public void setRight(HeroNode right) {
          this.right = right;
      }
  
      @Override
      public String toString() {
          return "HeroNode [no=" + no + ", name=" + name + "]";
      }
  
      //递归删除结点
      //1.如果删除的节点是叶子节点，则删除该节点
      //2.如果删除的节点是非叶子节点，则删除该子树
      public void delNode(int no) {
  
          //思路
  		/*
  		 * 	1. 因为我们的二叉树是单向的，所以我们是判断当前结点的子结点是否需要删除结点，而不能去判断当前这个结点是不是需要删除结点.
  			2. 如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null; 并且就返回(结束递归删除)
  			3. 如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将this.right= null ;并且就返回(结束递归删除)
  			4. 如果第2和第3步没有删除结点，那么我们就需要向左子树进行递归删除
  			5.  如果第4步也没有删除结点，则应当向右子树进行递归删除.
  
  		 */
          //2. 如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null; 并且就返回(结束递归删除)
          if (this.left != null && this.left.no == no) {
              this.left = null;
              return;
          }
          //3.如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将this.right= null ;并且就返回(结束递归删除)
          if (this.right != null && this.right.no == no) {
              this.right = null;
              return;
          }
          //4.我们就需要向左子树进行递归删除
          if (this.left != null) {
              this.left.delNode(no);
          }
          //5.则应当向右子树进行递归删除
          if (this.right != null) {
              this.right.delNode(no);
          }
      }
  
      //编写前序遍历的方法
      public void preOrder() {
          System.out.println(this); //先输出父结点
          //递归向左子树前序遍历
          if (this.left != null) {
              this.left.preOrder();
          }
          //递归向右子树前序遍历
          if (this.right != null) {
              this.right.preOrder();
          }
      }
  
      //中序遍历
      public void infixOrder() {
  
          //递归向左子树中序遍历
          if (this.left != null) {
              this.left.infixOrder();
          }
          //输出父结点
          System.out.println(this);
          //递归向右子树中序遍历
          if (this.right != null) {
              this.right.infixOrder();
          }
      }
  
      //后序遍历
      public void postOrder() {
          if (this.left != null) {
              this.left.postOrder();
          }
          if (this.right != null) {
              this.right.postOrder();
          }
          System.out.println(this);
      }
  
      //前序遍历查找
  
      /**
       * @param no 查找no
       * @return 如果找到就返回该Node ,如果没有找到返回 null
       */
      public HeroNode preOrderSearch(int no) {
          System.out.println("进入前序遍历");
          //比较当前结点是不是
          if (this.no == no) {
              return this;
          }
          //1.则判断当前结点的左子节点是否为空，如果不为空，则递归前序查找
          //2.如果左递归前序查找，找到结点，则返回
          HeroNode resNode = null;
          if (this.left != null) {
              resNode = this.left.preOrderSearch(no);
          }
          if (resNode != null) {//说明我们左子树找到
              return resNode;
          }
          //1.左递归前序查找，找到结点，则返回，否继续判断，
          //2.当前的结点的右子节点是否为空，如果不空，则继续向右递归前序查找
          if (this.right != null) {
              resNode = this.right.preOrderSearch(no);
          }
          return resNode;
      }
  
      //中序遍历查找
      public HeroNode infixOrderSearch(int no) {
          //判断当前结点的左子节点是否为空，如果不为空，则递归中序查找
          HeroNode resNode = null;
          if (this.left != null) {
              resNode = this.left.infixOrderSearch(no);
          }
          if (resNode != null) {
              return resNode;
          }
          System.out.println("进入中序查找");
          //如果找到，则返回，如果没有找到，就和当前结点比较，如果是则返回当前结点
          if (this.no == no) {
              return this;
          }
          //否则继续进行右递归的中序查找
          if (this.right != null) {
              resNode = this.right.infixOrderSearch(no);
          }
          return resNode;
  
      }
  
      //后序遍历查找
      public HeroNode postOrderSearch(int no) {
  
          //判断当前结点的左子节点是否为空，如果不为空，则递归后序查找
          HeroNode resNode = null;
          if (this.left != null) {
              resNode = this.left.postOrderSearch(no);
          }
          if (resNode != null) {//说明在左子树找到
              return resNode;
          }
  
          //如果左子树没有找到，则向右子树递归进行后序遍历查找
          if (this.right != null) {
              resNode = this.right.postOrderSearch(no);
          }
          if (resNode != null) {
              return resNode;
          }
          System.out.println("进入后序查找");
          //如果左右子树都没有找到，就比较当前结点是不是
          if (this.no == no) {
              return this;
          }
          return resNode;
      }
  }
  

9 树

9.1 赫夫曼树

• 基本介绍

  1. 给定 n 个权值（值）作为 n 个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman Tree), 还有的书翻译为霍夫曼树。
  2. 赫夫曼树是带权路径长度（路劲长度与该节点权值的乘积）最短的树，权值较大的结点离根较近

• 构成步骤

  1. 从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一颗最简单的二叉树

  2. 取出根节点权值最小的两颗二叉树

  3. 组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和

  4. 再将这颗新的二叉树，以根节点的权值大小 再次排序， 不断重复 1-2-3-4 的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树

• 代码实现

  public class HuffmanTree {
  
      public static void main(String[] args) {
          int arr[] = {13, 7, 8, 3, 29, 6, 1};
          Node root = createHuffmanTree(arr);
  
          //测试一把
          preOrder(root); //
  
      }
  
      //编写一个前序遍历的方法
      public static void preOrder(Node root) {
          if (root != null) {
              root.preOrder();
          } else {
              System.out.println("是空树，不能遍历~~");
          }
      }
  
      // 创建赫夫曼树的方法
  
      /**
       * @param arr 需要创建成哈夫曼树的数组
       * @return 创建好后的赫夫曼树的root结点
       */
      public static Node createHuffmanTree(int[] arr) {
          // 第一步为了操作方便
          // 1. 遍历 arr 数组
          // 2. 将arr的每个元素构成成一个Node
          // 3. 将Node 放入到ArrayList中
          List<Node> nodes = new ArrayList<Node>();
          for (int value : arr) {
              nodes.add(new Node(value));
          }
  
          //我们处理的过程是一个循环的过程
  
  
          while (nodes.size() > 1) {
  
              //排序 从小到大 
              Collections.sort(nodes);
  
              System.out.println("nodes =" + nodes);
  
              //取出根节点权值最小的两颗二叉树 
              //(1) 取出权值最小的结点（二叉树）
              Node leftNode = nodes.get(0);
              //(2) 取出权值第二小的结点（二叉树）
              Node rightNode = nodes.get(1);
  
              //(3)构建一颗新的二叉树
              Node parent = new Node(leftNode.value + rightNode.value);
              parent.left = leftNode;
              parent.right = rightNode;
  
              //(4)从ArrayList删除处理过的二叉树
              nodes.remove(leftNode);
              nodes.remove(rightNode);
              //(5)将parent加入到nodes
              nodes.add(parent);
          }
  
          //返回哈夫曼树的root结点
          return nodes.get(0);
      }
  }
  
  // 创建结点类
  // 为了让Node 对象持续排序Collections集合排序
  // 让Node 实现Comparable接口
  class Node implements Comparable<Node> {
      int value; // 结点权值
      char c; //字符
      Node left; // 指向左子结点
      Node right; // 指向右子结点
  
      //写一个前序遍历
      public void preOrder() {
          System.out.println(this);
          if (this.left != null) {
              this.left.preOrder();
          }
          if (this.right != null) {
              this.right.preOrder();
          }
      }
  
      public Node(int value) {
          this.value = value;
      }
  
      @Override
      public String toString() {
          return "Node [value=" + value + "]";
      }
  
      @Override
      public int compareTo(Node o) {
          // TODO Auto-generated method stub
          // 表示从小到大排序
          return this.value - o.value;
      }
  }
  

9.2 赫夫曼编码

• 基本介绍

• 步骤

  1. 从小到大进行排序, 将每一个数据，每个数据都是一个节点 ， 每个节点可以看成是一颗最简单的二叉树

  2. 取出根节点权值最小的两颗二叉树

  3. 组成一颗新的二叉树, 该新的二叉树的根节点的权值是前面两颗二叉树根节点权值的和

  4. 再将这颗新的二叉树，以根节点的权值大小 再次排序， 不断重复 1-2-3-4 的步骤，直到数列中，所有的数据都被处理，就得到一颗赫夫曼树

• 注意事项

  1. 如果文件本身就是经过压缩处理的，那么使用赫夫曼编码再压缩效率不会有明显变化，比如视频，ppt等文件
  2. 赫夫曼编码是按字节来处理的，因此可以处理所有的文件（二进制文件、文本文件）
  3. 如果一个文件中的内容，重复的数据不多，压缩效果也不会很明显

• 代码实现

  public class HuffmanCode {
  
  	public static void main(String[] args) {
  		
  		//测试压缩文件
  //		String srcFile = "d://Uninstall.xml";
  //		String dstFile = "d://Uninstall.zip";
  //		
  //		zipFile(srcFile, dstFile);
  //		System.out.println("压缩文件ok~~");
  		
  		
  		//测试解压文件
  		String zipFile = "d://Uninstall.zip";
  		String dstFile = "d://Uninstall2.xml";
  		unZipFile(zipFile, dstFile);
  		System.out.println("解压成功!");
  		
  		/*
  		String content = "i like like like java do you like a java";
  		byte[] contentBytes = content.getBytes();
  		System.out.println(contentBytes.length); //40
  		
  		byte[] huffmanCodesBytes= huffmanZip(contentBytes);
  		System.out.println("压缩后的结果是:" + Arrays.toString(huffmanCodesBytes) + " 长度= " + huffmanCodesBytes.length);
  		
  		
  		//测试一把byteToBitString方法
  		//System.out.println(byteToBitString((byte)1));
  		byte[] sourceBytes = decode(huffmanCodes, huffmanCodesBytes);
  		
  		System.out.println("原来的字符串=" + new String(sourceBytes)); // "i like like like java do you like a java"
  		*/
  		
  		
  		
  		//如何将 数据进行解压(解码)  
  		//分步过程
  		/*
  		List<Node> nodes = getNodes(contentBytes);
  		System.out.println("nodes=" + nodes);
  		
  		//测试一把，创建的赫夫曼树
  		System.out.println("赫夫曼树");
  		Node huffmanTreeRoot = createHuffmanTree(nodes);
  		System.out.println("前序遍历");
  		huffmanTreeRoot.preOrder();
  		
  		//测试一把是否生成了对应的赫夫曼编码
  		Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
  		System.out.println("~生成的赫夫曼编码表= " + huffmanCodes);
  		
  		//测试
  		byte[] huffmanCodeBytes = zip(contentBytes, huffmanCodes);
  		System.out.println("huffmanCodeBytes=" + Arrays.toString(huffmanCodeBytes));//17
  		
  		//发送huffmanCodeBytes 数组 */
  		
  		
  	}
  	
  	//编写一个方法，完成对压缩文件的解压
  	/**
  	 * 
  	 * @param zipFile 准备解压的文件
  	 * @param dstFile 将文件解压到哪个路径
  	 */
  	public static void unZipFile(String zipFile, String dstFile) {
  		
  		//定义文件输入流
  		InputStream is = null;
  		//定义一个对象输入流
  		ObjectInputStream ois = null;
  		//定义文件的输出流
  		OutputStream os = null;
  		try {
  			//创建文件输入流
  			is = new FileInputStream(zipFile);
  			//创建一个和  is关联的对象输入流
  			ois = new ObjectInputStream(is);
  			//读取byte数组  huffmanBytes
  			byte[] huffmanBytes = (byte[])ois.readObject();
  			//读取赫夫曼编码表
  			Map<Byte,String> huffmanCodes = (Map<Byte,String>)ois.readObject();
  			
  			//解码
  			byte[] bytes = decode(huffmanCodes, huffmanBytes);
  			//将bytes 数组写入到目标文件
  			os = new FileOutputStream(dstFile);
  			//写数据到 dstFile 文件
  			os.write(bytes);
  		} catch (Exception e) {
  			// TODO: handle exception
  			System.out.println(e.getMessage());
  		} finally {
  			
  			try {
  				os.close();
  				ois.close();
  				is.close();
  			} catch (Exception e2) {
  				// TODO: handle exception
  				System.out.println(e2.getMessage());
  			}
  			
  		}
  	}
  	
  	//编写方法，将一个文件进行压缩
  	/**
  	 * 
  	 * @param srcFile 你传入的希望压缩的文件的全路径
  	 * @param dstFile 我们压缩后将压缩文件放到哪个目录
  	 */
  	public static void zipFile(String srcFile, String dstFile) {
  		
  		//创建输出流
  		OutputStream os = null;
  		ObjectOutputStream oos = null;
  		//创建文件的输入流
  		FileInputStream is = null;
  		try {
  			//创建文件的输入流
  			is = new FileInputStream(srcFile);
  			//创建一个和源文件大小一样的byte[]
  			byte[] b = new byte[is.available()];
  			//读取文件
  			is.read(b);
  			//直接对源文件压缩
  			byte[] huffmanBytes = huffmanZip(b);
  			//创建文件的输出流, 存放压缩文件
  			os = new FileOutputStream(dstFile);
  			//创建一个和文件输出流关联的ObjectOutputStream
  			oos = new ObjectOutputStream(os);
  			//把 赫夫曼编码后的字节数组写入压缩文件
  			oos.writeObject(huffmanBytes); //我们是把
  			//这里我们以对象流的方式写入 赫夫曼编码，是为了以后我们恢复源文件时使用
  			//注意一定要把赫夫曼编码 写入压缩文件
  			oos.writeObject(huffmanCodes);
  			
  			
  		}catch (Exception e) {
  			// TODO: handle exception
  			System.out.println(e.getMessage());
  		}finally {
  			try {
  				is.close();
  				oos.close();
  				os.close();
  			}catch (Exception e) {
  				// TODO: handle exception
  				System.out.println(e.getMessage());
  			}
  		}	
  	}
  	
  	//完成数据的解压
  	//思路
  	//1. 将huffmanCodeBytes [-88, -65, -56, -65, -56, -65, -55, 77, -57, 6, -24, -14, -117, -4, -60, -90, 28]
  	//   重写先转成 赫夫曼编码对应的二进制的字符串 "1010100010111..."
  	//2.  赫夫曼编码对应的二进制的字符串 "1010100010111..." =》 对照 赫夫曼编码  =》 "i like like like java do you like a java"
  	
  	
  	//编写一个方法，完成对压缩数据的解码
  	/**
  	 * 
  	 * @param huffmanCodes 赫夫曼编码表 map
  	 * @param huffmanBytes 赫夫曼编码得到的字节数组
  	 * @return 就是原来的字符串对应的数组
  	 */
  	private static byte[] decode(Map<Byte,String> huffmanCodes, byte[] huffmanBytes) {
  		
  		//1. 先得到 huffmanBytes 对应的 二进制的字符串 ， 形式 1010100010111...
  		StringBuilder stringBuilder = new StringBuilder();
  		//将byte数组转成二进制的字符串
  		for(int i = 0; i < huffmanBytes.length; i++) {
  			byte b = huffmanBytes[i];
  			//判断是不是最后一个字节
  			boolean flag = (i == huffmanBytes.length - 1);
  			stringBuilder.append(byteToBitString(!flag, b));
  		}
  		//把字符串安装指定的赫夫曼编码进行解码
  		//把赫夫曼编码表进行调换，因为反向查询 a->100 100->a
  		Map<String, Byte>  map = new HashMap<String,Byte>();
  		for(Map.Entry<Byte, String> entry: huffmanCodes.entrySet()) {
  			map.put(entry.getValue(), entry.getKey());
  		}
  		
  		//创建要给集合，存放byte
  		List<Byte> list = new ArrayList<>();
  		//i 可以理解成就是索引,扫描 stringBuilder 
  		for(int  i = 0; i < stringBuilder.length(); ) {
  			int count = 1; // 小的计数器
  			boolean flag = true;
  			Byte b = null;
  			
  			while(flag) {
  				//1010100010111...
  				//递增的取出 key 1 
  				String key = stringBuilder.substring(i, i+count);//i 不动，让count移动，指定匹配到一个字符
  				b = map.get(key);
  				if(b == null) {//说明没有匹配到
  					count++;
  				}else {
  					//匹配到
  					flag = false;
  				}
  			}
  			list.add(b);
  			i += count;//i 直接移动到 count	
  		}
  		//当for循环结束后，我们list中就存放了所有的字符  "i like like like java do you like a java"
  		//把list 中的数据放入到byte[] 并返回
  		byte b[] = new byte[list.size()];
  		for(int i = 0;i < b.length; i++) {
  			b[i] = list.get(i);
  		}
  		return b;
  	}
   	
  	/**
  	 * 将一个byte 转成一个二进制的字符串, 如果看不懂，可以参考我讲的Java基础 二进制的原码，反码，补码
  	 * @param b 传入的 byte
  	 * @param flag 标志是否需要补高位如果是true ，表示需要补高位，如果是false表示不补, 如果是最后一个字节，无需补高位
  	 * @return 是该b 对应的二进制的字符串，（注意是按补码返回）
  	 */
  	private static String byteToBitString(boolean flag, byte b) {
  		//使用变量保存 b
  		int temp = b; //将 b 转成 int
  		//如果是正数我们还存在补高位
  		if(flag) {
  			temp |= 256; //按位与 256  1 0000 0000  | 0000 0001 => 1 0000 0001
  		}
  		String str = Integer.toBinaryString(temp); //返回的是temp对应的二进制的补码
  		if(flag) {
  			return str.substring(str.length() - 8);
  		} else {
  			return str;
  		}
  	}
  	
  	//使用一个方法，将前面的方法封装起来，便于我们的调用.
  	/**
  	 * 
  	 * @param bytes 原始的字符串对应的字节数组
  	 * @return 是经过 赫夫曼编码处理后的字节数组(压缩后的数组)
  	 */
  	private static byte[] huffmanZip(byte[] bytes) {
  		List<Node> nodes = getNodes(bytes);
  		//根据 nodes 创建的赫夫曼树
  		Node huffmanTreeRoot = createHuffmanTree(nodes);
  		//对应的赫夫曼编码(根据 赫夫曼树)
  		Map<Byte, String> huffmanCodes = getCodes(huffmanTreeRoot);
  		//根据生成的赫夫曼编码，压缩得到压缩后的赫夫曼编码字节数组
  		byte[] huffmanCodeBytes = zip(bytes, huffmanCodes);
  		return huffmanCodeBytes;
  	}
  	
  	
  	//编写一个方法，将字符串对应的byte[] 数组，通过生成的赫夫曼编码表，返回一个赫夫曼编码 压缩后的byte[]
  	/**
  	 * 
  	 * @param bytes 这时原始的字符串对应的 byte[]
  	 * @param huffmanCodes 生成的赫夫曼编码map
  	 * @return 返回赫夫曼编码处理后的 byte[] 
  	 * 举例： String content = "i like like like java do you like a java"; =》 byte[] contentBytes = content.getBytes();
  	 * 返回的是 字符串 "1010100010111111110010001011111111001000101111111100100101001101110001110000011011101000111100101000101111111100110001001010011011100"
  	 * => 对应的 byte[] huffmanCodeBytes  ，即 8位对应一个 byte,放入到 huffmanCodeBytes
  	 * huffmanCodeBytes[0] =  10101000(补码) => byte  [推导  10101000=> 10101000 - 1 => 10100111(反码)=> 11011000= -88 ]
  	 * huffmanCodeBytes[1] = -88
  	 */
  	private static byte[] zip(byte[] bytes, Map<Byte, String> huffmanCodes) {
  		
  		//1.利用 huffmanCodes 将  bytes 转成  赫夫曼编码对应的字符串
  		StringBuilder stringBuilder = new StringBuilder();
  		//遍历bytes 数组 
  		for(byte b: bytes) {
  			stringBuilder.append(huffmanCodes.get(b));
  		}
  		
  		//System.out.println("测试 stringBuilder~~~=" + stringBuilder.toString());
  		
  		//将 "1010100010111111110..." 转成 byte[]
  		
  		//统计返回  byte[] huffmanCodeBytes 长度
  		//一句话 int len = (stringBuilder.length() + 7) / 8;
  		int len;
  		if(stringBuilder.length() % 8 == 0) {
  			len = stringBuilder.length() / 8;
  		} else {
  			len = stringBuilder.length() / 8 + 1;
  		}
  		//创建 存储压缩后的 byte数组
  		byte[] huffmanCodeBytes = new byte[len];
  		int index = 0;//记录是第几个byte
  		for (int i = 0; i < stringBuilder.length(); i += 8) { //因为是每8位对应一个byte,所以步长 +8
  				String strByte;
  				if(i+8 > stringBuilder.length()) {//不够8位
  					strByte = stringBuilder.substring(i);//从第一位取到最后一位
  				}else{
  					strByte = stringBuilder.substring(i, i + 8);
  				}	
  				//将strByte 转成一个byte,放入到 huffmanCodeBytes
  				huffmanCodeBytes[index] = (byte)Integer.parseInt(strByte, 2);//从二进制转成10进制
  				index++;
  		}
  		return huffmanCodeBytes;
  	}
  	
  	//生成赫夫曼树对应的赫夫曼编码
  	//思路:
  	//1. 将赫夫曼编码表存放在 Map<Byte,String> 形式
  	//   生成的赫夫曼编码表{32=01, 97=100, 100=11000, 117=11001, 101=1110, 118=11011, 105=101, 121=11010, 106=0010, 107=1111, 108=000, 111=0011}
  	static Map<Byte, String> huffmanCodes = new HashMap<Byte,String>();
  	//2. 在生成赫夫曼编码表示，需要去拼接路径, 定义一个StringBuilder 存储某个叶子结点的路径
  	static StringBuilder stringBuilder = new StringBuilder();
  	
  	
  	//为了调用方便，我们重载 getCodes
  	private static Map<Byte, String> getCodes(Node root) {
  		if(root == null) {
  			return null;
  		}
  		//处理root的左子树
  		getCodes(root.left, "0", stringBuilder);
  		//处理root的右子树
  		getCodes(root.right, "1", stringBuilder);
  		return huffmanCodes;
  	}
  	
  	/**
  	 * 功能：将传入的node结点的所有叶子结点的赫夫曼编码得到，并放入到huffmanCodes集合
  	 * @param node  传入结点
  	 * @param code  路径： 左子结点是 0, 右子结点 1
  	 * @param stringBuilder 用于拼接路径
  	 */
  	private static void getCodes(Node node, String code, StringBuilder stringBuilder) {
  		StringBuilder stringBuilder2 = new StringBuilder(stringBuilder);
  		//将code 加入到 stringBuilder2
  		stringBuilder2.append(code);
  		if(node != null) { //如果node == null不处理
  			//判断当前node 是叶子结点还是非叶子结点
  			if(node.data == null) { //非叶子结点
  				//递归处理
  				//向左递归
  				getCodes(node.left, "0", stringBuilder2);
  				//向右递归
  				getCodes(node.right, "1", stringBuilder2);
  			} else { //说明是一个叶子结点
  				//就表示找到某个叶子结点的最后
  				huffmanCodes.put(node.data, stringBuilder2.toString());
  			}
  		}
  	}
  	
  	//前序遍历的方法
  	private static void preOrder(Node root) {
  		if(root != null) {
  			root.preOrder();
  		}else {
  			System.out.println("赫夫曼树为空");
  		}
  	}
  	
  	/**
  	 * 
  	 * @param bytes 接收字节数组
  	 * @return 返回的就是 List 形式   [Node[date=97 ,weight = 5], Node[]date=32,weight = 9]......],
  	 */
  	private static List<Node> getNodes(byte[] bytes) {
  		
  		//1创建一个ArrayList
  		ArrayList<Node> nodes = new ArrayList<Node>();
  		
  		//遍历 bytes , 统计 每一个byte出现的次数->map[key,value]
  		Map<Byte, Integer> counts = new HashMap<>();
  		for (byte b : bytes) {
  			Integer count = counts.get(b);
  			if (count == null) { // Map还没有这个字符数据,第一次
  				counts.put(b, 1);
  			} else {
  				counts.put(b, count + 1);
  			}
  		}
  		
  		//把每一个键值对转成一个Node 对象，并加入到nodes集合
  		//遍历map
  		for(Map.Entry<Byte, Integer> entry: counts.entrySet()) {
  			nodes.add(new Node(entry.getKey(), entry.getValue()));
  		}
  		return nodes;
  		
  	}
  	
  	//可以通过List 创建对应的赫夫曼树
  	private static Node createHuffmanTree(List<Node> nodes) {
  		
  		while(nodes.size() > 1) {
  			//排序, 从小到大
  			Collections.sort(nodes);
  			//取出第一颗最小的二叉树
  			Node leftNode = nodes.get(0);
  			//取出第二颗最小的二叉树
  			Node rightNode = nodes.get(1);
  			//创建一颗新的二叉树,它的根节点 没有data, 只有权值
  			Node parent = new Node(null, leftNode.weight + rightNode.weight);
  			parent.left = leftNode;
  			parent.right = rightNode;
  			
  			//将已经处理的两颗二叉树从nodes删除
  			nodes.remove(leftNode);
  			nodes.remove(rightNode);
  			//将新的二叉树，加入到nodes
  			nodes.add(parent);
  			
  		}
  		//nodes 最后的结点，就是赫夫曼树的根结点
  		return nodes.get(0);	
  	}
  }
  
  //创建Node ,待数据和权值
  class Node implements Comparable<Node>  {
  	Byte data; // 存放数据(字符)本身，比如'a' => 97 ' ' => 32
  	int weight; //权值, 表示字符出现的次数
  	Node left;//
  	Node right;
  	public Node(Byte data, int weight) {
  		
  		this.data = data;
  		this.weight = weight;
  	}
  	@Override
  	public int compareTo(Node o) {
  		// 从小到大排序
  		return this.weight - o.weight;
  	}
  	
  	public String toString() {
  		return "Node [data = " + data + " weight=" + weight + "]";
  	}
  	
  	//前序遍历
  	public void preOrder() {
  		System.out.println(this);
  		if(this.left != null) {
  			this.left.preOrder();
  		}
  		if(this.right != null) {
  			this.right.preOrder();
  		}
  	}
  }
  

9.3 二叉排序树（BST）

• 基本介绍

  二叉排序树: BST:(Binary Sort(Search) Tree),对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。
  特别说明: 如果有相同的值，可以将该节点放在左子节点或右子节点

• 思路分析

  • 二叉排序树的创建和遍历

  • 二叉排序树的删除

    

• 代码实现

9.4 平衡二叉树

• 基本介绍

  1. 平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为 AVL 树，可以保证查询效率较高
  2. 具有以下特点：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过 1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等

• 思路分析

  • 左旋转
  • 右旋转
  • 双旋转

• 代码实现

  public class AVLTreeDemo {
  
  	public static void main(String[] args) {
  		//int[] arr = {4,3,6,5,7,8};
  		//int[] arr = { 10, 12, 8, 9, 7, 6 };
  		int[] arr = { 10, 11, 7, 6, 8, 9 };  
  		//创建一个 AVLTree对象
  		AVLTree avlTree = new AVLTree();
  		//添加结点
  		for(int i=0; i < arr.length; i++) {
  			avlTree.add(new Node(arr[i]));
  		}
  		
  		//遍历
  		System.out.println("中序遍历");
  		avlTree.infixOrder();
  		
  		System.out.println("在平衡处理~~");
  		System.out.println("树的高度=" + avlTree.getRoot().height()); //3
  		System.out.println("树的左子树高度=" + avlTree.getRoot().leftHeight()); // 2
  		System.out.println("树的右子树高度=" + avlTree.getRoot().rightHeight()); // 2
  		System.out.println("当前的根结点=" + avlTree.getRoot());//8
  			
  	}
  }
  
  // 创建AVLTree
  class AVLTree {
  	private Node root;
  
  	public Node getRoot() {
  		return root;
  	}
  
  	// 查找要删除的结点
  	public Node search(int value) {
  		if (root == null) {
  			return null;
  		} else {
  			return root.search(value);
  		}
  	}
  
  	// 查找父结点
  	public Node searchParent(int value) {
  		if (root == null) {
  			return null;
  		} else {
  			return root.searchParent(value);
  		}
  	}
  
  	// 编写方法:
  	// 1. 返回的 以node 为根结点的二叉排序树的最小结点的值
  	// 2. 删除node 为根结点的二叉排序树的最小结点
  	/**
  	 * 
  	 * @param node
  	 *            传入的结点(当做二叉排序树的根结点)
  	 * @return 返回的 以node 为根结点的二叉排序树的最小结点的值
  	 */
  	public int delRightTreeMin(Node node) {
  		Node target = node;
  		// 循环的查找左子节点，就会找到最小值
  		while (target.left != null) {
  			target = target.left;
  		}
  		// 这时 target就指向了最小结点
  		// 删除最小结点
  		delNode(target.value);
  		return target.value;
  	}
  
  	// 删除结点
  	public void delNode(int value) {
  		if (root == null) {
  			return;
  		} else {
  			// 1.需求先去找到要删除的结点 targetNode
  			Node targetNode = search(value);
  			// 如果没有找到要删除的结点
  			if (targetNode == null) {
  				return;
  			}
  			// 如果我们发现当前这颗二叉排序树只有一个结点
  			if (root.left == null && root.right == null) {
  				root = null;
  				return;
  			}
  
  			// 去找到targetNode的父结点
  			Node parent = searchParent(value);
  			// 如果要删除的结点是叶子结点
  			if (targetNode.left == null && targetNode.right == null) {
  				// 判断targetNode 是父结点的左子结点，还是右子结点
  				if (parent.left != null && parent.left.value == value) { // 是左子结点
  					parent.left = null;
  				} else if (parent.right != null && parent.right.value == value) {// 是由子结点
  					parent.right = null;
  				}
  			} else if (targetNode.left != null && targetNode.right != null) { // 删除有两颗子树的节点
  				int minVal = delRightTreeMin(targetNode.right);
  				targetNode.value = minVal;
  
  			} else { // 删除只有一颗子树的结点
  				// 如果要删除的结点有左子结点
  				if (targetNode.left != null) {
  					if (parent != null) {
  						// 如果 targetNode 是 parent 的左子结点
  						if (parent.left.value == value) {
  							parent.left = targetNode.left;
  						} else { // targetNode 是 parent 的右子结点
  							parent.right = targetNode.left;
  						}
  					} else {
  						root = targetNode.left;
  					}
  				} else { // 如果要删除的结点有右子结点
  					if (parent != null) {
  						// 如果 targetNode 是 parent 的左子结点
  						if (parent.left.value == value) {
  							parent.left = targetNode.right;
  						} else { // 如果 targetNode 是 parent 的右子结点
  							parent.right = targetNode.right;
  						}
  					} else {
  						root = targetNode.right;
  					}
  				}
  			}
  		}
  	}
  
  	// 添加结点的方法
  	public void add(Node node) {
  		if (root == null) {
  			root = node;// 如果root为空则直接让root指向node
  		} else {
  			root.add(node);
  		}
  	}
  
  	// 中序遍历
  	public void infixOrder() {
  		if (root != null) {
  			root.infixOrder();
  		} else {
  			System.out.println("二叉排序树为空，不能遍历");
  		}
  	}
  }
  
  // 创建Node结点
  class Node {
  	int value;
  	Node left;
  	Node right;
  
  	public Node(int value) {
  
  		this.value = value;
  	}
  
  	// 返回左子树的高度
  	public int leftHeight() {
  		if (left == null) {
  			return 0;
  		}
  		return left.height();
  	}
  
  	// 返回右子树的高度
  	public int rightHeight() {
  		if (right == null) {
  			return 0;
  		}
  		return right.height();
  	}
  
  	// 返回 以该结点为根结点的树的高度
  	public int height() {
  		return Math.max(left == null ? 0 : left.height(), right == null ? 0 : right.height()) + 1;
  	}
  	
  	//左旋转方法
  	private void leftRotate() {
  		
  		//创建新的结点，以当前根结点的值
  		Node newNode = new Node(value);
  		//把新的结点的左子树设置成当前结点的左子树
  		newNode.left = left;
  		//把新的结点的右子树设置成带你过去结点的右子树的左子树
  		newNode.right = right.left;
  		//把当前结点的值替换成右子结点的值
  		value = right.value;
  		//把当前结点的右子树设置成当前结点右子树的右子树
  		right = right.right;
  		//把当前结点的左子树(左子结点)设置成新的结点
  		left = newNode;
  		
  		
  	}
  	
  	//右旋转
  	private void rightRotate() {
  		Node newNode = new Node(value);
  		newNode.right = right;
  		newNode.left = left.right;
  		value = left.value;
  		left = left.left;
  		right = newNode;
  	}
  
  	// 查找要删除的结点
  	/**
  	 * 
  	 * @param value
  	 *            希望删除的结点的值
  	 * @return 如果找到返回该结点，否则返回null
  	 */
  	public Node search(int value) {
  		if (value == this.value) { // 找到就是该结点
  			return this;
  		} else if (value < this.value) {// 如果查找的值小于当前结点，向左子树递归查找
  			// 如果左子结点为空
  			if (this.left == null) {
  				return null;
  			}
  			return this.left.search(value);
  		} else { // 如果查找的值不小于当前结点，向右子树递归查找
  			if (this.right == null) {
  				return null;
  			}
  			return this.right.search(value);
  		}
  	}
  
  	// 查找要删除结点的父结点
  	/**
  	 * 
  	 * @param value
  	 *            要找到的结点的值
  	 * @return 返回的是要删除的结点的父结点，如果没有就返回null
  	 */
  	public Node searchParent(int value) {
  		// 如果当前结点就是要删除的结点的父结点，就返回
  		if ((this.left != null && this.left.value == value) || (this.right != null && this.right.value == value)) {
  			return this;
  		} else {
  			// 如果查找的值小于当前结点的值, 并且当前结点的左子结点不为空
  			if (value < this.value && this.left != null) {
  				return this.left.searchParent(value); // 向左子树递归查找
  			} else if (value >= this.value && this.right != null) {
  				return this.right.searchParent(value); // 向右子树递归查找
  			} else {
  				return null; // 没有找到父结点
  			}
  		}
  	}
  
  	@Override
  	public String toString() {
  		return "Node [value=" + value + "]";
  	}
  
  	// 添加结点的方法
  	// 递归的形式添加结点，注意需要满足二叉排序树的要求
  	public void add(Node node) {
  		if (node == null) {
  			return;
  		}
  
  		// 判断传入的结点的值，和当前子树的根结点的值关系
  		if (node.value < this.value) {
  			// 如果当前结点左子结点为null
  			if (this.left == null) {
  				this.left = node;
  			} else {
  				// 递归的向左子树添加
  				this.left.add(node);
  			}
  		} else { // 添加的结点的值大于 当前结点的值
  			if (this.right == null) {
  				this.right = node;
  			} else {
  				// 递归的向右子树添加
  				this.right.add(node);
  			}
  		}
  		
  		//当添加完一个结点后，如果: (右子树的高度-左子树的高度) > 1 , 左旋转
  		if(rightHeight() - leftHeight() > 1) {
  			//如果它的右子树的左子树的高度大于它的右子树的右子树的高度
  			if(right != null && right.leftHeight() > right.rightHeight()) {
  				//先对右子结点进行右旋转
  				right.rightRotate();
  				//然后在对当前结点进行左旋转
  				leftRotate(); //左旋转..
  			} else {
  				//直接进行左旋转即可
  				leftRotate();
  			}
  			return ; //必须要!!!
  		}
  		
  		//当添加完一个结点后，如果 (左子树的高度 - 右子树的高度) > 1, 右旋转
  		if(leftHeight() - rightHeight() > 1) {
  			//如果它的左子树的右子树高度大于它的左子树的高度
  			if(left != null && left.rightHeight() > left.leftHeight()) {
  				//先对当前结点的左结点(左子树)->左旋转
  				left.leftRotate();
  				//再对当前结点进行右旋转
  				rightRotate();
  			} else {
  				//直接进行右旋转即可
  				rightRotate();
  			}
  		}
  	}
  
  	// 中序遍历
  	public void infixOrder() {
  		if (this.left != null) {
  			this.left.infixOrder();
  		}
  		System.out.println(this);
  		if (this.right != null) {
  			this.right.infixOrder();
  		}
  	}
  }
  

9.4 多路查找树

• B树
  1. B 树通过重新组织节点， 降低了树的高度
  2. 文件系统及数据库系统的设计者利用了磁盘预读原理，将一个节点的大小设为等于一个页(页得大小通常为4k)，这样每个节点只需要一次 I/O 就可以完全载入
  3. 将树的度 M 设置为 1024，在 600 亿个元素中最多只需要 4 次 I/O 操作就可以读取到想要的元素, B树(B+)广泛应用于文件存储系统以及数据库系统中
• 2-3树
  1. 2-3 树的所有叶子节点都在同一层.(只要是 B 树都满足这个条件)
  2. 有两个子节点的节点叫二节点，二节点要么没有子节点，要么有两个子节点
  3. 有三个子节点的节点叫三节点，三节点要么没有子节点，要么有三个子节点
  4. 2-3 树是由二节点和三节点构成的树
• B树

  1. B 树的阶：节点的最多子节点个数

  2. B-树的搜索，从根结点开始，对结点内的关键字（有序）序列进行二分查找，如果命中则结束，否则进入查询关键字所属范围的儿子结点；重复，直到所对应的儿子指针为空，或已经是叶子结点

  3. 关键字集合分布在整颗树中, 即叶子节点和非叶子节点都存放数据

  4. 搜索有可能在非叶子结点结束

  5. 其搜索性能等价于在关键字全集内做一次二分查找

• B+树

  1. B+树的搜索与 B 树也基本相同，区别是 B+树只有达到叶子结点才命中（B 树可以在非叶子结点命中），其性能也等价于在关键字全集做一次二分查找

  2. 所有关键字都出现在叶子结点的链表中（即数据只能在叶子节点【也叫稠密索引】），且链表中的关键字(数据)恰好是有序的

  3. 不可能在非叶子结点命中

  4. 非叶子结点相当于是叶子结点的索引（稀疏索引），叶子结点相当于是存储（关键字）数据的数据层

• B*树
  1. B*树定义了非叶子结点关键字个数至少为(2/3)*M，即块的最低使用率为 2/3，而B+树的块的最低使用率为的1/2
  2. 从第 1 个特点我们可以看出，B*树分配新结点的概率比 B+

10 图

• 图的常用概念

  1. 顶点（vertex）
  2. 边（edge）
  3. 路径
  4. 无向图
  5. 有向图
  6. 带权图

• 邻接矩阵

• 邻接表

• 代码实现

  public class Graph {
  
      private ArrayList<String> vertexList; //存储顶点集合
      private int[][] edges; //存储图对应的邻结矩阵
      private int numOfEdges; //表示边的数目
      //定义给数组boolean[], 记录某个结点是否被访问
      private boolean[] isVisited;
  
      public static void main(String[] args) {
          //测试一把图是否创建ok
          int n = 8;  //结点的个数
          //String Vertexs[] = {"A", "B", "C", "D", "E"};
          String Vertexs[] = {"1", "2", "3", "4", "5", "6", "7", "8"};
  
          //创建图对象
          Graph graph = new Graph(n);
          //循环的添加顶点
          for (String vertex : Vertexs) {
              graph.insertVertex(vertex);
          }
  
          //添加边
          //A-B A-C B-C B-D B-E 
  //    graph.insertEdge(0, 1, 1); // A-B
  //    graph.insertEdge(0, 2, 1); // 
  //    graph.insertEdge(1, 2, 1); // 
  //    graph.insertEdge(1, 3, 1); // 
  //    graph.insertEdge(1, 4, 1); // 
  
          //更新边的关系
          graph.insertEdge(0, 1, 1);
          graph.insertEdge(0, 2, 1);
          graph.insertEdge(1, 3, 1);
          graph.insertEdge(1, 4, 1);
          graph.insertEdge(3, 7, 1);
          graph.insertEdge(4, 7, 1);
          graph.insertEdge(2, 5, 1);
          graph.insertEdge(2, 6, 1);
          graph.insertEdge(5, 6, 1);
  
  
          //显示一把邻结矩阵
          graph.showGraph();
  
          //测试一把，我们的dfs遍历是否ok
          System.out.println("深度遍历");
          graph.dfs(); // A->B->C->D->E [1->2->4->8->5->3->6->7]
  //    System.out.println();
          System.out.println("广度优先!");
          graph.bfs(); // A->B->C->D-E [1->2->3->4->5->6->7->8]
  
      }
  
      //构造器
      public Graph(int n) {
          //初始化矩阵和vertexList
          edges = new int[n][n];
          vertexList = new ArrayList<String>(n);
          numOfEdges = 0;
  
      }
  
      //得到第一个邻接结点的下标 w 
  
      /**
       * @param index
       * @return 如果存在就返回对应的下标，否则返回-1
       */
      public int getFirstNeighbor(int index) {
          for (int j = 0; j < vertexList.size(); j++) {
              if (edges[index][j] > 0) {
                  return j;
              }
          }
          return -1;
      }
  
      //根据前一个邻接结点的下标来获取下一个邻接结点
      public int getNextNeighbor(int v1, int v2) {
          for (int j = v2 + 1; j < vertexList.size(); j++) {
              if (edges[v1][j] > 0) {
                  return j;
              }
          }
          return -1;
      }
  
      //深度优先遍历算法
      //i 第一次就是 0
      private void dfs(boolean[] isVisited, int i) {
          //首先我们访问该结点,输出
          System.out.print(getValueByIndex(i) + "->");
          //将结点设置为已经访问
          isVisited[i] = true;
          //查找结点i的第一个邻接结点w
          int w = getFirstNeighbor(i);
          while (w != -1) {//说明有
              if (!isVisited[w]) {
                  dfs(isVisited, w);
              }
              //如果w结点已经被访问过
              w = getNextNeighbor(i, w);
          }
  
      }
  
      //对dfs 进行一个重载, 遍历我们所有的结点，并进行 dfs
      public void dfs() {
          isVisited = new boolean[vertexList.size()];
          //遍历所有的结点，进行dfs[回溯]
          for (int i = 0; i < getNumOfVertex(); i++) {
              if (!isVisited[i]) {
                  dfs(isVisited, i);
              }
          }
      }
  
      //对一个结点进行广度优先遍历的方法
      private void bfs(boolean[] isVisited, int i) {
          int u; // 表示队列的头结点对应下标
          int w; // 邻接结点w
          //队列，记录结点访问的顺序
          LinkedList queue = new LinkedList();
          //访问结点，输出结点信息
          System.out.print(getValueByIndex(i) + "=>");
          //标记为已访问
          isVisited[i] = true;
          //将结点加入队列
          queue.addLast(i);
  
          while (!queue.isEmpty()) {
              //取出队列的头结点下标
              u = (Integer) queue.removeFirst();
              //得到第一个邻接结点的下标 w 
              w = getFirstNeighbor(u);
              while (w != -1) {//找到
                  //是否访问过
                  if (!isVisited[w]) {
                      System.out.print(getValueByIndex(w) + "=>");
                      //标记已经访问
                      isVisited[w] = true;
                      //入队
                      queue.addLast(w);
                  }
                  //以u为前驱点，找w后面的下一个邻结点
                  w = getNextNeighbor(u, w); //体现出我们的广度优先
              }
          }
  
      }
  
      //遍历所有的结点，都进行广度优先搜索
      public void bfs() {
          isVisited = new boolean[vertexList.size()];
          for (int i = 0; i < getNumOfVertex(); i++) {
              if (!isVisited[i]) {
                  bfs(isVisited, i);
              }
          }
      }
  
      //图中常用的方法
      //返回结点的个数
      public int getNumOfVertex() {
          return vertexList.size();
      }
  
      //显示图对应的矩阵
      public void showGraph() {
          for (int[] link : edges) {
              System.err.println(Arrays.toString(link));
          }
      }
  
      //得到边的数目
      public int getNumOfEdges() {
          return numOfEdges;
      }
  
      //返回结点i(下标)对应的数据 0->"A" 1->"B" 2->"C"
      public String getValueByIndex(int i) {
          return vertexList.get(i);
      }
  
      //返回v1和v2的权值
      public int getWeight(int v1, int v2) {
          return edges[v1][v2];
      }
  
      //插入结点
      public void insertVertex(String vertex) {
          vertexList.add(vertex);
      }
      //添加边
  
      /**
       * @param v1     表示点的下标即使第几个顶点  "A"-"B" "A"->0 "B"->1
       * @param v2     第二个顶点对应的下标
       * @param weight 表示
       */
      public void insertEdge(int v1, int v2, int weight) {
          edges[v1][v2] = weight;
          edges[v2][v1] = weight;
          numOfEdges++;
      }
  }
  

10.1 深度优先

• 基本思想

  图的深度优先搜索(Depth First Search)

  1. 深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解:每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。
  2. 我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。
  3. 显然，深度优先搜索是一个递归的过程

• 步骤

  1. 访问初始结点 v，并标记结点 v 为已访问
  2. 查找结点 v 的第一个邻接结点 w
  3. 若 w 存在，则继续执行 4，如果 w 不存在，则回到第1步，将从 v 的下一个结点继续
  4. 若 w 未被访问，对 w 进行深度优先遍历递归 (即把 w 当做另一个 v ，然后进行步骤123)
  5. 查找结点 v 的 w 邻接结点的下一个邻接结点，转到步骤 3

• 代码实现

  //深度优先遍历算法
      //i 第一次就是 0
      private void dfs(boolean[] isVisited, int i) {
          //首先我们访问该结点,输出
          System.out.print(getValueByIndex(i) + "->");
          //将结点设置为已经访问
          isVisited[i] = true;
          //查找结点i的第一个邻接结点w
          int w = getFirstNeighbor(i);
          while (w != -1) {//说明有
              if (!isVisited[w]) {
                  dfs(isVisited, w);
              }
              //如果w结点已经被访问过
              w = getNextNeighbor(i, w);
          }
  
      }
  
      //对dfs 进行一个重载, 遍历我们所有的结点，并进行 dfs
      public void dfs() {
          isVisited = new boolean[vertexList.size()];
          //遍历所有的结点，进行dfs[回溯]
          for (int i = 0; i < getNumOfVertex(); i++) {
              if (!isVisited[i]) {
                  dfs(isVisited, i);
              }
          }
      }
  

10.2 广度优先

• 基本介绍

  类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来
  访问这些结点的邻接结点

• 算法实现步骤

  1. 访问初始结点 v 并标记结点 v 为已访问
  2. 结点 v 入队列
  3. 当队列非空时，继续执行，否则算法结束。
  4. 出队列，取得队头结点 u
  5. 查找结点 u 的第一个邻接结点 w
  6. 若结点 u 的邻接结点 w 不存在，则转到步骤3;否则循环执行以下三个步骤：
     1. 若结点 w 尚未被访问，则访问结点 w 并标记为已访问
     2. 结点 w 入队列
     3. 查找结点 u 的继 w 邻接结点后的下一个邻接结点 w，转到步骤6

• 代码实现

  //对一个结点进行广度优先遍历的方法
      private void bfs(boolean[] isVisited, int i) {
          int u; // 表示队列的头结点对应下标
          int w; // 邻接结点w
          //队列，记录结点访问的顺序
          LinkedList queue = new LinkedList();
          //访问结点，输出结点信息
          System.out.print(getValueByIndex(i) + "=>");
          //标记为已访问
          isVisited[i] = true;
          //将结点加入队列
          queue.addLast(i);
  
          while (!queue.isEmpty()) {
              //取出队列的头结点下标
              u = (Integer) queue.removeFirst();
              //得到第一个邻接结点的下标 w
              w = getFirstNeighbor(u);
              while (w != -1) {//找到
                  //是否访问过
                  if (!isVisited[w]) {
                      System.out.print(getValueByIndex(w) + "=>");
                      //标记已经访问
                      isVisited[w] = true;
                      //入队
                      queue.addLast(w);
                  }
                  //以u为前驱点，找w后面的下一个邻结点
                  w = getNextNeighbor(u, w); //体现出我们的广度优先
              }
          }
  
      }
  
      //遍历所有的结点，都进行广度优先搜索
      public void bfs() {
          isVisited = new boolean[vertexList.size()];
          for (int i = 0; i < getNumOfVertex(); i++) {
              if (!isVisited[i]) {
                  bfs(isVisited, i);
              }
          }
      }
  

11 常用算法

11.1 二分查找（非递归）

• 代码实现

  public class BinarySearchNoRecur {
  
      public static void main(String[] args) {
          //测试
          int[] arr = {1, 3, 8, 10, 11, 67, 100};
          int index = binarySearch(arr, 100);
          System.out.println("index=" + index);//
      }
  
      //二分查找的非递归实现
  
      /**
       * @param arr    待查找的数组, arr是升序排序
       * @param target 需要查找的数
       * @return 返回对应下标，-1表示没有找到
       */
      public static int binarySearch(int[] arr, int target) {
  
          int left = 0;
          int right = arr.length - 1;
          while (left <= right) { //说明继续查找
              int mid = (left + right) / 2;
              if (arr[mid] == target) {
                  return mid;
              } else if (arr[mid] > target) {
                  right = mid - 1;//需要向左边查找
              } else {
                  left = mid + 1; //需要向右边查找
              }
          }
          return -1;
      }
  }
  

11.2 分治算法

• 基本介绍

  分治法在每一层递归上都有三个步骤：

  1. 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题
  2. 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题
  3. 合并：将各个子问题的解合并为原问题的解

• 汉诺塔思路

  1. 如果是有一个盘， A->C
     如果我们有 n >= 2 情况，我们总是可以看做是两个盘 1.最下边的盘 2. 上面的盘
  2. 先把 最上面的盘 A->B
  3. 把最下边的盘 A->C
  4. 把 B塔的所有盘 从 B->C

• 代码实现

  public class Hanoitower {
  
      public static void main(String[] args) {
          hanoiTower(10, 'A', 'B', 'C');
      }
  
      //汉诺塔的移动的方法
      //使用分治算法
  
      public static void hanoiTower(int num, char a, char b, char c) {
          //如果只有一个盘
          if (num == 1) {
              System.out.println("第1个盘从 " + a + "->" + c);
          } else {
              //如果我们有 n >= 2 情况，我们总是可以看做是两个盘 1.最下边的一个盘 2. 上面的所有盘
              //1. 先把 最上面的所有盘 A->B， 移动过程会使用到 c
              hanoiTower(num - 1, a, c, b);
              //2. 把最下边的盘 A->C
              System.out.println("第" + num + "个盘从 " + a + "->" + c);
              //3. 把B塔的所有盘 从 B->C , 移动过程使用到 a塔
              hanoiTower(num - 1, b, a, c);
  
          }
      }
  }
  

11.3 动态规划

• 基本介绍

  1. 动态规划(Dynamic Programming)算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法
  2. 动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解
  3. 与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。 ( 即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解 )
  4. 动态规划可以通过填表的方式来逐步推进，得到最优解

• 思路

  1. 背包问题主要是指一个给定容量的背包、若干具有一定价值和重量的物品，如何选择物品放入背包使物品的价值最大。其中又分 01 背包和完全背包(完全背包指的是：每种物品都有无限件可用)

  2. 这里的问题属于 01 背包，即每个物品最多放一个。而无限背包可以转化为 01 背包

  3. 算法的主要思想，利用动态规划来解决。每次遍历到的第 i 个物品，根据 w[i]和 v[i]来确定是否需要将该物品
     放入背包中。即对于给定的 n 个物品，设 v[i]、w[i]分别为第 i 个物品的价值和重量，C 为背包的容量。再令 v[i][j]
     表示在前 i 个物品中能够装入容量为 j 的背包中的最大价值[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UObTwaEo-1682753464169)(C:\Users\vito\Desktop\java学习资料\数据结构和算法\动态规划背包问题02.jpg)]

• 代码实现

  public class KnapsackProblem {
  
     public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] w = {1, 4, 3};//物品的重量
        int[] val = {1500, 3000, 2000}; //物品的价值 这里val[i] 就是前面讲的v[i]
        int m = 4; //背包的容量
        int n = val.length; //物品的个数
  
  
        //创建二维数组，
        //v[i][j] 表示在前i个物品中能够装入容量为j的背包中的最大价值
        int[][] v = new int[n + 1][m + 1];
        //为了记录放入商品的情况，我们定一个二维数组
        int[][] path = new int[n + 1][m + 1];
  
        //初始化第一行和第一列, 这里在本程序中，可以不去处理，因为默认就是0
        for (int i = 0; i < v.length; i++) {
           v[i][0] = 0; //将第一列设置为0
        }
        for (int i = 0; i < v[0].length; i++) {
           v[0][i] = 0; //将第一行设置0
        }
  
  
        //根据前面得到公式来动态规划处理
        for (int i = 1; i < v.length; i++) { //不处理第一行 i是从1开始的
           for (int j = 1; j < v[0].length; j++) {//不处理第一列, j是从1开始的
              //公式
              if (w[i - 1] > j) { // 因为我们程序i 是从1开始的，因此原来公式中的 w[i] 修改成 w[i-1]
                 v[i][j] = v[i - 1][j];
              } else {
                 //说明:
                 //因为我们的i 从1开始的， 因此公式需要调整成
                 //v[i][j]=Math.max(v[i-1][j], val[i-1]+v[i-1][j-w[i-1]]);
                 //v[i][j] = Math.max(v[i - 1][j], val[i - 1] + v[i - 1][j - w[i - 1]]);
                 //为了记录商品存放到背包的情况，我们不能直接的使用上面的公式，需要使用if-else来体现公式
                 if (v[i - 1][j] < val[i - 1] + v[i - 1][j - w[i - 1]]) {
                    v[i][j] = val[i - 1] + v[i - 1][j - w[i - 1]];
                    //把当前的情况记录到path
                    path[i][j] = 1;
                 } else {
                    v[i][j] = v[i - 1][j];
                 }
  
              }
           }
        }
  
        //输出一下v 看看目前的情况
        for (int i = 0; i < v.length; i++) {
           for (int j = 0; j < v[i].length; j++) {
              System.out.print(v[i][j] + " ");
           }
           System.out.println();
        }
  
        System.out.println("============================");
        //输出最后我们是放入的哪些商品
        //遍历path, 这样输出会把所有的放入情况都得到, 其实我们只需要最后的放入
  //    for(int i = 0; i < path.length; i++) {
  //       for(int j=0; j < path[i].length; j++) {
  //          if(path[i][j] == 1) {
  //             System.out.printf("第%d个商品放入到背包\n", i);
  //          }
  //       }
  //    }
  
        //动脑筋
        int i = path.length - 1; //行的最大下标
        int j = path[0].length - 1;  //列的最大下标
        while (i > 0 && j > 0) { //从path的最后开始找
           if (path[i][j] == 1) {
              System.out.printf("第%d个商品放入到背包\n", i);
              j -= w[i - 1]; //w[i-1]
           }
           i--;
        }
     }
  }
  

11.4 KMP算法

• 基本介绍

  1. KMP 是一个解决模式串在文本串是否出现过，如果出现过，最早出现的位置的经典算法
  2. Knuth-Morris-Pratt 字符串查找算法，简称为 “KMP 算法”，常用于在一个文本串 S 内查找一个模式串 P 的
     出现位置，这个算法由Donald Knuth、Vaughan Pratt、James H. Morris 三人于 1977 年联合发表，故取这 3 人的
     姓氏命名此算法.
  3. KMP 方法算法就利用之前判断过信息，通过一个 next 数组，保存模式串中前后最长公共子序列的长度，每次
     回溯时，通过 next 数组找到，前面匹配过的位置，省去了大量的计算时间

• 思路分析

  帮你把KMP算法学个通透！（求next数组代码篇）_哔哩哔哩_bilibili

• 代码实现

  public class KMPAlgorithm {
  
     public static void main(String[] args) {
        // TODO Auto-generated method stub
        String str1 = "BBC ABCDAB ABCDABCDABDE";
        String str2 = "ABCDABD";
        //String str2 = "BBC";
        
        int[] next = kmpNext("ABCDABD"); //[0, 1, 2, 0]
        System.out.println("next=" + Arrays.toString(next));
        
        int index = kmpSearch(str1, str2, next);
        System.out.println("index=" + index); // 15了  
     }
     
     //写出我们的kmp搜索算法
     /**
      * 
      * @param str1 源字符串
      * @param str2 子串
      * @param next 部分匹配表, 是子串对应的部分匹配表
      * @return 如果是-1就是没有匹配到，否则返回第一个匹配的位置
      */
     public static int kmpSearch(String str1, String str2, int[] next) {
        
        //遍历 
        for(int i = 0, j = 0; i < str1.length(); i++) {
           
           //需要处理 str1.charAt(i) ！= str2.charAt(j), 去调整j的大小
           //KMP算法核心点, 可以验证...
           while( j > 0 && str1.charAt(i) != str2.charAt(j)) {
              j = next[j-1]; 
           }
           
           if(str1.charAt(i) == str2.charAt(j)) {
              j++;
           }        
           if(j == str2.length()) {//找到了 // j = 3 i 
              return i - j + 1;
           }
        }
        return  -1;
     }
  
     //获取到一个字符串(子串) 的部分匹配值表
     public static  int[] kmpNext(String dest) {
        //创建一个next 数组保存部分匹配值
        int[] next = new int[dest.length()];
        next[0] = 0; 
        for(int i = 1, j = 0; i < dest.length(); i++) {
           //当dest.charAt(i) != dest.charAt(j) ，我们需要从next[j-1]获取新的j
           //直到我们发现 有  dest.charAt(i) == dest.charAt(j)成立才退出
           //这时kmp算法的核心点
           while(j > 0 && dest.charAt(i) != dest.charAt(j)) {
              j = next[j-1];
           }
           
           //当dest.charAt(i) == dest.charAt(j) 满足时，部分匹配值就是+1
           if(dest.charAt(i) == dest.charAt(j)) {
              j++;
           }
           next[i] = j;
        }
        return next;
     }
  }
  

11.5 贪心算法

• 基本介绍

  1. 贪婪算法(贪心算法)是指在对问题进行求解时，在每一步选择中都采取最好或者最优(即最有利)的选择，从而希望能够导致结果是最好或者最优的算法
  2. 贪婪算法所得到的结果不一定是最优的结果(有时候会是最优解)，但是都是相对近似(接近)最优解的结果

• 思路[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tzVr8GfO-1682753464170)(C:\Users\vito\Desktop\java学习资料\数据结构和算法\贪心算法广播电台.jpg)]

  1. 遍历所有的广播电台, 找到一个覆盖了最多未覆盖的地区的电台(此电台可能包含一些已覆盖的地区，但没有关系）
  2. 将这个电台加入到一个集合中(比如ArrayList), 想办法把该电台覆盖的地区在下次比较时去掉。
  3. 重复第 1 步直到覆盖了全部的地区

• 代码实现

  public class GreedyAlgorithm {
  
     public static void main(String[] args) {
        //创建广播电台,放入到Map
        HashMap<String,HashSet<String>> broadcasts = new HashMap<String, HashSet<String>>();
        //将各个电台放入到broadcasts
        HashSet<String> hashSet1 = new HashSet<String>();
        hashSet1.add("北京");
        hashSet1.add("上海");
        hashSet1.add("天津");
        
        HashSet<String> hashSet2 = new HashSet<String>();
        hashSet2.add("广州");
        hashSet2.add("北京");
        hashSet2.add("深圳");
        
        HashSet<String> hashSet3 = new HashSet<String>();
        hashSet3.add("成都");
        hashSet3.add("上海");
        hashSet3.add("杭州");
        
        
        HashSet<String> hashSet4 = new HashSet<String>();
        hashSet4.add("上海");
        hashSet4.add("天津");
        
        HashSet<String> hashSet5 = new HashSet<String>();
        hashSet5.add("杭州");
        hashSet5.add("大连");
     
        //加入到map
        broadcasts.put("K1", hashSet1);
        broadcasts.put("K2", hashSet2);
        broadcasts.put("K3", hashSet3);
        broadcasts.put("K4", hashSet4);
        broadcasts.put("K5", hashSet5);
        
        //allAreas 存放所有的地区
        HashSet<String> allAreas = new HashSet<String>();
        allAreas.add("北京");
        allAreas.add("上海");
        allAreas.add("天津");
        allAreas.add("广州");
        allAreas.add("深圳");
        allAreas.add("成都");
        allAreas.add("杭州");
        allAreas.add("大连");
        
        //创建ArrayList, 存放选择的电台集合
        ArrayList<String> selects = new ArrayList<String>();
        
        //定义一个临时的集合， 在遍历的过程中，存放遍历过程中的电台覆盖的地区和当前还没有覆盖的地区的交集
        HashSet<String> tempSet = new HashSet<String>();
        
        //定义给maxKey ， 保存在一次遍历过程中，能够覆盖最大未覆盖的地区对应的电台的key
        //如果maxKey 不为null , 则会加入到 selects
        String maxKey = null;
        while(allAreas.size() != 0) { // 如果allAreas 不为0, 则表示还没有覆盖到所有的地区
           //每进行一次while,需要
           maxKey = null;
           
           //遍历 broadcasts, 取出对应key
           for(String key : broadcasts.keySet()) {
              //每进行一次for
              tempSet.clear();
              //当前这个key能够覆盖的地区
              HashSet<String> areas = broadcasts.get(key);
              tempSet.addAll(areas);
              //求出tempSet 和   allAreas 集合的交集, 交集会赋给 tempSet
              tempSet.retainAll(allAreas);
              //如果当前这个集合包含的未覆盖地区的数量，比maxKey指向的集合地区还多
              //就需要重置maxKey
              // tempSet.size() >broadcasts.get(maxKey).size()) 体现出贪心算法的特点,每次都选择最优的
              if(tempSet.size() > 0 && 
                    (maxKey == null || tempSet.size() >broadcasts.get(maxKey).size())){
                 maxKey = key;
              }
           }
           //maxKey != null, 就应该将maxKey 加入selects
           if(maxKey != null) {
              selects.add(maxKey);
              //将maxKey指向的广播电台覆盖的地区，从 allAreas 去掉
              allAreas.removeAll(broadcasts.get(maxKey));
           }
           
        }
        
        System.out.println("得到的选择结果是" + selects);//[K1,K2,K3,K5]    
     }
  }
  

11.6 普利姆算法

• 基本介绍

  普利姆(Prim)算法求最小生成树，也就是在包含 n 个顶点的连通图中，找出只有(n-1)条边包含所有 n 个顶点的连通子图，也就是所谓的极小连通子图

• 思路

  

  普利姆的算法如下:

  1. 设G=(V,E)是连通网，T=(U,D)是最小生成树，V,U是顶点集合，E,D是边的集合
  2. 若从顶点 u 开始构造最小生成树，则从集合V中取出顶点 u 放入集合U中，标记顶点 v 的 visited[u]=1
  3. 若集合U中顶点 ui 与集合V-U中的顶点 vj 之间存在边，则寻找这些边中权值最小的边，但不能构成回路，将
     顶点 vj 加入集合U中，将边（ui,vj）加入集合D中，标记 visited[vj]=1
  4. 重复步骤②，直到U与V相等，即所有顶点都被标记为访问过，此时D中有 n-1 条边

• 代码实现

  public class PrimAlgorithm {
  
     public static void main(String[] args) {
        //测试看看图是否创建ok
        char[] data = new char[]{'A','B','C','D','E','F','G'};
        int verxs = data.length;
        //邻接矩阵的关系使用二维数组表示,10000这个大数，表示两个点不联通
        int [][]weight=new int[][]{
              {10000,5,7,10000,10000,10000,2},
              {5,10000,10000,9,10000,10000,3},
              {7,10000,10000,10000,8,10000,10000},
              {10000,9,10000,10000,10000,4,10000},
              {10000,10000,8,10000,10000,5,4},
              {10000,10000,10000,4,5,10000,6},
              {2,3,10000,10000,4,6,10000},};
              
          //创建MGraph对象
          MGraph graph = new MGraph(verxs);
          //创建一个MinTree对象
          MinTree minTree = new MinTree();
          minTree.createGraph(graph, verxs, data, weight);
          //输出
          minTree.showGraph(graph);
          //测试普利姆算法
          minTree.prim(graph, 1);// 
     }
  
  }
  
  //创建最小生成树->村庄的图
  class MinTree {
     //创建图的邻接矩阵
     /**
      * 
      * @param graph 图对象
      * @param verxs 图对应的顶点个数
      * @param data 图的各个顶点的值
      * @param weight 图的邻接矩阵
      */
     public void createGraph(MGraph graph, int verxs, char data[], int[][] weight) {
        int i, j;
        for(i = 0; i < verxs; i++) {//顶点
           graph.data[i] = data[i];
           for(j = 0; j < verxs; j++) {
              graph.weight[i][j] = weight[i][j];
           }
        }
     }
     
     //显示图的邻接矩阵
     public void showGraph(MGraph graph) {
        for(int[] link: graph.weight) {
           System.out.println(Arrays.toString(link));
        }
     }
     
     //编写prim算法，得到最小生成树
     /**
      * 
      * @param graph 图
      * @param v 表示从图的第几个顶点开始生成'A'->0 'B'->1...
      */
     public void prim(MGraph graph, int v) {
        //visited[] 标记结点(顶点)是否被访问过
        int visited[] = new int[graph.verxs];
        //visited[] 默认元素的值都是0, 表示没有访问过
  //    for(int i =0; i <graph.verxs; i++) {
  //       visited[i] = 0;
  //    }
        
        //把当前这个结点标记为已访问
        visited[v] = 1;
        //h1 和 h2 记录两个顶点的下标
        int h1 = -1;
        int h2 = -1;
        int minWeight = 10000; //将 minWeight 初始成一个大数，后面在遍历过程中，会被替换
        for(int k = 1; k < graph.verxs; k++) {//因为有 graph.verxs顶点，普利姆算法结束后，有 graph.verxs-1边
           
           //这个是确定每一次生成的子图 ，和哪个结点的距离最近
           for(int i = 0; i < graph.verxs; i++) {// i结点表示被访问过的结点
              for(int j = 0; j< graph.verxs;j++) {//j结点表示还没有访问过的结点
                 if(visited[i] == 1 && visited[j] == 0 && graph.weight[i][j] < minWeight) {
                    //替换minWeight(寻找已经访问过的结点和未访问过的结点间的权值最小的边)
                    minWeight = graph.weight[i][j];
                    h1 = i;
                    h2 = j;
                 }
              }
           }
           //找到一条边是最小
           System.out.println("边<" + graph.data[h1] + "," + graph.data[h2] + "> 权值:" + minWeight);
           //将当前这个结点标记为已经访问
           visited[h2] = 1;
           //minWeight 重新设置为最大值 10000
           minWeight = 10000;
        }
        
     }
  }
  
  class MGraph {
     int verxs; //表示图的节点个数
     char[] data;//存放结点数据
     int[][] weight; //存放边，就是我们的邻接矩阵
     
     public MGraph(int verxs) {
        this.verxs = verxs;
        data = new char[verxs];
        weight = new int[verxs][verxs];
     }
  }
  

11.7 克鲁斯卡尔算法

• 基本介绍

  1. 克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。
  2. 基本思想：按照权值从小到大的顺序选择 n-1 条边，并保证这 n-1 条边不构成回路
  3. 具体做法：首先构造一个只含 n 个顶点的森林，然后依权值从小到大从连通网中选择边加入到森林中，并使森
     林中不产生回路，直至森林变成一棵树为止

• 思路分析

  

• 代码实现

  public class KruskalCase {
  
     private int edgeNum; //边的个数
     private char[] vertexs; //顶点数组
     private int[][] matrix; //邻接矩阵
     //使用 INF 表示两个顶点不能连通
     private static final int INF = Integer.MAX_VALUE;
     
     public static void main(String[] args) {
        char[] vertexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        //克鲁斯卡尔算法的邻接矩阵  
           int matrix[][] = {
           /*A*//*B*//*C*//*D*//*E*//*F*//*G*/
     /*A*/ {   0,  12, INF, INF, INF,  16,  14},
     /*B*/ {  12,   0,  10, INF, INF,   7, INF},
     /*C*/ { INF,  10,   0,   3,   5,   6, INF},
     /*D*/ { INF, INF,   3,   0,   4, INF, INF},
     /*E*/ { INF, INF,   5,   4,   0,   2,   8},
     /*F*/ {  16,   7,   6, INF,   2,   0,   9},
     /*G*/ {  14, INF, INF, INF,   8,   9,   0}}; 
           //大家可以在去测试其它的邻接矩阵，结果都可以得到最小生成树.
           
           //创建KruskalCase 对象实例
           KruskalCase kruskalCase = new KruskalCase(vertexs, matrix);
           //输出构建的
           kruskalCase.print();
           kruskalCase.kruskal();
           
     }
     
     //构造器
     public KruskalCase(char[] vertexs, int[][] matrix) {
        //初始化顶点数和边的个数
        int vlen = vertexs.length;
        
        //初始化顶点, 复制拷贝的方式
        this.vertexs = new char[vlen];
        for(int i = 0; i < vertexs.length; i++) {
           this.vertexs[i] = vertexs[i];
        }
        
        //初始化边, 使用的是复制拷贝的方式
        this.matrix = new int[vlen][vlen];
        for(int i = 0; i < vlen; i++) {
           for(int j= 0; j < vlen; j++) {
              this.matrix[i][j] = matrix[i][j];
           }
        }
        //统计边的条数
        for(int i =0; i < vlen; i++) {
           for(int j = i+1; j < vlen; j++) {
              if(this.matrix[i][j] != INF) {
                 edgeNum++;
              }
           }
        }
        
     }
     public void kruskal() {
        int index = 0; //表示最后结果数组的索引
        int[] ends = new int[edgeNum]; //用于保存"已有最小生成树" 中的每个顶点在最小生成树中的终点
        //创建结果数组, 保存最后的最小生成树
        EData[] rets = new EData[edgeNum];
        
        //获取图中 所有的边的集合 ， 一共有12边
        EData[] edges = getEdges();
        System.out.println("图的边的集合=" + Arrays.toString(edges) + " 共"+ edges.length); //12
        
        //按照边的权值大小进行排序(从小到大)
        sortEdges(edges);
        
        //遍历edges 数组，将边添加到最小生成树中时，判断是准备加入的边否形成了回路，如果没有，就加入 rets, 否则不能加入
        for(int i=0; i < edgeNum; i++) {
           //获取到第i条边的第一个顶点(起点)
           int p1 = getPosition(edges[i].start); //p1=4
           //获取到第i条边的第2个顶点
           int p2 = getPosition(edges[i].end); //p2 = 5
           
           //获取p1这个顶点在已有最小生成树中的终点
           int m = getEnd(ends, p1); //m = 4
           //获取p2这个顶点在已有最小生成树中的终点
           int n = getEnd(ends, p2); // n = 5
           //是否构成回路
           if(m != n) { //没有构成回路
              ends[m] = n; // 设置m 在"已有最小生成树"中的终点 <E,F> [0,0,0,0,5,0,0,0,0,0,0,0]
              rets[index++] = edges[i]; //有一条边加入到rets数组
           }
        }
        //<E,F> <C,D> <D,E> <B,F> <E,G> <A,B>。
        //统计并打印 "最小生成树", 输出  rets
        System.out.println("最小生成树为");
        for(int i = 0; i < index; i++) {
           System.out.println(rets[i]);
        }
        
        
     }
     
     //打印邻接矩阵
     public void print() {
        System.out.println("邻接矩阵为: \n");
        for(int i = 0; i < vertexs.length; i++) {
           for(int j=0; j < vertexs.length; j++) {
              System.out.printf("%12d", matrix[i][j]);
           }
           System.out.println();//换行
        }
     }
  
     /**
      * 功能：对边进行排序处理, 冒泡排序
      * @param edges 边的集合
      */
     private void sortEdges(EData[] edges) {
        for(int i = 0; i < edges.length - 1; i++) {
           for(int j = 0; j < edges.length - 1 - i; j++) {
              if(edges[j].weight > edges[j+1].weight) {//交换
                 EData tmp = edges[j];
                 edges[j] = edges[j+1];
                 edges[j+1] = tmp;
              }
           }
        }
     }
     /**
      * 
      * @param ch 顶点的值，比如'A','B'
      * @return 返回ch顶点对应的下标，如果找不到，返回-1
      */
     private int getPosition(char ch) {
        for(int i = 0; i < vertexs.length; i++) {
           if(vertexs[i] == ch) {//找到
              return i;
           }
        }
        //找不到,返回-1
        return -1;
     }
     /**
      * 功能: 获取图中边，放到EData[] 数组中，后面我们需要遍历该数组
      * 是通过matrix 邻接矩阵来获取
      * EData[] 形式 [['A','B', 12], ['B','F',7], .....]
      * @return
      */
     private EData[] getEdges() {
        int index = 0;
        EData[] edges = new EData[edgeNum];
        for(int i = 0; i < vertexs.length; i++) {
           for(int j=i+1; j <vertexs.length; j++) {
              if(matrix[i][j] != INF) {
                 edges[index++] = new EData(vertexs[i], vertexs[j], matrix[i][j]);
              }
           }
        }
        return edges;
     }
     /**
      * 功能: 获取下标为i的顶点的终点(), 用于后面判断两个顶点的终点是否相同
      * @param ends ： 数组就是记录了各个顶点对应的终点是哪个,ends 数组是在遍历过程中，逐步形成
      * @param i : 表示传入的顶点对应的下标
      * @return 返回的就是 下标为i的这个顶点对应的终点的下标, 一会回头还有来理解
      */
     private int getEnd(int[] ends, int i) { // i = 4 [0,0,0,0,5,0,0,0,0,0,0,0]
        while(ends[i] != 0) {
           i = ends[i];
        }
        return i;
     }
   
  }
  
  //创建一个类EData ，它的对象实例就表示一条边
  class EData {
     char start; //边的一个点
     char end; //边的另外一个点
     int weight; //边的权值
     //构造器
     public EData(char start, char end, int weight) {
        this.start = start;
        this.end = end;
        this.weight = weight;
     }
     //重写toString, 便于输出边信息
     @Override
     public String toString() {
        return "EData [<" + start + ", " + end + ">= " + weight + "]";
     }   
  }
  

11.8 迪杰斯特拉算法

• 基本介绍

  迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个结点到其他结点的最短路径。它的主要特点是以
  起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止

• 思路分析

  
  1. 设置出发顶点为 v，顶点集合 V{v1,v2,vi…}，v 到 V 中各顶点的距离构成距离集合 Dis，Dis{d1,d2,di…}，Dis
     集合记录着 v 到图中各顶点的距离(到自身可以看作 0，v 到 vi 距离对应为 di)
  2. 从Dis 中选择值最小的 di 并移出Dis 集合，同时移出V集合中对应的顶点 vi，此时的 v 到 vi 即为最短路径
  3. 更新Dis 集合，更新规则为：比较 v 到V集合中顶点的距离值，与 v 通过 vi 到 V集合中顶点的距离值，保留
     值较小的一个(同时也应该更新顶点的前驱节点为 vi，表明是通过 vi 到达的)
  4. 重复执行两步骤，直到最短路径顶点为目标顶点即可结束

• 代码实现

  public class DijkstraAlgorithm {
  
     public static void main(String[] args) {
        char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
        //邻接矩阵
        int[][] matrix = new int[vertex.length][vertex.length];
        final int N = 65535;// 表示不可以连接
        matrix[0]=new int[]{N,5,7,N,N,N,2};  
          matrix[1]=new int[]{5,N,N,9,N,N,3};  
          matrix[2]=new int[]{7,N,N,N,8,N,N};  
          matrix[3]=new int[]{N,9,N,N,N,4,N};  
          matrix[4]=new int[]{N,N,8,N,N,5,4};  
          matrix[5]=new int[]{N,N,N,4,5,N,6};  
          matrix[6]=new int[]{2,3,N,N,4,6,N};
          //创建 Graph对象
          Graph graph = new Graph(vertex, matrix);
          //测试, 看看图的邻接矩阵是否ok
          graph.showGraph();
          //测试迪杰斯特拉算法
          graph.dsj(2);//C
          graph.showDijkstra();
          
          
     }
  
  }
  
  class Graph {
     private char[] vertex; // 顶点数组
     private int[][] matrix; // 邻接矩阵
     private VisitedVertex vv; //已经访问的顶点的集合
  
     // 构造器
     public Graph(char[] vertex, int[][] matrix) {
        this.vertex = vertex;
        this.matrix = matrix;
     }
     
     //显示结果
     public void showDijkstra() {
        vv.show();
     }
  
     // 显示图
     public void showGraph() {
        for (int[] link : matrix) {
           System.out.println(Arrays.toString(link));
        }
     }
     
     //迪杰斯特拉算法实现
     /**
      * 
      * @param index 表示出发顶点对应的下标
      */
     public void dsj(int index) {
        vv = new VisitedVertex(vertex.length, index);
        update(index);//更新index顶点到周围顶点的距离和前驱顶点
        for(int j = 1; j <vertex.length; j++) {
           index = vv.updateArr();// 选择并返回新的访问顶点
           update(index); // 更新index顶点到周围顶点的距离和前驱顶点
        } 
     }
     
     
     
     //更新index下标顶点到周围顶点的距离和周围顶点的前驱顶点,
     private void update(int index) {
        int len = 0;
        //根据遍历我们的邻接矩阵的  matrix[index]行
        for(int j = 0; j < matrix[index].length; j++) {
           // len 含义是 : 出发顶点到index顶点的距离 + 从index顶点到j顶点的距离的和 
           len = vv.getDis(index) + matrix[index][j];
           // 如果j顶点没有被访问过，并且 len 小于出发顶点到j顶点的距离，就需要更新
           if(!vv.in(j) && len < vv.getDis(j)) {
              vv.updatePre(j, index); //更新j顶点的前驱为index顶点
              vv.updateDis(j, len); //更新出发顶点到j顶点的距离
           }
        }
     }
  }
  
  // 已访问顶点集合
  class VisitedVertex {
     // 记录各个顶点是否访问过 1表示访问过,0未访问,会动态更新
     public int[] already_arr;
     // 每个下标对应的值为前一个顶点下标, 会动态更新
     public int[] pre_visited;
     // 记录出发顶点到其他所有顶点的距离,比如G为出发顶点，就会记录G到其它顶点的距离，会动态更新，求的最短距离就会存放到dis
     public int[] dis;
     
     //构造器
     /**
      * 
      * @param length :表示顶点的个数 
      * @param index: 出发顶点对应的下标, 比如G顶点，下标就是6
      */
     public VisitedVertex(int length, int index) {
        this.already_arr = new int[length];
        this.pre_visited = new int[length];
        this.dis = new int[length];
        //初始化 dis数组
        Arrays.fill(dis, 65535);
        this.already_arr[index] = 1; //设置出发顶点被访问过
        this.dis[index] = 0;//设置出发顶点的访问距离为0
              
     }
     /**
      * 功能: 判断index顶点是否被访问过
      * @param index
      * @return 如果访问过，就返回true, 否则访问false
      */
     public boolean in(int index) {
        return already_arr[index] == 1;
     }
     
     /**
      * 功能: 更新出发顶点到index顶点的距离
      * @param index
      * @param len
      */
     public void updateDis(int index, int len) {
        dis[index] = len;
     }
     /**
      * 功能: 更新pre这个顶点的前驱顶点为index顶点
      * @param pre
      * @param index
      */
     public void updatePre(int pre, int index) {
        pre_visited[pre] = index;
     }
     /**
      * 功能:返回出发顶点到index顶点的距离
      * @param index
      */
     public int getDis(int index) {
        return dis[index];
     }
     
     
     /**
      * 继续选择并返回新的访问顶点， 比如这里的G 完后，就是 A点作为新的访问顶点(注意不是出发顶点)
      * @return
      */
     public int updateArr() {
        int min = 65535, index = 0;
        for(int i = 0; i < already_arr.length; i++) {
           if(already_arr[i] == 0 && dis[i] < min ) {
              min = dis[i];
              index = i;
           }
        }
        //更新 index 顶点被访问过
        already_arr[index] = 1;
        return index;
     }
     
     //显示最后的结果
     //即将三个数组的情况输出
     public void show() {
        
        System.out.println("==========================");
        //输出already_arr
        for(int i : already_arr) {
           System.out.print(i + " ");
        }
        System.out.println();
        //输出pre_visited
        for(int i : pre_visited) {
           System.out.print(i + " ");
        }
        System.out.println();
        //输出dis
        for(int i : dis) {
           System.out.print(i + " ");
        }
        System.out.println();
        //为了好看最后的最短距离，我们处理
        char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
        int count = 0;
        for (int i : dis) {
           if (i != 65535) {
              System.out.print(vertex[count] + "("+i+") ");
           } else {
              System.out.println("N ");
           }
           count++;
        }
        System.out.println();     
     }
  }
  

11.9 佛洛依德

• 基本介绍

  1. 和Dijkstra 算法一样，弗洛伊德(Floyd)算法也是一种用于寻找给定的加权图中顶点间最短路径的算法。该算法
     名称以创始人之一、1978 年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名
  2. 弗洛伊德算法(Floyd)计算图中各个顶点之间的最短路径
  3. 迪杰斯特拉算法用于计算图中某一个顶点到其他顶点的最短路径
  4. 弗洛伊德算法 VS 迪杰斯特拉算法：迪杰斯特拉算法通过选定的被访问顶点，求出从出发访问顶点到其他顶点
     的最短路径；弗洛伊德算法中每一个顶点都是出发访问点，所以需要将每一个顶点看做被访问顶点，求出从每
     一个顶点到其他顶点的最短路径

• 思路分析

  
  1. 设置顶点 vi 到顶点 vk 的最短路径已知为 Lik，顶点 vk 到 vj 的最短路径已知为 Lkj，顶点 vi 到 vj 的路径为 Lij，
     则 vi 到 vj 的最短路径为：min((Lik+Lkj),Lij)，vk 的取值为图中所有顶点，则可获得 vi 到 vj 的最短路径
  2. 至于 vi 到 vk 的最短路径 Lik 或者 vk 到 vj 的最短路径 Lkj，是以同样的方式获得

• 代码实现

  public class FloydAlgorithm {
  
     public static void main(String[] args) {
        // 测试看看图是否创建成功
        char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
        //创建邻接矩阵
        int[][] matrix = new int[vertex.length][vertex.length];
        final int N = 65535;
        matrix[0] = new int[] { 0, 5, 7, N, N, N, 2 };
        matrix[1] = new int[] { 5, 0, N, 9, N, N, 3 };
        matrix[2] = new int[] { 7, N, 0, N, 8, N, N };
        matrix[3] = new int[] { N, 9, N, 0, N, 4, N };
        matrix[4] = new int[] { N, N, 8, N, 0, 5, 4 };
        matrix[5] = new int[] { N, N, N, 4, 5, 0, 6 };
        matrix[6] = new int[] { 2, 3, N, N, 4, 6, 0 };
        
        //创建 Graph 对象
        Graph graph = new Graph(vertex.length, matrix, vertex);
        //调用弗洛伊德算法
        graph.floyd();
        graph.show();
     }
  
  }
  
  // 创建图
  class Graph {
     private char[] vertex; // 存放顶点的数组
     private int[][] dis; // 保存，从各个顶点出发到其它顶点的距离，最后的结果，也是保留在该数组
     private int[][] pre;// 保存到达目标顶点的前驱顶点
  
     // 构造器
     /**
      * 
      * @param length
      *            大小
      * @param matrix
      *            邻接矩阵
      * @param vertex
      *            顶点数组
      */
     public Graph(int length, int[][] matrix, char[] vertex) {
        this.vertex = vertex;
        this.dis = matrix;
        this.pre = new int[length][length];
        // 对pre数组初始化, 注意存放的是前驱顶点的下标
        for (int i = 0; i < length; i++) {
           Arrays.fill(pre[i], i);
        }
     }
  
     // 显示pre数组和dis数组
     public void show() {
  
        //为了显示便于阅读，我们优化一下输出
        char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
        for (int k = 0; k < dis.length; k++) {
           // 先将pre数组输出的一行
           for (int i = 0; i < dis.length; i++) {
              System.out.print(vertex[pre[k][i]] + " ");
           }
           System.out.println();
           // 输出dis数组的一行数据
           for (int i = 0; i < dis.length; i++) {
              System.out.print("("+vertex[k]+"到"+vertex[i]+"的最短路径是" + dis[k][i] + ") ");
           }
           System.out.println();
           System.out.println();
  
        }
  
     }
     
     //弗洛伊德算法, 比较容易理解，而且容易实现
     public void floyd() {
        int len = 0; //变量保存距离
        //对中间顶点遍历， k 就是中间顶点的下标 [A, B, C, D, E, F, G] 
        for(int k = 0; k < dis.length; k++) { // 
           //从i顶点开始出发 [A, B, C, D, E, F, G]
           for(int i = 0; i < dis.length; i++) {
              //到达j顶点 // [A, B, C, D, E, F, G]
              for(int j = 0; j < dis.length; j++) {
                 len = dis[i][k] + dis[k][j];// => 求出从i 顶点出发，经过 k中间顶点，到达 j 顶点距离
                 if(len < dis[i][j]) {//如果len小于 dis[i][j]
                    dis[i][j] = len;//更新距离
                    pre[i][j] = pre[k][j];//更新前驱顶点
                 }
              }
           }
        }
     }
  }
  

，下标就是6
*/
public VisitedVertex(int length, int index) {
this.already_arr = new int[length];
this.pre_visited = new int[length];
this.dis = new int[length];
//初始化 dis数组
Arrays.fill(dis, 65535);
this.already_arr[index] = 1; //设置出发顶点被访问过
this.dis[index] = 0;//设置出发顶点的访问距离为0

 }
 /**
  * 功能: 判断index顶点是否被访问过
  * @param index
  * @return 如果访问过，就返回true, 否则访问false
  */
 public boolean in(int index) {
    return already_arr[index] == 1;
 }
 
 /**
  * 功能: 更新出发顶点到index顶点的距离
  * @param index
  * @param len
  */
 public void updateDis(int index, int len) {
    dis[index] = len;
 }
 /**
  * 功能: 更新pre这个顶点的前驱顶点为index顶点
  * @param pre
  * @param index
  */
 public void updatePre(int pre, int index) {
    pre_visited[pre] = index;
 }
 /**
  * 功能:返回出发顶点到index顶点的距离
  * @param index
  */
 public int getDis(int index) {
    return dis[index];
 }
 
 
 /**
  * 继续选择并返回新的访问顶点， 比如这里的G 完后，就是 A点作为新的访问顶点(注意不是出发顶点)
  * @return
  */
 public int updateArr() {
    int min = 65535, index = 0;
    for(int i = 0; i < already_arr.length; i++) {
       if(already_arr[i] == 0 && dis[i] < min ) {
          min = dis[i];
          index = i;
       }
    }
    //更新 index 顶点被访问过
    already_arr[index] = 1;
    return index;
 }
 
 //显示最后的结果
 //即将三个数组的情况输出
 public void show() {
    
    System.out.println("==========================");
    //输出already_arr
    for(int i : already_arr) {
       System.out.print(i + " ");
    }
    System.out.println();
    //输出pre_visited
    for(int i : pre_visited) {
       System.out.print(i + " ");
    }
    System.out.println();
    //输出dis
    for(int i : dis) {
       System.out.print(i + " ");
    }
    System.out.println();
    //为了好看最后的最短距离，我们处理
    char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
    int count = 0;
    for (int i : dis) {
       if (i != 65535) {
          System.out.print(vertex[count] + "("+i+") ");
       } else {
          System.out.println("N ");
       }
       count++;
    }
    System.out.println();     
 }

}

## 11.9 佛洛依德

- 基本介绍

1. 和Dijkstra 算法一样，弗洛伊德(Floyd)算法也是一种用于寻找给定的加权图中顶点间最短路径的算法。该算法
   名称以创始人之一、1978 年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名
2. 弗洛伊德算法(Floyd)计算图中各个顶点之间的最短路径
3. 迪杰斯特拉算法用于计算图中某一个顶点到其他顶点的最短路径
4. 弗洛伊德算法 VS 迪杰斯特拉算法：迪杰斯特拉算法通过选定的被访问顶点，求出从出发访问顶点到其他顶点
   的最短路径；弗洛伊德算法中每一个顶点都是出发访问点，所以需要将每一个顶点看做被访问顶点，求出从每
   一个顶点到其他顶点的最短路径

- 思路分析

<img src="https://zuimeiweidebingqilin-1317588512.cos.ap-shanghai.myqcloud.com/lj/%E4%BD%9B%E6%B4%9B%E4%BE%9D%E5%BE%B7%E7%AE%97%E6%B3%95.jpg" />

1) 设置顶点 vi 到顶点 vk 的最短路径已知为 Lik，顶点 vk 到 vj 的最短路径已知为 Lkj，顶点 vi 到 vj 的路径为 Lij，
   则 vi 到 vj 的最短路径为：min((Lik+Lkj),Lij)，vk 的取值为图中所有顶点，则可获得 vi 到 vj 的最短路径
2) 至于 vi 到 vk 的最短路径 Lik 或者 vk 到 vj 的最短路径 Lkj，是以同样的方式获得

- 代码实现

```java
public class FloydAlgorithm {

   public static void main(String[] args) {
      // 测试看看图是否创建成功
      char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
      //创建邻接矩阵
      int[][] matrix = new int[vertex.length][vertex.length];
      final int N = 65535;
      matrix[0] = new int[] { 0, 5, 7, N, N, N, 2 };
      matrix[1] = new int[] { 5, 0, N, 9, N, N, 3 };
      matrix[2] = new int[] { 7, N, 0, N, 8, N, N };
      matrix[3] = new int[] { N, 9, N, 0, N, 4, N };
      matrix[4] = new int[] { N, N, 8, N, 0, 5, 4 };
      matrix[5] = new int[] { N, N, N, 4, 5, 0, 6 };
      matrix[6] = new int[] { 2, 3, N, N, 4, 6, 0 };
      
      //创建 Graph 对象
      Graph graph = new Graph(vertex.length, matrix, vertex);
      //调用弗洛伊德算法
      graph.floyd();
      graph.show();
   }

}

// 创建图
class Graph {
   private char[] vertex; // 存放顶点的数组
   private int[][] dis; // 保存，从各个顶点出发到其它顶点的距离，最后的结果，也是保留在该数组
   private int[][] pre;// 保存到达目标顶点的前驱顶点

   // 构造器
   /**
    * 
    * @param length
    *            大小
    * @param matrix
    *            邻接矩阵
    * @param vertex
    *            顶点数组
    */
   public Graph(int length, int[][] matrix, char[] vertex) {
      this.vertex = vertex;
      this.dis = matrix;
      this.pre = new int[length][length];
      // 对pre数组初始化, 注意存放的是前驱顶点的下标
      for (int i = 0; i < length; i++) {
         Arrays.fill(pre[i], i);
      }
   }

   // 显示pre数组和dis数组
   public void show() {

      //为了显示便于阅读，我们优化一下输出
      char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
      for (int k = 0; k < dis.length; k++) {
         // 先将pre数组输出的一行
         for (int i = 0; i < dis.length; i++) {
            System.out.print(vertex[pre[k][i]] + " ");
         }
         System.out.println();
         // 输出dis数组的一行数据
         for (int i = 0; i < dis.length; i++) {
            System.out.print("("+vertex[k]+"到"+vertex[i]+"的最短路径是" + dis[k][i] + ") ");
         }
         System.out.println();
         System.out.println();

      }

   }
   
   //弗洛伊德算法, 比较容易理解，而且容易实现
   public void floyd() {
      int len = 0; //变量保存距离
      //对中间顶点遍历， k 就是中间顶点的下标 [A, B, C, D, E, F, G] 
      for(int k = 0; k < dis.length; k++) { // 
         //从i顶点开始出发 [A, B, C, D, E, F, G]
         for(int i = 0; i < dis.length; i++) {
            //到达j顶点 // [A, B, C, D, E, F, G]
            for(int j = 0; j < dis.length; j++) {
               len = dis[i][k] + dis[k][j];// => 求出从i 顶点出发，经过 k中间顶点，到达 j 顶点距离
               if(len < dis[i][j]) {//如果len小于 dis[i][j]
                  dis[i][j] = len;//更新距离
                  pre[i][j] = pre[k][j];//更新前驱顶点
               }
            }
         }
      }
   }
}