数据结构与算法| 队列| 排序| 查找| 二叉树| 哈希表

时间 2019-12-10

标签数据结构算法队列排序查找二叉树哈希栏目应用数学繁體版

原文原文链接

递归(recursion)的概念

简单的说:递归就是函数/方法本身调用本身,每次调用时传入不一样的变量.递归有助于编程者解决复杂的问题,同时可让代码变得简洁。java

递归快速入门程序员

我列举两个小案例,来帮助你们理解递归，递归在讲函数时已经讲过(当时讲的相对比较简单)，这里在给你们回顾一下递归调用机制算法

1) 打印问题数据库

2) 阶乘问题编程

举一个比较综合的案例,迷宫(maze)问题数组

说明:tomcat

1) 小球获得的路径，和程序员设置的找路策略有关即：找路的上下左右的顺序相关再获得小球路径时，能够先使用(下右上左)，再改为(上右下左)，看看路径是否是有变化数据结构

2) 测试回溯现象app

3) 思考: 如何求出最短路径?dom

4) 分析和代码

object MiGong {
  def main(args: Array[String]): Unit = {
    //使用二维数组模拟地图 map[8][7]
    val map = Array.ofDim[Int](8, 7)
    //给map初始化，使用1 表示墙

    //上下行设置1
    for (i <- 0 until 7) {
      map(0)(i) = 1
      map(7)(i) = 1
    }

    //左右设置为1
    for (i <- 0 until 8) {
      map(i)(0) = 1
      map(i)(6) = 1
    }
    //设置墙
    map(3)(1) = 1
    map(3)(2) = 1

    //验证看看当前地图是否
    for (row <- map) {
      for (ele <- row) {
        print(ele + " ")
      }
      println()
    }
    println()

    //测试迷宫
    setWay2(map, 1, 1)

    //看看迷宫的状况
    println("小球找路的结果:")
    for (row <- map) {
      for (ele <- row) {
        print(ele + " ")
      }
      println()
    }
    println()
  }

  //编写方法完成探路
  /**
    *
    * @param map 地图
    * @param i   表示当前探测点横坐标
    * @param j   表示当前探测点纵坐标
    * @return
    */
  def setWay(map: Array[Array[Int]], i: Int, j: Int): Boolean = {
    //若是map[6][5] == 2
    if (map(6)(5) == 2) { //找到通路
      return true
    } else {
      //找在地图中，使用1 表示墙，0 表示没有走过, 2 表示通路，3  表示该点已经探测过，可是走不通，死路
      if(map(i)(j) == 0) {
        //假定map(i)(j) 能够走通，实际不必定
        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, 则map(i)(j) 1 2 3
        return  false
      }
    }
  }

  def setWay2(map: Array[Array[Int]], i: Int, j: Int): Boolean = {
    //若是map[6][5] == 2
    if (map(6)(5) == 2) { //找到通路
      return true
    } else {
      //找在地图中，使用1 表示墙，0 表示没有走过, 2 表示通路，3  表示该点已经探测过，可是走不通，死路
      if(map(i)(j) == 0) {
        //假定map(i)(j) 能够走通，实际不必定
        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 { //map(i)(j) != 0, 则map(i)(j) 1 2 3
        return  false
      }
    }
  }
}

View Code

排序

是将一组数据，依指定的顺序进行排列的过程, 常见的排序：

//时间复杂度

//思路=》推导

1) 冒泡排序

2) 选择排序

3) 插入排序

4) 快速排序

5) 归并排序

1.冒泡排序

冒泡排序（Bubble Sorting）的基本思想是：经过对待排序序列从后向前（从下标较大的元素开始）,依次比较相邻元素的排序码，若发现逆序则交换，使排序码较小

的元素逐渐从后部移向前部（从下标较大的单元移向下

标较小的单元），就象水底下的气泡同样逐渐向上冒。

冒泡排序算法的分析

冒泡代码实现：

import java.text.SimpleDateFormat
import java.util.Date
import util.control.Breaks._

