數據結構與算法| 隊列| 排序| 查找| 二叉樹| 哈希表

時間 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()

  }
}