第一章 树结构的基础部分
分为三大基础树：二叉树、顺序存储二叉树、线索化二叉树
一、二叉树
1.各种存储方式异同
- 数组存储的特点：通过下标方式访问元素，速度快，但插入值时效率太低
- 链表存储的特点：插入删除元素时效率高，但是进行检索时，效率仍然很低
- **树存储的特点：**能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。
2.树的示意图
树的常用术语：
节点、根节点、父节点、子节点、叶子节点 (没有子节点的节点)、节点的权(节点值)、路径(从 root 节点找到该节点的路线)、层、子树、树的高度(最大层数)、森林 :多颗子树构成森林
二、二叉树
1.概念
- 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树
- 二叉树的子节点分为左节点和右节点
- 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树
- 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树
2.二叉树构建
第一步先构造叶子节点
class HeroNode{
private int no;//叶子编号
private String name;//叶子信息
private HeroNode left;//左节点
private HeroNode right;//右节点
@Override
public String toString() {
return "HeroNode [no=" + no + ", 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;
}
public HeroNode(int no, String name) {
super();
this.no = no;
this.name = name;
}
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);
}
public HeroNode preordersearch(int no){//前序查找
System.out.println("前序查找");
if(this.no==no){
return this;
}
HeroNode resNode=null;
if(this.left!=null){
resNode=this.left.preordersearch(no);
}
if(resNode!=null){
return resNode;
}
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;
}
public void delNode(int no){
if(this.left!=null&&this.left.no==no){
this.left=null;
return;
}
if(this.right != null && this.right.no == no) {
this.right = null;
return;
}
if(this.left != null) {
this.left.delNode(no);
}
if(this.right != null) {
this.right.delNode(no);
}
}
}
第二步构造二叉树
class BinaryTree{
private HeroNode root;//二叉树要有根节点
public void setRoot(HeroNode root) {//设置根节点
this.root = root;
}
public void Treepreorder(){//树前序遍历
if(this.root!=null){
this.root.preorder();
}else{
System.out.println("二叉树为空，无法遍历");
}
}
public HeroNode TreepreSearch(int no){//树前序查找
if(root!=null){
return root.preordersearch(no);
}else{
return null;
}
}
public void Treeinfixorder(){//树中序遍历
if(this.root!=null){
this.root.infixorder();
}else{
System.out.println("二叉树为空，无法遍历");
}
}
public HeroNode TreeinfixSearch(int no){//树中序查找
if(root!=null){
return root.infixordersearch(no);
}else{
return null;
}
}
public void Treepostorder(){//树后续遍历
if(this.root!=null){
this.root.postorder();
}else{
System.out.println("二叉树为空，无法遍历");
}
}
public HeroNode TreepostSearch(int no){//树后续查找
if(root!=null){
return root.postordersearch(no);
}else{
return null;
}
}
public void delNode(int no){//树节点的删除
if(root!=null){
if(root.getNo()==no){
root=null;
}else{
root.delNode(no);
}
}else{
System.out.println("空树，无法删除");
}
}
}
3.二叉树遍历
3.1前序遍历
先输出父节点，再遍历左子树和右子树
代码思路：
- 先输出当前节点(初始的时候的root节点)
- 如果左子节点不为空，则递归继续前序遍历–>(根左右)
- 如果右子节点不为空，则递归继续前序遍历
代码实现：
public void preorder(){//前序遍历
System.out.println(this);
if(this.left!=null){
this.left.preorder();
}
if(this.right!=null){
this.right.preorder();
}
}
3.2中序遍历
先遍历左子树，再输出父节点，再遍历左子树
代码思路：
- 如果当前节点的左子节点不为空，则递归中序遍历
- 输出当前节点–>(左根右)
- 如果当前节点的右子节点不为空，则递归中序遍历
代码实现：
public void infixorder(){//中序遍历
if(this.left!=null){
this.left.infixorder();
}
System.out.println(this);
if(this.right!=null){
this.right.infixorder();
}
}
3.3后序遍历
先遍历左子树，再遍历右子树，最后输出父节点
代码思路：
- 如果当前节点的左子节点不为空，则递归后序遍历
- 如果当前节点的右子节点不为空，则递归后序遍历–>(左右根)
- 输出当前节点
代码实现：
public void postorder(){//后序遍历
if(this.left!=null){
this.left.postorder();
}
if(this.right!=null){
this.right.postorder();
}
System.out.println(this);
}
4.二叉树的删除
①和遍历顺序相同，若当前找到，则返回，否则按左右节点递归查找
②删除的要求：
- 如果删除的节点是叶子节点，则删除该节点
- 如果删除的节点是非叶子节点，则删除该子树
③代码思路：
- 先判断根节点root是不是待删除的节点，如果是，则删除根节点否则开始执行递归
- 判断当前节点(this)的左节点是不是待删除的节点，如果是，则删除this.left，然后返回，结束递归
- 判断当前节点(this)的右节点是否为待删除的节点，如果是，则删除this.right，然后返回，结束递归
- 否则继续执行左递归，左递归执行完后，执行右递归
二、顺序存储二叉树
1.概念
从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组
- 上图的二叉树的结点，要求以数组的方式来存放 arr : [1, 2, 3, 4, 5, 6, 6]
- 要求在遍历数组 arr 时，仍然可以以前序遍历，中序遍历和后序遍历的方式完成结点的遍历
2.特点
- 顺序二叉树通常只考虑完全二叉树
- 第 n 个元素的左子节点为 2 * n + 1
- 第 n 个元素的右子节点为 2 * n + 2
- 第 n 个元素的父节点为 (n-1) / 2
- n : 表示二叉树中的第几个元素
3.代码实现
public class ArrBinaryTreeDemo {
public static void main(String[] args) {
int []arr={1,2,3,4,5,6,7};
ArrBinaryTree arrBinaryTree = new ArrBinaryTree(arr);
arrBinaryTree.preOrder();//1245367
System.out.println();
arrBinaryTree.infixOrder();//2451367
System.out.println();
arrBinaryTree.postOrder();//2453671
}
}
class ArrBinaryTree{
private int []arr;
public ArrBinaryTree(int []arr){
this.arr=arr;
}
public void preOrder(){
preOrder(0);
}
public void infixOrder(){
infixOrder(0);
}
public void postOrder(){
postOrder(0);
}
//前序遍历
public void preOrder(int index){
if(arr==null||arr.length==0){
System.out.println("该顺序二叉树为空，无法遍历");
}
System.out.print(arr[index]+" ");
if((index*2+1)<arr.length){//向左递归遍历
preOrder((index*2+1));
}
if((index*2+2)<arr.length){//向右递归遍历
preOrder((index*2+2));
}
}
//中序遍历
public void infixOrder(int index){
if(arr==null||arr.length==0){
System.out.println("该顺序二叉树为空，无法遍历");
}
if((index*2+1)<arr.length){//向左递归遍历
preOrder((index*2+1));
}
System.out.print(arr[index]+" ");
if((index*2+2)<arr.length){//向右递归遍历
preOrder((index*2+2));
}
}
//后序遍历
public void postOrder(int index){
if(arr==null||arr.length==0){
System.out.println("该顺序二叉树为空，无法遍历");
}
if((index*2+1)<arr.length){//向左递归遍历
preOrder((index*2+1));
}
if((index*2+2)<arr.length){//向右递归遍历
preOrder((index*2+2));
}
System.out.print(arr[index]+" ");
}
}
理解：顺序存储二叉树的实现，是通过左右节点公式递归形成的
三、线索化二叉树
1.概念
- n 个结点的二叉链表中含有 n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向
该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"） - 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种
- 一个结点的前一个结点，称为前驱结点
- 一个结点的后一个结点，称为后继结点
2.对二叉树进行中序线索化
public void infixthreadedNodes(TreeNode node){
if(node == null){
return;
}
infixthreadedNodes(node.getLeft());
if(node.getLeft() == null){
node.setLeft(pre);
node.setLeftType(1);
}
if(pre != null && pre.getRight() == null){
pre.setRight(node);
pre.setRightType(1);
}
pre = node;
infixthreadedNodes(node.getRight());
}
3.遍历线索化二叉树
public void infixthreadedList(){
TreeNode cur = root;//从根节点开始
while(cur != null){//开始找节点遍历
while (cur.getLeftType() == 0){//如果有前驱节点，一直向左向下寻找最下面最左边的节点
cur = cur.getLeft();
}
System.out.println(cur);//输出当前节点
while(cur.getRightType() == 1){//如果有后继节点，找到后继节点输出
cur = cur.getRight();
System.out.println(cur);
}
cur = cur.getRight();//向右找
}
}
四、赫夫曼树
1.概念
给定 n 个权值作为 n 个叶子结点，构造一棵二叉树，若该树的带权路径长度(wpl)达到最小，称这样的二叉树为最优二叉树，称为霍夫曼树。
2.重要性质
- 路径和路径长度：在一棵树中，从一个结点往下可以达到的孩子或孙子结点之间的通路，称为路径。通路中分支的数目称为路径长度。若规定根结点的层数为 1，则从根结点到第 L 层结点的路径长度为 L-1
- 结点的权及带权路径长度：若将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。结点的带权路径长度为：从根结点到该结点之间的路径长度与该结点的权的乘积，为了使权值最小，大的数往上放
- 树的带权路径长度：树的带权路径长度规定为所有叶子结点的带权路径长度之和，记为WPL(weighted pathlength) ,权值越大的结点离根结点越近的二叉树才是最优二叉树
3.霍夫曼树的创建
核心思想：让权值小的节点远离根节点，让权值大的节点靠近根节点
- 从小到大排序，将一个数据视为一个节点，每个节点都看作一颗简单的二叉树
- 取出根节点权值最小的两棵二叉树，组成一棵新的二叉树，该树的二叉树的根节点的权值是前面两棵二叉树根节点权值的和
- 再将这颗新的二叉树。以根节点的权值大小再次排序，不断重复上述步骤，直到数列中，所有的数据都被处理，就得到一颗霍夫曼树
4.代码实现
先构造节点
class Node implements Comparable<Node>{
int value;
Node leftnode;
Node rightnode;
public Node(int value){
this.value = value;
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
public void preOrder(){
System.out.println(this);
if(this.leftnode != null){
this.leftnode.preOrder();
}
if(this.rightnode != null){
this.rightnode.preOrder();
}
}
@Override
public int compareTo(Node o) {
return this.value - o.value;//从小到大排序
}
}
构造并实现霍夫曼树：
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 Node createHuffmanTree(int[] arr){
ArrayList<Node> list = new ArrayList<>();//造一个集合
for(int value : arr){//遍历数组，把带有数组的值的节点装到集合中
list.add(new Node(value));
}
while(list.size() > 1){//要留一个根节点，除根节点之外开始循环
Collections.sort(list);//先从小到大排序
System.out.println("nodes=" + list);
Node leftNode = list.get(0);//去除最小的和次小的作为第一棵树的左右子节点
Node rightNode = list.get(1);
Node parent = new Node(leftNode.value +rightNode.value);//构造父节点
parent.leftnode = leftNode;//此时，是在给父节点配属性，不能让父节点的左右节点空着
parent.rightnode = rightNode;
list.remove(leftNode);//而此时删掉的是集合中的节点，不删的话节点就会产生的越来越多
list.remove(rightNode);
list.add(parent);//别忘了父节点做好之后放到集合里
}
return list.get(0);//循环完之后剩一个根节点，而此时的根节点下面就是完整的霍夫曼树
//通过遍历就能体现霍夫曼树
}
public static void preOrder(Node root){
if(root != null){
root.preOrder();
}else {
System.out.println("空树，不能遍历");
}
}
}
五、霍夫曼树的应用–霍夫曼编码
1.介绍
- 赫夫曼编码也翻译为 哈夫曼编码(Huffman Coding)，又称霍夫曼编码，是一种编码方式, 属于一种程序算法
- 赫夫曼编码是赫哈夫曼树在电讯通信中的经典的应用之一。
- 赫夫曼编码广泛地用于数据文件压缩。其压缩率通常在 20%～90%之间
- 赫夫曼码是可变字长编码(VLC)的一种。Huffman 于 1952 年提出一种编码方法，称之为最佳编码
- 通信领域中信息的处理方式一般有三种：定长编码，变长编码和霍夫曼编码
2.霍夫曼树应用–数据压缩
任务：给定一个字符串“i like like like java do you like a java",将该文本输出霍夫曼编码
思路：
- 构造节点Node{data [存放数据] ，weight [存放权值]， left和right}
- 得到“i like like like java do you like a java"对应的byte[]数组
- 编写一个方法，将准备构建霍夫曼树的Node节点放到list，如Node{data = 97(‘a’) , weight = 5}
- 可以通过list创建对应的霍夫曼树
第一步：创建霍夫曼树
public class HuffManCode {
public static void main(String[] args) {
String content = "i like like like java do you like a java";
byte[] bytes = content.getBytes();
List<Node> nodes = getNodes(bytes);
Node root = createhuffmantree(nodes);
preOrder(root);
}
public static void preOrder(Node root){
if(root != null){
root.preOrder();
}else{
System.out.println("空树，不能遍历");
}
}
private static List<Node> getNodes(byte[] bytes){
//1.构建一个ArrayList
ArrayList<Node> nodes = new ArrayList<>();
//2.构建一个Map,把byte数组中的字符以及字符出现的次数装到Map中去
HashMap<Byte, Integer> counts = new HashMap<>();
for(byte b : bytes){//遍历byte数组，取得每一个字符
Integer count = counts.get(b);//若没出现过，就置为1
if(count == null){
counts.put(b,1);
}else {
counts.put(b,count+1);//若出现过，就+1
}
}
//此时得到一个键为字符，值为字符出现的次数的Map，遍历该Map
for(Map.Entry<Byte,Integer> entry : counts.entrySet()){
nodes.add(new Node(entry.getKey(),entry.getValue()));//将Map中的键值对取出来
//作为新的Node逐个装入到list中
}
return nodes;//此时输出list
}
//通过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);
Node parent = new Node(null,leftnode.weight + rightnode.weight);
parent.left = leftnode;
parent.right = rightnode;
nodes.remove(leftnode);
nodes.remove(rightnode);
nodes.add(parent);
}
return nodes.get(0);
}
}
class Node implements Comparable<Node>{
Byte data;
int weight;
Node left;
Node right;
public Node(Byte data,int weight){
this.data = data;
this.weight = weight;
}
@Override
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();
}
}
@Override
public int compareTo(Node o) {
return this.weight - o.weight;// 从小到大排序
}
}
第二步：将霍夫曼树转为霍夫曼编码
static Map<Byte,String> huffManCodes = new HashMap<>();//把霍夫曼编码装到Map中
static StringBuilder stringbuileder= new StringBuilder();//用于字符串的拼接
//在找叶子节点的过程中
private static Map<Byte,String> getCodes(Node root){//重载getCodes方法得到霍夫曼编码
if(root == null){
return null;
}else {
getCodes(root.left,"0",stringbuileder);
getCodes(root.right,"1",stringbuileder);
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);
stringBuilder2.append(code);//拼接编码
if (node != null){//node = null不处理
if(node.data == null){//非叶子节点
//递归向左右处理
getCodes(node.left,"0",stringBuilder2);
getCodes(node.right,"1",stringBuilder2);
}else {//叶子节点
huffManCodes.put(node.data,stringBuilder2.toString());
}
}
}
第三步：用霍夫曼编码生成霍夫曼编码数据
//使用一个方法，将前面的方法封装起来，便于我们的调用.
/**
*
* @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);
index++;
}
return huffmanCodeBytes;
}
3.*数据解码
/**
* 将一个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 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;
}
4.使用霍夫曼编码压缩文件
将文件压缩：
//编写方法，将一个文件进行压缩
/**
*
* @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());
}
}
}
5.使用霍夫曼编码解压文件
//编写一个方法，完成对压缩文件的解压
/**
*
* @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());
}
}
}
六、二叉排序树
1.概念
二叉排序树： BST(Binary Sort(Search) Tree), 对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大，若相同，放到左子节点和右子节点均可。
2.二叉排序树的创建与遍历
//创建二叉排序树
class BinarySortTree{
private Node root;
public void add(Node node){
if(root==null){
root=node;
}else{
root.add(node);
}
}
public void infixOrder(){
if(root!=null){
root.infixOrder();
}else{
System.out.println("二叉排序树为空，无法遍历");
}
}
}
//创建节点
class Node{
int value;
Node left;
Node right;
public Node(int value){
this.value=value;
}
@Override
public String toString() {
return "Node [value=" + value + "]";
}
public void add(Node node){
if(node == null){
return;
}
if(node.value < this.value){
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);
}
}
}
public void infixOrder(){
if(this.left!=null){
this.left.infixOrder();
}
System.out.println(this);
if(this.right!=null){
this.right.infixOrder();
}
}
public Node search(int value){
if(this.value == value){
return this;
}else if(this.value > value){
if (this.left == null) {
return null;
}
return this.left.search(value);
}else {
if(this.right == null){
return null;
}
return this.right.search(value);
}
}
public Node searchParent(int value){
if(this.left != null && this.left.value ==value || this.right != null && this.right.value == value){//若当前节点的左不空且左的值等于查找的值，或者右边也是这样。那父节点就是自己
return this;
}else {
if(this.left != null && value < this.value){
return this.left.searchParent(value);
}else if(this.right != null && value >= this.value){
return this.right.searchParent(value);
}else {//最后找不到就返回null
return null;
}
}
}
}
3.二叉排序树的删除
一共分为三种情况：
- 删除的节点没有子节点，即删除叶子节点
- 删除的节点有一个叶子节点
- 删除的节点有两个叶子节点
思路分析：
4. 第一种情况:
删除叶子节点 (比如：2, 5, 9, 12)
思路
(1) 需要先去找到要删除的结点 targetNode
(2) 找到 targetNode 的 父结点 parent
(3) 确定 targetNode 是 parent 的左子结点 还是右子结点
(4) 根据前面的情况来对应删除
左子结点 parent.left = null;
右子结点 parent.right = null;
- 第二种情况: 删除只有一颗子树的节点 比如 1
思路
(1) 需要先去找到要删除的结点 targetNode
(2) 找到 targetNode 的 父结点 parent
(3) 确定 targetNode 的子结点是左子结点还是右子结点
(4) targetNode 是 parent 的左子结点还是右子结点
(5) 如果 targetNode 有左子结点
5.1 如果 targetNode 是 parent 的左子结点parent.left = targetNode.left;
5.2 如果 targetNode 是 parent 的右子结点parent.right = targetNode.left;
(6) 如果 targetNode 有右子结点
6.1 如果 targetNode 是 parent 的左子结点parent.left = targetNode.right;
6.2 如果 targetNode 是 parent 的右子结点parent.right = targetNode.right;
此时的四种情况：
- 第三种情况： 删除有两颗子树的节点. (比如：7, 3,10)
思路
(1) 需要先去找到要删除的结点 targetNode
(2) 找到 targetNode 的 父结点 parent
(3) 从 targetNode 的右子树找到最小的结点
(4) 用一个临时变量，将 最小结点的值保存 temp = 11
(5) 删除该最小结点
(6)targetNode.value = temp; - 代码实现：
public int delRightTreeMin(Node node){
Node temp = node;
while (temp.left != null){
temp = temp.left;
}
delete(temp.value);
return temp.value;
}
public int delLeftTreeMax(Node node){
Node temp = node;
while (temp.right != null) {
temp = temp.right;
}
delete(temp.value);
return temp.value;
}
public void delete(int value){
if(root == null){
return;
}else {
Node targetnode = search(value);
if(targetnode == null){
return;
}
//1.如果此时只有根节点
if(root.left == null && root.right == null){
root = null;
return;
}
//1.第一种情况：删掉叶子节点,先获取一下目标节点的父节点
Node parent = searchparent(value);
if(targetnode.left == null && targetnode.right == null){
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){//2.第三种情况，删除有两个子节点的节点
int minVal = delRightTreeMin(targetnode.right);//从右边找个最小的数来顶替根节点
targetnode.value = minVal;
// int maxVal = delLeftTreeMax(targetnode.left);//从左边找个最大的数来顶替根节点
// targetnode.value = maxVal;
}else {//3.第二种情况，删除有一个子节点的节点
if(targetnode.left != null){//如果目标节点的左节点不为空
if(parent != null){//!!!!!!!!!!注意
if(parent.left.value == value){//且目标结点确定
parent.left = targetnode.left;//就是①(圈1)
}else {
parent.left = targetnode.right;//②(圈2)
}
}else {
root = targetnode.left;
}
}else {
if(parent != null){
if(parent.left.value == value){
parent.left = targetnode.right;//③(圈3)
}else {
parent.right = targetnode.right;//④(圈4)
}
}else {
root = targetnode.right;
}
}
}
}
}
注意：
- 当删除的节点具有左右节点时，可以通过找到左边最大的节点值来代替根节点，也可以找到右边最小的节点值来代替根节点，在获取最大(或者最小)值时，就可以在其方法内将该最大(或者最小)节点删除，回到删除的主方法中，就可以直接把根节点的值改为最大(或最小)节点的值即可。
- ！！！注意的点：若此时只剩根节点和其一个子结点，在删除时要考虑根节点的父节点是空的，如果不对父节点讨论，会导致空指针异常。
七、平衡二叉树
1. 介绍
平衡二叉树是二叉排序树的升级和优化，当给一个升序数组时，转为二叉排序树就更像一个单链表，查询速度还比单链表慢，所以体现不出二叉排序树的优势，而平衡二叉树很好地解决了这个不足。
2.概念
- 平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为 AVL 树， 可以保证查询效率较高。
- 具有以下特点：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过 1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。
3.排序树转化平衡树
思路：当你的右子树的高度比左子树的高度高时，采用左旋转(即谁矮谁旋转)，左旋转的目的是要降低右子树的高度。
左旋转：
右旋转：
说明：由于平衡二叉树是二叉排序树的优化，所以是直接在二叉排序树的程序上进行改动
第一步：先计算左子树和右子树的高度,定义在Node中的高度方法
public int height(){
return Math.max(left == null ? 0 : left.height(),
right == null ? 0 : right.height()) + 1;//加1是因为根节点本身算一层
}
public int left_height(){
if(left == null){
return 0;
}
return left.height();
}
public int right_height(){
if(right == null){
return 0;
}
return right.height();
}
第二步：进行左(右)旋转
private void leftRotate(){
Node1 newNode = new Node1(this.value);//创建新的结点，以当前根结点的值
newNode.left = this.left;//把新的结点的左子树设置成当前结点的左子树
newNode.right = this.right.left;//把新的结点的右子树设置成带你过去结点的右子树的左子树
this.value = this.right.value;//把当前结点的值替换成右子结点的值
this.right = this.right.right;//把当前结点的右子树设置成当前结点右子树的右子树
this.left = newNode;//把当前结点的左子树(左子结点)设置成新的结点
}
private void rightRotate() {
Node1 newNode = new Node1(this.value);//创建新的结点，以当前根结点的值
newNode.right = this.right;//把新的结点的右子树设置成当前结点的右子树
newNode.left = this.left.right;//把新的结点的左子树设置成带你过去结点的左子树的右子树
this.value = this.left.value;//把当前结点的值替换成左子结点的值
this.left = this.left.left;//把当前结点的左子树设置成当前结点左子树的左子树
this.right = newNode;//把当前结点的右子树(右子结点)设置成新的结点
}
4.平衡二叉树的双旋转
存在的问题：由于某些数组比较特殊，经过一次单旋转之后并不能得到一棵平衡二叉树，所以此时需要双旋转。
思路：
- 若左子树的右子树的高度小于左子树的左子树高度
- 对当前节点10这个节点的左节点进行左旋转(遵循谁矮谁旋转)
- 再对当前节点10进行右旋转
此时需要改变添加Node的方法，改进后的add方法如下：
public void add(Node1 node){
if(node == null){
return;
}
if(node.value < this.value){
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(right_height() - left_height() > 1) {
if(this.right != null && this.right.left_height() > this.right.right_height()){
//如果它的右子树的左子树的高度大于它的右子树的右子树的高度
//先对的右子节点进行旋转
this.right.rightRotate();
//然后在对当前结点进行左旋转
leftRotate();
}else {
//没啥特殊情况就进行一次单旋转(左旋转)
leftRotate();
}
}else if(left_height() - right_height() > 1){//当添加完一个结点后，如果 (左子树的高度 - 右子树的高度) > 1, 右旋转
if(this.left != null && this.left.left_height() < this.left.right_height()){
//如果它的左子树的右子树高度大于它的左子树的高度
//先对当前结点的左结点(左子树)->左旋转
this.left.leftRotate();
//再对当前结点进行右旋转
rightRotate();
}else {
//没啥特殊情况就进行一次单旋转(右旋转)
rightRotate();
}
}
//这一段使用if else if主要是因为根节点的左节点或者右节点只会满足一边需要双旋转的情况
//所以为了不影响后面的平衡二叉树，所以在这里进行一次双旋转即可得到平衡二叉树
}
第二章 多路查找树
一、B树
1.B树是二叉树的升级
树结构的查询效率高，并且可以保持有序，这使得数据库索引使用非常便利。但是既然使用树结构，二叉搜索树的查询时间复杂度是O(log(n))，从算法逻辑上来讲，无论查找速度还是比较次数都是最小的，那为什么数据库索引没有采用二叉搜索树呢？因为在实际情况下，我们不得不考虑另外一个现实问题，磁盘IO，因为数据库的索引通常十分庞大，需要以文件形式存储，而磁盘IO的存取次数就是评价一个数据库索引优劣的关键性指标。
树的查找是由树的高度决定的，所以在二叉查找树中，最坏的情况下，磁盘的IO次数等于索引树的高度，而二叉查找树的性质决定了，大数据量的情况下树的高度必然会很高，所以为了减少磁盘IO次数，我们需要将瘦高的树变得矮胖，这也是B-tree的特征之一。
二叉树作为一种数据结构，还是要被实际使用的。当节点少的时候，没什么问题。如果节点很多，就需要进行多次 i/o 操作(海量数据存在数据库或文件中)，所以构建二叉树时，速度就会有影响。而且二叉树的高度也会很大，降低操作速度，此时就需要B树这种数据结构。
2.多叉树的概念
如果允许每个节点可以有更多的数据项和更多的子节点，就是多叉树(multiway tree)
2节点指 一个左节点一个右结点 就是含有一个数据
3节点 指一个左节点 一个右结点 一个中节点，含有两个数据
3.2-3树是一种多叉树
2-3 树是最简单的 B 树结构, 具有如下特点:
- 2-3 树的所有叶子节点都在同一层.(只要是 B 树都满足这个条件)
- 有两个子节点的节点叫二节点，二节点要么没有子节点，要么有两个子节点.
- 有三个子节点的节点叫三节点，三节点要么没有子节点，要么有三个子节点.
- 2-3 树是由二节点和三节点构成的
二、B树、 B+树和 B*树
1.B树的介绍
B-tree 树即 B 树，B 即 Balanced，平衡的意思。只有B树和Balanced Tree称呼。B-tree这个数据结构一般用于数据库的索引，综合效率较高。比如MySql的索引采用的就是B+树，是B-tree的变体，所以接下来我们先了解B-tree的原理。
2.B树的相关概念
- B 树的阶：节点的最多子节点个数。比如 2-3 树的阶是 3，2-3-4 树的阶是4
- B 树的搜索，从根结点开始，对结点内的关键字(有序)序列进行二分查找，如果命中则结束，否则进入查询关键字所属范围的儿子结点；重复，直到所对应的儿子指针为空，或已经是叶子结点
- 关键字集合分布在整颗树中, 即叶子节点和非叶子节点都存放数据.
- 搜索有可能在非叶子结点结束
- 其搜索性能等价于在关键字全集内做一次二分查找
3.B+树的介绍
B+树是B树的变体，是一种多路搜索树
- B+树的搜索与 B 树也基本相同，区别是 B+树只有达到叶子结点才命中(B 树可以在非叶子结点命中)，其性能也等价于在关键字全集做一次二分查找
- 所有关键字都出现在叶子结点的链表中(即数据只能在叶子节点【也叫稠密索引】)，且链表中的关键字(数据)恰好是有序的。除叶子节点层之外都是查找数据的索引
- 不可能在非叶子结点命中
- 非叶子结点相当于是叶子结点的索引(稀疏索引)，叶子结点相当于是存储(关键字)数据的数据层
- 更适合文件索引系统
- B 树和 B+树各有自己的应用场景，不能说 B+树完全比 B 树好
4.B*树的介绍
B*树是B+树的变体，在B+树的非根和非叶子结点再增加指向兄弟的指针。
- B*树定义了非叶子结点关键字个数至少为(2/3)*M，即块的最低使用率为 2/3，而 B+树的块的最低使用率为的1/2。
- 从第 1 个特点我们可以看出，B*树分配新结点的概率比 B+树要低，空间使用率更高
5.关于树的面试相关问题
第三章 图
一、图的基本介绍
1.为什么要有图
- 前面我们学了线性表和树
- 线性表局限于一个直接前驱和一个直接后继的关系
- 树也只能有一个直接前驱也就是父节点
- 当我们需要表示多对多的关系时， 这里我们就用到了图。
2.图的举例说明
图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。 结点也可以称为顶点。就像地铁线之间都有相交关联的关系。
3.图的常用概念
顶点、边、路径、无向图、有向图、带权图
4.图的表示方式
邻接矩阵(二维数组)和邻接表(链表)
4.1邻接矩阵
邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于 n 个顶点的图而言，矩阵是的 row 和 col 表示的是 1…n个点，有点像稀疏数组。矩阵中0表示未联通，1表示联通。
4.2邻接表
- 邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在,会造成空间的一定损失
- 邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表。有点像HashTable]
说明：最前面的012345指的是节点，其后面跟的就是与该节点直接相关的节点(即有连线)，箭头并不是指向关系。
二、图的遍历
1.图的深度优先遍历(DST)
图的深度优先搜索(Depth First Search)
- 深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。
- 我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。
- 显然，深度优先搜索是一个递归的过程
2.图的深度优先遍历算法实现
- 访问初始结点 v，并标记结点 v 为已访问。
- 查找结点 v 的第一个邻接结点 w。
- 若 w 存在，则继续执行 4，如果 w 不存在，则回到第 1 步，将从 v 的下一个结点继续。
- 若 w 未被访问，对 w 进行深度优先遍历递归（即把 w 当做另一个 v，然后进行步骤 123）。
- 查找结点 v 的 w 邻接结点的下一个邻接结点，转到步骤 3。
3.图的深度优先遍历代码实现
图结构的基本方法:
public class Graph {
private ArrayList<String> vertexList; //存储顶点集合
private int[][] edges; //存储图对应的邻结矩阵
private int numOfEdges; //表示边的数目
//定义给数组boolean[], 记录某个结点是否被访问
private boolean[] isVisited;
//构造器
public Graph(int n) {
//初始化矩阵和vertexList
edges = new int[n][n];
vertexList = new ArrayList<String>(n);
numOfEdges = 0;
}
//图中常用的方法
//返回结点的个数
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++;
}
}
获取邻接节点下标以及邻接节点的邻接节点的下标：
//得到第一个邻接结点的下标 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;
}
说明：
深度优先遍历：
//深度优先遍历算法，对一个节点进行深度优先遍历
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);
}
}
}
4.图的广度优先遍历
图的广度优先搜索(Broad First Search)
类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点
5.图的广度优先遍历算法步骤
- 访问初始结点 v 并标记结点 v 为已访问。
- 结点 v 入队列
- 当队列非空时，继续执行，否则算法结束。
- 出队列，取得队头结点 u。
- 查找结点 u 的第一个邻接结点 w。
- 若结点 u 的邻接结点 w 不存在，则转到步骤 3；否则循环执行以下三个步骤：
6.1 若结点 w 尚未被访问，则访问结点 w 并标记为已访问。
6.2 结点 w 入队列
6.3 查找结点 u 的继 w 邻接结点后的下一个邻接结点 w，转到步骤 6。
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);
}
}
}
7.图的深度优先 VS 广度优先
由图可知，顾名思义，深度优先遍历，即以深度为主，先向下遍历。广度优先遍历，即以广度为主，先遍历每一层，逐层深入遍历。
第四章 常用十大算法
一、二分查找算法(非递归)
- 前面我们讲过了二分查找算法，是使用递归的方式，下面我们讲解二分查找算法的非递归方式
- 二分查找法只适用于从有序的数列中进行查找(比如数字和字母等)，将数列排序后再进行查找
- 二分查找法的运行时间为对数时间 O(㏒₂n) ，即查找到需要的目标位置最多只需要㏒₂n
代码实现：
//二分查找的非递归实现
/**
*
* @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;
}
二、分治算法
1.分治算法的理解
分治算法在每一层递归上都有三个步骤：
- 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题
- 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题
- 合并：将各个子问题的解合并为原问题的解
2.分治算法之汉诺塔的实现
代码实现：
public class Hanoitower {
public static void main(String[] args) {
hanoiTower(5, 'A', 'B', 'C');
}
//汉诺塔的移动的方法
//使用分治算法
public static void hanoiTower(int num, char from, char buffer, char to) {
//如果只有一个盘
if(num == 1) {
System.out.println("第1个盘从 " + from + "->" + to);
} else {
//如果我们有 n >= 2 情况，我们总是可以看做是两个盘 1.最下边的一个盘 2. 上面的所有盘
//1. 先把 最上面的所有盘 A->B， 移动过程会使用到 c
hanoiTower(num - 1, from, to, buffer);
//2. 把最下边的盘 A->C
System.out.println("第" + num + "个盘从 " + a + "->" + c);
//3. 把B塔的所有盘 从 B->C , 移动过程使用到 a塔
hanoiTower(num - 1, buffer, from, to);
}
}
}
对以上代码理解：
- 在声明方法的时候，确定固定位置(形参)第一个char是来源柱，第二个char是缓冲柱，第三个char是去向柱，在搬运过程中，不用的柱子就是缓冲柱
- 只有一个盘的时候，直接从来源柱(a)到去向柱©
- 现假设有两个盘子，总共三次。分别是：第1个盘从A->B，第2个盘从A->C，第1个盘从B->C
- 由于
num = 2；直接进入else，此时注意第一个回溯解决了第一步和第二步，虽然解决了两步，但是要按照第一部的处理方法来写回溯，即第1个盘从A->B，所以A是来源柱，B是去向柱，C是缓冲柱，则hanoiTower(num - 1, from, to, buffer); - 最后一条代码
hanoiTower(num - 1, buffer, from, to);指的是最后一步，即第1个盘从B->C，A是缓冲柱，B是来源柱，C是去向柱
3.汉诺塔递归的理解
递归当然只能以递归的思路理解，递归思路，说白了是如下三步：
- 对于问题N，如果N-1已经解决了，那么N是否很容易解决。那么：如果前N-1层可以找别人搞定，咱只管搬第N层，会不会变得非常容易？你看，这一下就简单了：这时当它只有两层就好了，先把前N-1层看作一个整体，把它搬到B；然后把最下面的第N层搬到C；然后再把前N-1层从B搬到C。类似的，假如接到“搬前N-1层”这个任务的是我们，怎么搬呢？简单，像前东家一样，把前N-2层外包出去，我们只搬第N-1层——其实和前面讨论过的“外包N-1层，只搬第N层”完全一样嘛。依此类推，一层层“外包”下去——我不管你们有多伤脑筋，反正只要你们把我外包给你的活干了，我就能干了我的活！注意，这里千万别管“接到外包工作的家伙有多伤脑筋”——丢给他就让他头疼去，我们就别再捡回来痛苦自己了。这一步就是“递推”。注意这里的搬法：搬第N层，就需要把前N-1层搬两次，另外再把第N层搬一次；搬第N-1层，又需要把前N-2层搬两次，然后再把N-1层搬一次，依此类推。很容易知道，一共需要搬2^N-1次。
- 一步步递推下去，终究会有个“包工头”，接到“搬第一层”的任务。第一层怎么搬？太简单了，让搬哪搬哪。换句话说，到此，“递推”就到了极限，简单粗暴直接做就可以了。
- 既然第一层搬了，那么第二层当然就可以搬了；第二层搬了，第三层又可以搬了……依次类推，直到第N层。于是问题搞定。这一步就是“回归”。如上三步加起来，就是“递归”。推而广之，任何问题，不管规模为N时有多复杂，只要把N-1那块“外包”给别人做之后，我们在这个基础上可以轻易完成N，那么它很可能就适合用“递归”解决。那么，怎么最终确定它能不能用“递归”做呢？看当N取1或2之类最简情况时，问题是否可以解决——然后写程序解决它。容易看出，“递归”其实和“数学归纳法”的思路非常像：证明N=1时成立；证明若N=n-1成立，则N=n时也成立；如上两步得证，则命题在n>1时一定成立（n为自然数）。你看，我们没必要从1开始逐一验证每个自然数，只要证明了“基础条件”、再证明了“递推条件”，大自然的规律会帮我们搞定一切。
- 对递归的理解的要点主要在于放弃!放弃你对于理解和跟踪递归全程的企图，只理解递归两层之间的交接，以及递归终结的条件。
685
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