object BubbleSort {
  def main(args: Array[String]): Unit = {
    //o(n^2)
    //val arr = Array(3, 9, -1, 10, 2) // 80000
    //建立一个80000个随机数据的数组
    val random = new util.Random()
    val arr = new Array[Int](80000)
    for (i <- 0 until 80000) {
      arr(i) = random.nextInt(8000000) //范围[0,8000000)
    }
    println("排序前")
    val now: Date = new Date()
    val dateFormat: SimpleDateFormat =
      new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
    val date = dateFormat.format(now)
    println("排序前时间=" + date) //输出时间

    //测试一下时间

    bubbleSort(arr)

    val now2: Date = new Date()
    val date2 = dateFormat.format(now2)
    println("排序前时间=" + date2) //输出时间


  }

  def bubbleSort(arr: Array[Int]): Unit = {

    //由于1,2,3,4， 轮几乎同样，咱们使用for循环嵌套即
    //对冒泡优化
    //思路
    //1. 若是咱们发现数组已是一个有序的了，则能够提早退出排序
    //2. 定义一个标识符 flag ,若是在1轮排序，一次交换都没有发生，说明数组已经有序
    var temp = 0
    var flag = false

    breakable {
      for (i <- 0 until arr.length - 1) {
        for (j <- 0 until arr.length - 1 - i) {
          if (arr(j) > arr(j + 1)) {
            flag = true
            temp = arr(j)
            arr(j) = arr(j + 1)
            arr(j + 1) = temp
          }
        }
        if (!flag) {
          break()
        } else {
          flag = false //下一轮，重写设置false
        }
        //println("第"+(i+1)+"轮的排序" + arr.mkString(","))
      }
    }

    /*
    第1轮 =>         将最大数，移动数组的最后
  (1)  3, 9, -1, 10, 2
  (2)  3, -1,9,10,2
  (3)  3, -1,9,10,2
  (4) 3, -1,9,2,10

     */
    /*
    var temp = 0
    for (j <- 0 until arr.length - 1 - 0) {
      if (arr(j) > arr(j + 1)) {
        temp = arr(j)
        arr(j) = arr(j + 1)
        arr(j + 1) = temp
      }
    }
    println("第l轮的排序" + arr.mkString(","))

    //第二轮
    for (j <- 0 until arr.length - 1 - 1) {
      if (arr(j) > arr(j + 1)) {
        temp = arr(j)
        arr(j) = arr(j + 1)
        arr(j + 1) = temp
      }
    }
    println("第2轮的排序" + arr.mkString(","))

    //第3轮
    for (j <- 0 until arr.length - 1 - 2) {
      if (arr(j) > arr(j + 1)) {
        temp = arr(j)
        arr(j) = arr(j + 1)
        arr(j + 1) = temp
      }
    }
    println("第3轮的排序" + arr.mkString(","))

    //第4轮
    for (j <- 0 until arr.length - 1 - 3) {
      if (arr(j) > arr(j + 1)) {
        temp = arr(j)
        arr(j) = arr(j + 1)
        arr(j + 1) = temp
      }
    }
    println("第4轮的排序" + arr.mkString(","))*/

  }
}

View Code

2. 插入排序法介绍:

插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。

插入排序法思想：

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

插入排序的思路图解

代码实现和推导过程

import java.text.SimpleDateFormat
import java.util.Date

object InsertSort {
  def main(args: Array[String]): Unit = {
    //val arr = Array(101, 34, 119, 1)
    val random = new util.Random()
    val arr = new Array[Int](800000)
    for (i <- 0 until 800000) {
      arr(i) = random.nextInt(8000000) //范围[0,8000000)
    }
    println("排序前")
    val now: Date = new Date()
    val dateFormat: SimpleDateFormat =
      new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
    val date = dateFormat.format(now)
    println("排序前时间=" + date) //输出时间
    println("插入排序")

    insertSort(arr) //插入排序

    val now2: Date = new Date()
    val date2 = dateFormat.format(now2)
    println("排序前时间=" + date2) //输出时间
  }

  //插入排序
  def insertSort(arr: Array[Int]): Unit = {

    var insertVal = 0
    var index = 0
    //使用for循环来完成
    for(i <- 1 until arr.length) {
      insertVal = arr(i)
      index = i - 1
      //说明
      //若是index >=0 比较 insertVal 和  arr(index)关系
      //insertVal < arr(index) 知足，说明尚未找到位置
      while (index >= 0 && (insertVal < arr(index))) {
        //让arr(index) 后移
        arr(index+1) = arr(index)
        index -= 1
      }
      arr(index+1) = insertVal
      //println("arr 第"+i+"轮" + arr.mkString(","))
    }


    //完成第1轮的排序(给 34)找位置
    //思路
    //1. 先 34 保存到一个变量
    //2  用一个变量保存 34的元素的前一个下标

    /*
    var insertVal = arr(1)
    var index = 1 - 1
    //说明
    //若是index >=0 比较 insertVal 和  arr(index)关系
    //insertVal < arr(index) 知足，说明尚未找到位置
    while (index >= 0 && (insertVal < arr(index))) {
      //让arr(index) 后移
      arr(index+1) = arr(index)
      index -= 1
    }
    arr(index+1) = insertVal
    println("arr 第1轮" + arr.mkString(","))

    //第2轮
    insertVal = arr(2)
    index = 2 - 1
    while (index >= 0 && (insertVal < arr(index))) {
      //让arr(index) 后移
      arr(index+1) = arr(index)
      index -= 1
    }
    arr(index+1) = insertVal
    println("arr 第2轮" + arr.mkString(","))

    //第3轮
    insertVal = arr(3)
    index = 3 - 1
    while (index >= 0 && (insertVal < arr(index))) {
      //让arr(index) 后移
      arr(index+1) = arr(index)
      index -= 1
    }
    arr(index+1) = insertVal
    println("arr 第3轮" + arr.mkString(","))*/

  }


}

View Code

3. 归并排序介绍:

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题而后递归求解，而治(conquer)的阶段则将分的阶段获得的各答案"修补"在一块儿，即分而治之)。

归并排序思想示意图1-基本思想:

能够看到这种结构很像一棵彻底二叉树，本文的归并排序咱们采用递归去实现（也可采用迭代的方式去实现）。分阶段能够理解为就是递归拆分子序列的过程。

归并排序思想示意图2-合并相邻有序子序列:

再来看看治阶段，咱们须要将两个已经有序的子序列合并成一个有序序列，好比上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤

代码实现

import java.text.SimpleDateFormat
import java.util.Date

object MergeSort {
  def main(args: Array[String]): Unit = {
    //val arr = Array(8, 4, 5, 7, 1, 3, 6, 2,-1)

    val random = new util.Random()
    val arr = new Array[Int](8000000)
    for (i <- 0 until 8000000) {
      arr(i) = random.nextInt(8000000) //范围[0,8000000)
    }
    println("排序前")
    val now: Date = new Date()
    val dateFormat: SimpleDateFormat =
      new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
    val date = dateFormat.format(now)
    println("排序前时间=" + date) //输出时间
    println("归并排序")

    val temp = new Array[Int](arr.length)
    mergeSort(arr,0,arr.length-1,temp)

    val now2: Date = new Date()
    val date2 = dateFormat.format(now2)
    println("排序前时间=" + date2) //输出时间

    //println("排序后"+arr.mkString(","))

  }

  def mergeSort(arr: Array[Int],left:Int,right :Int,temp:Array[Int]): Unit = {
    if(left<right){
      val 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  //作中转的数组
    */
  def merge(arr: Array[Int], left: Int, mid: Int, right: Int, temp: Array[Int]) {
    var i = left //初始化i
    var j = mid + 1 //初始j
    var t = 0 // 指向temp数组的当前索引

    //将左右两边有序数列安，从小到大的顺序拷贝到temp数组中
    while (i <= mid && j <= right) {
      //若是左边的有序数列的当前元素，小于右边的有序数列的当前元素
      //则将arr(i) 拷贝temp
      if (arr(i) <= arr(j)) {
        temp(t) = arr(i)
        t += 1
        i += 1
      } else { //将 arr(j) 拷贝到temp
        temp(t) = arr(j)
        t += 1
        j += 1
      }
    }

    //若是左边的有序数列有剩余，的依次拷贝到temp
    while (i <= mid) {
      temp(t) = arr(i)
      t += 1
      i += 1
    }
    //若是右边的有序数列有剩余，的依次拷贝到temp
    while (j <= right) {
      temp(t) = arr(j)
      t += 1
      j += 1
    }
    t = 0
    var tempLeft = left
    //是把temp 数组的元素拷贝到 arr
    while (tempLeft <= right) {
      arr(tempLeft) = temp(t)
      t += 1
      tempLeft += 1
    }
  }

}

View Code

4. 快排

代码实现

def quickSort(left: Int, right: Int, arr: Array[Int]): Unit = {

    var l: Int = left
    var r: Int = right
    var pivot = arr((left + right) / 2)
    var temp = 0

    //Array(10, 11, 2, -1, 3)
    breakable {
      while (l < r) {

//从左点向右遍历，直到找到比中间值大的
        while (arr(l) < pivot) {
          l += 1
        }

//从右点向左遍历，直到找到比中间值小的
        while (arr(r) > pivot) {
          r -= 1
        }

//判断是否已经越过中间值
        if (l >= r) {
          break()
        }

         //交换数据
        temp = arr(l)
        arr(l) = arr(r)
        arr(r) = temp
      }
    }

    if (l == r) {
      l += 1
      r -= 1
    }

    //向左递归
    if (left < r) {
      quickSort(left, r, arr)
    }

    //向右递归
    if (right > l) {
      quickSort(l, right, arr)
    }

}

View Code

查找

介绍：

在java中，咱们经常使用的查找有两种:

1) 顺序(线性)查找

2) 二分查找

线性查找

有一个数列： {1,8, 10, 89, 1000, 1234} ，判断数列中是否包含此名称【顺序查找】要求: 若是找到了，就提示找到，并给出下标值。

object OrderSearch {
  def main(args: Array[String]): Unit = {
    val arr = Array(1,8, 10, 89, 89,1000, 1234)
    val index = orderFind(arr, 89)
    if (index == -1) {
      println("没有查找到~")
    } else {
      println("找到，下标为=" + index)
    }
  }
  def orderFind(arr: Array[Int], value: Int): Int = {
    for (i <- 0 until arr.length) {
      if (arr(i) == value) {
        return i
      }
    }
    -1
  }
}

View Code

二分查找：

请对一个有序数组进行二分查找 {1,8, 10, 89, 1000, 1234} ，输入一个数看看该数组是否存在此数，而且求出下标，若是没有就提示"没有这个数"。

课后思考题1： {1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中，有多个相同的数值时，如何将全部的数值都查找到，好比这里的 1000.

import scala.collection.mutable.ArrayBuffer
import util.control.Breaks._

object BinarySearch {
  def main(args: Array[String]): Unit = {

    val arr = Array(1, 8, 10, 89, 1000, 1000, 1000,1000,1000)
    //binarySearch(arr,0,arr.length -1, 1000)
    val resIndexBuffer = binarySearch2(arr, 0, arr.length - 1, 1000)
    println("结果是=" + resIndexBuffer)

    //要求：
    /*
    课后思考题1： {1,8, 10, 89, 1000, 1000，1234}
    当一个有序数组中，有多个相同的数值时，如何将全部的数值对应下标都查找到，好比这里的 1000.

     */


  }

  //使用二分查找，须要将全部数都找到
  def binarySearch2(arr: Array[Int], leftIndex: Int, rightIndex: Int, findVal: Int): ArrayBuffer[Int] = {
    //判断何时是找不到
    if (rightIndex < leftIndex) {
      return ArrayBuffer() //若是没有找到，就返回ArrayBuffer大小=0
    }


    //获得中间的mid
    val midIndex = (leftIndex + rightIndex) / 2
    val midVal = arr(midIndex)

    //比较
    if (midVal > findVal) { //向左递归查找
      return binarySearch2(arr, leftIndex, midIndex - 1, findVal)
    } else if (midVal < findVal) { //向右递归查找
      return binarySearch2(arr, midIndex + 1, rightIndex, findVal)
    } else {
      //思路，当咱们找到midIndex时，须要在midIndex 左右两边扫描，将知足条件的下标
      //所有放入到ArrayBuffer
      val resIndexBuffer = new ArrayBuffer[Int]()
      //向左
      var temp = midIndex - 1
      breakable {
        while (true) {
          //若是 temp < 0 已经把左边所有扫描完毕
          // arr(temp) != findVal: 在向左扫描过程当中，一旦发现有一个元素不等于 findVal，就退出
          if (temp < 0 || arr(temp) != findVal) {
            break()
          }
          resIndexBuffer.append(temp)
          temp -= 1
        }
      }
      resIndexBuffer.append(midIndex) //加入中间索引
      //向右
      temp = midIndex + 1
      breakable {
        while (true) {
          //若是 temp > arr.length - 1 已经把右边所有扫描完毕
          // arr(temp) != findVal: 在向左扫描过程当中，一旦发现有一个元素不等于 findVal，就退出
          if (temp > arr.length - 1 || arr(temp) != findVal) {
            break()
          }
          resIndexBuffer.append(temp)
          temp += 1
        }
      }
      return resIndexBuffer

    }
  }

  //使用递归的方式，编写二分查找
  /**
    *
    * @param arr        待查找的数组
    * @param leftIndex  数组左边的索引
    * @param rightIndex 数组右边的索引
    * @param findVal    你要查找的数
    */
  def binarySearch(arr: Array[Int], leftIndex: Int, rightIndex: Int, findVal: Int): Unit = {

    //判断何时是找不到
    if (rightIndex < leftIndex) {
      println("找不到")
      return
    }


    //获得中间的mid
    val midIndex = (leftIndex + rightIndex) / 2
    val midVal = arr(midIndex)

    //比较
    if (midVal > findVal) { //向左递归查找
      binarySearch(arr, leftIndex, midIndex - 1, findVal)
    } else if (midVal < findVal) { //向右递归查找
      binarySearch(arr, midIndex + 1, rightIndex, findVal)
    } else {
      println("找到了 索引为=" + midIndex)


    }

  }
}

View Code

二叉树概念

二叉树是一种很是重要的数据结构，它同时具备数组和链表各自的特色：它能够像数组同样快速查找，也能够像链表同样快速添加。可是他也有本身的缺点：删除操做复杂。

二叉树：是每一个节点最多有两个子树的有序树，在使用二叉树的时候，数据并非随便插入到节点中的，一个节点的左子节点的关键值必须小于此节点，右子节点的关键值必须大于或者是等于此节点，因此又称二叉查找树、二叉排序树、二叉搜索树。

彻底二叉树：若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，而且叶子结点都是从左到右依次排布，这就是彻底二叉树。

满二叉树——除了叶结点外每个结点都有左右子叶且叶子结点都处在最底层的二叉树。

深度——二叉树的层数，就是深度。

二叉树的特色

1）树执行查找、删除、插入的时间复杂度都是O(logN)

2）遍历二叉树的方法包括前序、中序、后序

3）非平衡树指的是根的左右两边的子节点的数量不一致

4）在非空二叉树中，第i层的结点总数不超过 , i>=1；

5）深度为h的二叉树最多有个结点(h>=1)，最少有h个结点；

6）对于任意一棵二叉树，若是其叶结点数为N0，而度数为2的结点总数为N2，则N0=N2+1；

二叉树的Java代码实现

首先是树的节点的定义，下面的代码中使用的是最简单的int基本数据类型做为节点的数据，若是要使用节点带有更加复杂的数据类型，换成对应的对象便可。

public class TreeNode {

 // 左节点
 private TreeNode lefTreeNode;
 // 右节点
 private TreeNode rightNode;
 // 数据
 private int value;

 private boolean isDelete;

 public TreeNode getLefTreeNode() {
  return lefTreeNode;
 }

 public void setLefTreeNode(TreeNode lefTreeNode) {
  this.lefTreeNode = lefTreeNode;
 }

 public TreeNode getRightNode() {
  return rightNode;
 }

 public void setRightNode(TreeNode rightNode) {
  this.rightNode = rightNode;
 }

 public int getValue() {
  return value;
 }

 public void setValue(int value) {
  this.value = value;
 }

 public boolean isDelete() {
  return isDelete;
 }

 public void setDelete(boolean isDelete) {
  this.isDelete = isDelete;
 }

 public TreeNode() {
  super();
 }

 public TreeNode(int value) {
  this(null, null, value, false);
 }

 public TreeNode(TreeNode lefTreeNode, TreeNode rightNode, int value,
   boolean isDelete) {
  super();
  this.lefTreeNode = lefTreeNode;
  this.rightNode = rightNode;
  this.value = value;
  this.isDelete = isDelete;
 }

 @Override
 public String toString() {
  return "TreeNode [lefTreeNode=" + lefTreeNode + ", rightNode="
    + rightNode + ", value=" + value + ", isDelete=" + isDelete
    + "]";
 }

}
下面给出二叉树的代码实现。因为在二叉树中进行节点的删除很是繁琐，所以，下面的代码使用的是利用节点的isDelete字段对节点的状态进行标识
public class BinaryTree {

 // 根节点
 private TreeNode root;

 public TreeNode getRoot() {
  return root;
 }

 /**
  * 插入操做
  * 
  * @param value
  */
 public void insert(int value) {

  TreeNode newNode = new TreeNode(value);

  if (root == null) {
   root = newNode;
   root.setLefTreeNode(null);
   root.setRightNode(null);
  } else {

   TreeNode currentNode = root;
   TreeNode parentNode;

   while (true) {

    parentNode = currentNode;
    // 往右放
if (newNode.getValue() > currentNode.getValue()) {

     currentNode = currentNode.getRightNode();

     if (currentNode == null) {
      parentNode.setRightNode(newNode);
      return;
     }
    } else {
     // 往左放
     currentNode = currentNode.getLefTreeNode();

     if (currentNode == null) {
      parentNode.setLefTreeNode(newNode);
      return;
     }
    }
   }
  }
 }

 /**
  * 查找
  * 
  * @param key
  * @return
  */
 public TreeNode find(int key) {

  TreeNode currentNode = root;

  if (currentNode != null) {

   while (currentNode.getValue() != key) {

    if (currentNode.getValue() > key) {
     currentNode = currentNode.getLefTreeNode();
    } else {
     currentNode = currentNode.getRightNode();
    }

    if (currentNode == null) {
     return null;
}

   }

   if (currentNode.isDelete()) {
    return null;
   } else {
    return currentNode;
   }

  } else {
   return null;
  }
 }

 /**
  * 中序遍历
  * 
  * @param treeNode
  */
 public void inOrder(TreeNode treeNode) {

  if (treeNode != null && treeNode.isDelete() == false) {

   inOrder(treeNode.getLefTreeNode());

   System.out.println("--" + treeNode.getValue());

   inOrder(treeNode.getRightNode());
  }
 }
}

View Code

在上面对二叉树的遍历操做中，使用的是中序遍历，这样遍历出来的数据是增序的。

下面是测试代码：

public class Main {

 public static void main(String[] args) {

  BinaryTree tree = new BinaryTree();

  // 添加数据测试
  tree.insert(10);
  tree.insert(40);
  tree.insert(20);
  tree.insert(3);
  tree.insert(49);
  tree.insert(13);
  tree.insert(123);

  System.out.println("root=" + tree.getRoot().getValue());

  // 排序测试
  tree.inOrder(tree.getRoot());

  // 查找测试
  if (tree.find(10) != null) {
   System.out.println("找到了");
  } else {
   System.out.println("没找到");
  }

  // 删除测试
  tree.find(40).setDelete(true);

  if (tree.find(40) != null) {
   System.out.println("找到了");
  } else {
   System.out.println("没找到");
  }
 }
}

View Code

哈希表(散列)

哈希表的基本介绍

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

应用实例

google公司的一个上机题:

有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,住址..),当输入该员工的id时,要求查找到该员工的全部信息.

要求:

1) 不使用数据库,,速度越快越好=>哈希表(散列)

2) 添加时，保证按照id从低到高插入 [课后思考：若是id不是从低到高插入，但要求各条链表还是从低到高，怎么解决?]

3) 使用链表来实现哈希表, 该链表不带表头
[即: 链表的第一个结点就存放雇员信息]

4) 思路分析并画出示意图

1) 代码实现[增删改查(显示全部员工，按id查询)]

import util.control.Breaks._
object HashTableDemo {
  def main(args: Array[String]): Unit = {
    val emp1 = new Emp(1,"tom")
    val emp2 = new Emp(2,"mary")
    val emp3 = new Emp(3,"smith")
    val emp4 = new Emp(4,"terry")
    val emp5 = new Emp(5,"tomcat")
    val emp6 = new Emp(11,"king")

    //建立HashTable
    val hashTable = new HashTable(7)
    hashTable.addEmp(emp1)
    hashTable.addEmp(emp2)
    hashTable.addEmp(emp3)
    hashTable.addEmp(emp4)
    hashTable.addEmp(emp5)
    hashTable.addEmp(emp6)

    //显示
    hashTable.list()

    //测试查找
    val emp = hashTable.findByNo(111)
    if(emp != null) {
      printf("找到了" + emp.no + " " + emp.name )
    } else {
      println("没有找到")
    }
  }
}


//建立HashTable , 管理7条链表
class HashTable(size:Int) {
  val linkedArr: Array[EmpLinkedList] = new Array[EmpLinkedList](size)
  //将 linkedArr 数组中的每个链表对象，再new
  for(i <- 0 until linkedArr.length ) {
    linkedArr(i) = new EmpLinkedList()
  }

  //查找
  def findByNo(no:Int): Emp = {
    //先肯定到哪条链表去查找
    println("在" + hash(no) + "去找雇员")
    return linkedArr(hash(no)).findByNO(no)
  }

  //添加方法， 由 HashTable 来经过哈希获得应该加入的链表
  def addEmp(emp: Emp): Unit = {
    val linkedListNO = hash(emp.no)//散列
    linkedArr(linkedListNO).add(emp)
  }
  //遍历整个哈希表
  def list(): Unit = {
    for(i <- 0 until linkedArr.length) {
      linkedArr(i).list(hash(i))
      println()
    }
  }

  /**
    *
    * @param no 传入雇员的no
    * @return 返回该雇员应该加入到哪一个链表中
    */
  def hash(no:Int): Int = {
    no % size
  }
}

//建立Emp 类，表示雇员
class Emp(eNo: Int, eName: String) {
  val no = eNo
  var name = eName
  var next: Emp = null
}

//建立EmpLinkedList 存放Emp的单链表
class EmpLinkedList {
  var head: Emp = null//链表头
  //添加
  def add(emp: Emp): Unit = {
    if(head == null) { //添加的第一个Emp
      head = emp
    } else {
      //使用辅助指针完成添加, 简单处理直接加入到链表的最后
      var curEmp = head
      while (curEmp.next != null) {
        curEmp = curEmp.next
      }
      //退出while后curEmp就指向最后
      curEmp.next = emp
    }
  }

  //查找
  //若是找到返回 Emp对象，没有则返回null
  def findByNO(no:Int): Emp = {
    if(head==null) {
      println("空链表")
      return null
    }
    var curEmp = head

    breakable {
      while (true) {
        if (curEmp.no == no) {
          //找到
          break() //这时curEmp就是你要找到Emp
        }
        if (curEmp.next == null) {
          //这时curEmp就是是最后
          curEmp = null
        }

        curEmp = curEmp.next
      }
    }

    return curEmp
  }

  //遍历
  def list(linkedListNO:Int): Unit = {
    //判断链表是否为空
    if(head == null) {
      println("第"+linkedListNO+"链表为空")
      return
    }
    var curEmp = head
    print("第"+linkedListNO+"链表雇员 : ")
    while(curEmp != null) {
      //输出curEmp信息
      printf("雇员的信息 no=%d name = %s => ", curEmp.no, curEmp.name)
      curEmp = curEmp.next
    }
    println()

  }
}

View Code