数据结构及算法(数据结构篇)

工作之余b站充电

视频链接：https://www.bilibili.com/video/BV1iJ411E7xW?from=search&seid=11746233105888556082

一、线性表

线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。

前驱元素：

若A元素在B元素的前面，则称A为B的前驱元素

后继元素：

若B元素在A元素的后面，则称B为A的后继元素

线性表的特征：数据元素之间具有一种“一对一”的逻辑关系。

1. 第一个数据元素没有前驱，这个数据元素被称为头结点；

2. 最后一个数据元素没有后继，这个数据元素被称为尾结点；

3. 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继。

如果把线性表用数学语言来定义，则可以表示为(a1,...ai-1,ai,ai+1,...an)，ai-1领先于ai,ai领先于ai+1，称ai-1是ai的

前驱元素，ai+1是ai的后继元素

线性表的分类：

线性表中数据存储的方式可以是顺序存储，也可以是链式存储，按照数据的存储方式不同，可以把线性表分为顺序

表和链表。

1.1 顺序表

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存

储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元

素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。

1.1.1 顺序表的实现

顺序表API设计：

顺序表的代码实现：

顺序表的代码实现：
//顺序表代码
public class SequenceList<T> {
    //存储元素的数组
    private T[] eles;
    //记录当前顺序表中的元素个数
    private int N;
    //构造方法
    public SequenceList(int capacity){
        eles = (T[])new Object[capacity];
        N=0;
    }
    //将一个线性表置为空表
    public void clear(){
        N=0;
    }
    //判断当前线性表是否为空表
    public boolean isEmpty(){
        return N==0;
    }
    //获取线性表的长度
    public int length(){
        return N;
    }
    //获取指定位置的元素
    public T get(int i){
        if (i<0 || i>=N){
            throw new RuntimeException("当前元素不存在！");
        }
        return eles[i];
    }
    //向线型表中添加元素t
    public void insert(T t){
        if (N==eles.length){
            throw new RuntimeException("当前表已满");
        }
        eles[N++] = t;
    }
    //在i元素处插入元素t
    public void insert(int i,T t){
        if (i==eles.length){
            throw new RuntimeException("当前表已满");
        }
        if (i<0 || i>N){
            throw new RuntimeException("插入的位置不合法");
        }
//把i位置空出来，i位置及其后面的元素依次向后移动一位
        for (int index=N;index>i;index--){
            eles[index]=eles[index-1];
        }
//把t放到i位置处
        eles[i]=t;
//元素数量+1
        N++;
    }
    //删除指定位置i处的元素，并返回该元素
    public T remove(int i){
        if (i<0 || i>N-1){
            throw new RuntimeException("当前要删除的元素不存在");
        }
//记录i位置处的元素
        T result = eles[i];
//把i位置后面的元素都向前移动一位

        1.1.2 顺序表的遍历
        一般作为容器存储数据，都需要向外部提供遍历的方式，因此我们需要给顺序表提供遍历方式。
        for (int index=i;index<N-1;index++){
            eles[index]=eles[index+1];
        }
//当前元素数量-1
        N--;
        return result;
    }
    //查找t元素第一次出现的位置
    public int indexOf(T t){
        if(t==null){
            throw new RuntimeException("查找的元素不合法");
        }
        for (int i = 0; i < N; i++) {
            if (eles[i].equals(t)){
                return i;
            }
        }
        return -1;
    }
}
//测试代码
public class SequenceListTest {
    public static void main(String[] args) {
//创建顺序表对象
        SequenceList<String> sl = new SequenceList<>(10);
//测试插入
        sl.insert("姚明");
        sl.insert("科比");
        sl.insert("麦迪");
        sl.insert(1,"詹姆斯");
//测试获取
        String getResult = sl.get(1);
        System.out.println("获取索引1处的结果为："+getResult);
//测试删除
        String removeResult = sl.remove(0);
        System.out.println("删除的元素是："+removeResult);
//测试清空
        sl.clear();
        System.out.println("清空后的线性表中的元素个数为:"+sl.length());
    }
}

1.1.2 顺序表的遍历

一般作为容器存储数据，都需要向外部提供遍历的方式，因此我们需要给顺序表提供遍历方式。

在java中，遍历集合的方式一般都是用的是foreach循环，如果想让我们的SequenceList也能支持foreach循环，则

需要做如下操作：

1.让SequenceList实现Iterable接口，重写iterator方法；

2.在SequenceList内部提供一个内部类SIterator,实现Iterator接口，重写hasNext方法和next方法；

代码：

//顺序表代码

import java.util.Iterator;
public class SequenceList<T> implements Iterable<T>{
//存储元素的数组
private T[] eles;
//记录当前顺序表中的元素个数
private int N;
//构造方法
public SequenceList(int capacity){
eles = (T[])new Object[capacity];
N=0;
}
//将一个线性表置为空表
public void clear(){
N=0;
}
//判断当前线性表是否为空表
public boolean isEmpty(){
return N==0;
}
//获取线性表的长度
public int length(){
return N;
}
//获取指定位置的元素
public T get(int i){
if (i<0 || i>=N){
throw new RuntimeException("当前元素不存在！");
}
return eles[i];
}
//向线型表中添加元素t
public void insert(T t){
if (N==eles.length){
throw new RuntimeException("当前表已满");
}
eles[N++] = t;
}
//在i元素处插入元素t
public void insert(int i,T t){
if (i==eles.length){
throw new RuntimeException("当前表已满");
}
if (i<0 || i>N){
throw new RuntimeException("插入的位置不合法");
}
//把i位置空出来，i位置及其后面的元素依次向后移动一位
for (int index=N;index>i;index--){
eles[index]=eles[index-1];
}
//把t放到i位置处
eles[i]=t;
//元素数量+1
N++;
}
//删除指定位置i处的元素，并返回该元素
public T remove(int i){
if (i<0 || i>N-1){
throw new RuntimeException("当前要删除的元素不存在");
}
//记录i位置处的元素
T result = eles[i];
//把i位置后面的元素都向前移动一位
for (int index=i;index<N-1;index++){
eles[index]=eles[index+1];
}
//当前元素数量-1
N--;
return result;
}
//查找t元素第一次出现的位置
public int indexOf(T t){
if(t==null){
throw new RuntimeException("查找的元素不合法");
}
for (int i = 0; i < N; i++) {
if (eles[i].equals(t)){
return i;
}
}
return -1;
}
//打印当前线性表的元素
public void showEles(){
for (int i = 0; i < N; i++) {
System.out.print(eles[i]+" ");
}
System.out.println();
}
@Override
public Iterator iterator() {
return new SIterator();
}
private class SIterator implements Iterator{
private int cur;
public SIterator(){
this.cur=0;
}
@Override
public boolean hasNext() {
return cur<N;
}
@Override
public T next() {
return eles[cur++];
}
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
SequenceList<String> squence = new SequenceList<>(5);
//测试遍历
squence.insert(0, "姚明");
squence.insert(1, "科比");
squence.insert(2, "麦迪");
squence.insert(3, "艾佛森");
squence.insert(4, "卡特");
for (String s : squence) {
System.out.println(s);
}
}
}

1.1.3 顺序表的容量可变

在之前的实现中，当我们使用SequenceList时，先new SequenceList(5)创建一个对象，创建对象时就需要指定容

器的大小，初始化指定大小的数组来存储元素，当我们插入元素时，如果已经插入了5个元素，还要继续插入数

据，则会报错，就不能插入了。这种设计不符合容器的设计理念，因此我们在设计顺序表时，应该考虑它的容量的

伸缩性。

考虑容器的容量伸缩性，其实就是改变存储数据元素的数组的大小，那我们需要考虑什么时候需要改变数组的大

小？

1.添加元素时：

添加元素时，应该检查当前数组的大小是否能容纳新的元素，如果不能容纳，则需要创建新的容量更大的数组，我

们这里创建一个是原数组两倍容量的新数组存储元素。

2.移除元素时：

移除元素时，应该检查当前数组的大小是否太大，比如正在用100个容量的数组存储10个元素，这样就会造成内存

空间的浪费，应该创建一个容量更小的数组存储元素。如果我们发现数据元素的数量不足数组容量的1/4，则创建

一个是原数组容量的1/2的新数组存储元素。

顺序表的容量可变代码：

//顺序表代码
public class SequenceList<T> implements Iterable<T>{
//存储元素的数组
private T[] eles;
//记录当前顺序表中的元素个数
private int N;
//构造方法
public SequenceList(int capacity){
eles = (T[])new Object[capacity];
N=0;
}
//将一个线性表置为空表
public void clear(){
N=0;
}
//判断当前线性表是否为空表
public boolean isEmpty(){
return N==0;
}
//获取线性表的长度
public int length(){
return N;
}
//获取指定位置的元素
public T get(int i){
if (i<0 || i>=N){
throw new RuntimeException("当前元素不存在！");
}
return eles[i];
}
//向线型表中添加元素t
public void insert(T t){
if (N==eles.length){
resize(eles.length*2);
}
eles[N++] = t;
}
//在i元素处插入元素t
public void insert(int i,T t){
if (i<0 || i>N){
throw new RuntimeException("插入的位置不合法");
}
//元素已经放满了数组，需要扩容
if (N==eles.length){
resize(eles.length*2);
}
//把i位置空出来，i位置及其后面的元素依次向后移动一位
for (int index=N-1;index>i;index--){
eles[index]=eles[index-1];
}
//把t放到i位置处
eles[i]=t;
//元素数量+1
N++;
}
//删除指定位置i处的元素，并返回该元素
public T remove(int i){
if (i<0 || i>N-1){
throw new RuntimeException("当前要删除的元素不存在");
}
//记录i位置处的元素
T result = eles[i];
//把i位置后面的元素都向前移动一位
for (int index=i;index<N-1;index++){
eles[index]=eles[index+1];
}
//当前元素数量-1
N--;
//当元素已经不足数组大小的1/4,则重置数组的大小
if (N>0 && N<eles.length/4){
resize(eles.length/2);
}
return result;
}
//查找t元素第一次出现的位置
public int indexOf(T t){
if(t==null){
throw new RuntimeException("查找的元素不合法");
}
for (int i = 0; i < N; i++) {
if (eles[i].equals(t)){
return i;
}
}
return -1;
}
//打印当前线性表的元素
public void showEles(){
for (int i = 0; i < N; i++) {
System.out.print(eles[i]+" ");
}
System.out.println();
}
@Override
public Iterator iterator() {
return new SIterator();
}
private class SIterator implements Iterator{
private int cur;
public SIterator(){
this.cur=0;
}
@Override
public boolean hasNext() {
return cur<N;
}
@Override
public T next() {
return eles[cur++];
}
}
//改变容量
private void resize(int newSize){
//记录旧数组
T[] temp = eles;
//创建新数组
eles = (T[]) new Object[newSize];
//把旧数组中的元素拷贝到新数组
for (int i = 0; i < N; i++) {
eles[i] = temp[i];
}
}
public int capacity(){
return eles.length;
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
SequenceList<String> squence = new SequenceList<>(5);
//测试遍历
squence.insert(0, "姚明");
squence.insert(1, "科比");
squence.insert(2, "麦迪");
squence.insert(3, "艾佛森");
squence.insert(4, "卡特");
System.out.println(squence.capacity());
squence.insert(5,"aa");
System.out.println(squence.capacity());
squence.insert(5,"aa");
squence.insert(5,"aa");
squence.insert(5,"aa");
squence.insert(5,"aa");
squence.insert(5,"aa");
System.out.println(squence.capacity());
squence.remove(1);
squence.remove(1);
squence.remove(1);
squence.remove(1);
squence.remove(1);
squence.remove(1);
squence.remove(1);
System.out.println(squence.capacity());
}
}

1.1.4 顺序表的时间复杂度

get(i):不难看出，不论数据元素量N有多大，只需要一次eles[i]就可以获取到对应的元素，所以时间复杂度为O(1);

insert(int i,T t):每一次插入，都需要把i位置后面的元素移动一次，随着元素数量N的增大，移动的元素也越多，时

间复杂为O(n);

remove(int i):每一次删除，都需要把i位置后面的元素移动一次，随着数据量N的增大,移动的元素也越多，时间复

杂度为O(n);

由于顺序表的底层由数组实现，数组的长度是固定的，所以在操作的过程中涉及到了容器扩容操作。这样会导致顺

序表在使用过程中的时间复杂度不是线性的，在某些需要扩容的结点处，耗时会突增，尤其是元素越多，这个问题

越明显

1.1.5 java中ArrayList实现

java中ArrayList集合的底层也是一种顺序表，使用数组实现，同样提供了增删改查以及扩容等功能。

1.是否用数组实现；

2.有没有扩容操作；

3.有没有提供遍历方式；

1.2 链表

　　之前我们已经使用顺序存储结构实现了线性表，我们会发现虽然顺序表的查询很快，时间复杂度为O(1),但是增删的

效率是比较低的，因为每一次增删操作都伴随着大量的数据元素移动。这个问题有没有解决方案呢？有，我们可以

使用另外一种存储结构实现线性表，链式存储结构。

　　链表是一种物理存储单元上非连续、非顺序的存储结构，其物理结构不能只管的表示数据元素的逻辑顺序，数据元

素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的结点（链表中的每一个元素称为结点）组成，

结点可以在运行时动态生成。

那我们如何使用链表呢？按照面向对象的思想，我们可以设计一个类，来描述结点这个事物，用一个属性描述这个

结点存储的元素，用来另外一个属性描述这个结点的下一个结点。

结点API设计：

结点类实现：

public class Node<T> {
//存储元素
public T item;
//指向下一个结点
public Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}

生成链表：

public static void main(String[] args) throws Exception {
//构建结点
Node<Integer> first = new Node<Integer>(11, null);
Node<Integer> second = new Node<Integer>(13, null);
Node<Integer> third = new Node<Integer>(12, null);
Node<Integer> fourth = new Node<Integer>(8, null);
Node<Integer> fifth = new Node<Integer>(9, null);
//生成链表
first.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
}

1.2.1 单向链表

单向链表是链表的一种，它由多个结点组成，每个结点都由一个数据域和一个指针域组成，数据域用来存储数据，

指针域用来指向其后继结点。链表的头结点的数据域不存储数据，指针域指向第一个真正存储数据的结点。

1.2.1.1 单向链表API设计

1.2.1.2 单向链表代码实现

//单向列表代码

import java.util.Iterator;
public class LinkList<T> implements Iterable<T> {
//记录头结点
private Node head;
//记录链表的长度
private int N;
public LinkList(){
//初始化头结点
head = new Node(null,null);
N=0;
}
//清空链表
public void clear(){
head.next=null;
head.item=null;
N=0;
}
//获取链表的长度
public int length(){
return N;
}
//判断链表是否为空
public boolean isEmpty(){
return N==0;
}
//获取指定位置i出的元素
public T get(int i){
if (i<0||i>=N){
throw new RuntimeException("位置不合法！");
}
Node n = head.next;
for (int index = 0; index < i; index++) {
n = n.next;
}
return n.item;
}
//向链表中添加元素t
public void insert(T t){
//找到最后一个节点
Node n = head;
while(n.next!=null){
n = n.next;
}
Node newNode = new Node(t, null);
n.next = newNode;
//链表长度+1
N++;
}
//向指定位置i处，添加元素t
public void insert(int i,T t){
if (i<0||i>=N){
throw new RuntimeException("位置不合法！");
}
//寻找位置i之前的结点
Node pre = head;
for (int index = 0; index <=i-1; index++) {
pre = pre.next;
}
//位置i的结点
Node curr = pre.next;
//构建新的结点，让新结点指向位置i的结点
Node newNode = new Node(t, curr);
//让之前的结点指向新结点
pre.next = newNode;
//长度+1
N++;
}
//删除指定位置i处的元素，并返回被删除的元素
public T remove(int i){
if (i<0 || i>=N){
throw new RuntimeException("位置不合法");
}
//寻找i之前的元素
Node pre = head;
for (int index = 0; index <=i-1; index++) {
pre = pre.next;
}
//当前i位置的结点
Node curr = pre.next;
//前一个结点指向下一个结点，删除当前结点
pre.next = curr.next;
//长度-1
N--;
return curr.item;
}
//查找元素t在链表中第一次出现的位置
public int indexOf(T t){
Node n = head;
for (int i = 0;n.next!=null;i++){
n = n.next;
if (n.item.equals(t)){
return i;
}
}
return -1;
}
//结点类
private class Node{
//存储数据
T item;
//下一个结点
Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
} 
}
@Override
public Iterator iterator() {
return new LIterator();
}
private class LIterator implements Iterator<T>{
private Node n;
public LIterator() {
this.n = head;
}
@Override
public boolean hasNext() {
return n.next!=null;
}
@Override
public T next() {
n = n.next;
return n.item;
}
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
LinkList<String> list = new LinkList<>();
list.insert(0,"张三");
list.insert(1,"李四");
list.insert(2,"王五");
list.insert(3,"赵六");
//测试length方法
for (String s : list) {
System.out.println(s);
}
System.out.println(list.length());
System.out.println("-------------------");
//测试get方法
System.out.println(list.get(2));
System.out.println("------------------------");
//测试remove方法
String remove = list.remove(1);
System.out.println(remove);
System.out.println(list.length());
System.out.println("----------------");;
for (String s : list) {
System.out.println(s);
} 
}
}

1.2.2 双向链表

双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用

来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点的数据域不存

储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一个真正存储数据的结点。

按照面向对象的思想，我们需要设计一个类，来描述结点这个事物。由于结点是属于链表的，所以我们把结点类作

为链表类的一个内部类来实现

1.2.2.1 结点API设计

1.2.2.2 双向链表API设计

1.2.2.3 双向链表代码实现

//双向链表代码

import java.util.Iterator;
public class TowWayLinkList<T> implements Iterable<T>{
//首结点
private Node head;
//最后一个结点
private Node last;
//链表的长度
private int N;
public TowWayLinkList() {
last = null;
head = new Node(null,null,null);
N=0;
}
//清空链表
public void clear(){
last=null;
head.next=last;
head.pre=null;
head.item=null;
N=0;
}
//获取链表长度
public int length(){
return N;
}
//判断链表是否为空
public boolean isEmpty(){
return N==0;
}
//插入元素t
public void insert(T t){
if (last==null){
last = new Node(t,head,null);
head.next = last;
}else{
Node oldLast = last;
Node node = new Node(t, oldLast, null);
oldLast.next = node;
last = node;
}
//长度+1
N++;
}
//向指定位置i处插入元素t
public void insert(int i,T t){
if (i<0 || i>=N){
throw new RuntimeException("位置不合法");
}
//找到位置i的前一个结点
Node pre = head;
for (int index = 0; index < i; index++) {
pre = pre.next;
}
//当前结点
Node curr = pre.next;
//构建新结点
Node newNode = new Node(t, pre, curr);
curr.pre= newNode;
pre.next = newNode;
//长度+1
N++;
}
//获取指定位置i处的元素
public T get(int i){
if (i<0||i>=N){
throw new RuntimeException("位置不合法");
}
//寻找当前结点
Node curr = head.next;
for (int index = 0; index <i; index++) {
curr = curr.next;
}
return curr.item;
}
//找到元素t在链表中第一次出现的位置
public int indexOf(T t){
Node n= head;
for (int i=0;n.next!=null;i++){
n = n.next;
if (n.next.equals(t)){
return i;
}
}
return -1;
}
//删除位置i处的元素，并返回该元素
public T remove(int i){
if (i<0 || i>=N){
throw new RuntimeException("位置不合法");
}
//寻找i位置的前一个元素
Node pre = head;
for (int index = 0; index <i ; index++) {
pre = pre.next;
}
//i位置的元素
Node curr = pre.next;
//i位置的下一个元素
Node curr_next = curr.next;
pre.next = curr_next;
curr_next.pre = pre;
//长度-1；
N--;
return curr.item;
}
//获取第一个元素
public T getFirst(){
if (isEmpty()){
return null;
}
return head.next.item;
}

//获取最后一个元素
public T getLast(){
if (isEmpty()){
return null;
}
return last.item;
}
@Override
public Iterator<T> iterator() {
return new TIterator();
}
private class TIterator implements Iterator{
private Node n = head;
@Override
public boolean hasNext() {
return n.next!=null;
}
@Override
public Object next() {
n = n.next;
return n.item;
}
}
//结点类
private class Node{
public Node(T item, Node pre, Node next) {
this.item = item;
this.pre = pre;
this.next = next;
}
//存储数据
public T item;
//指向上一个结点
public Node pre;
//指向下一个结点
public Node next;
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
TowWayLinkList<String> list = new TowWayLinkList<>();
list.insert("乔峰");
list.insert("虚竹");
list.insert("段誉");
list.insert(1,"鸠摩智");
list.insert(3,"叶二娘");
for (String str : list) {
System.out.println(str);
}
System.out.println("----------------------");
String tow = list.get(2);
System.out.println(tow);
System.out.println("-------------------------");
String remove = list.remove(3);
System.out.println(remove);
System.out.println(list.length());
System.out.println("--------------------");
System.out.println(list.getFirst());
System.out.println(list.getLast());
}
}

1.2.2.4 java中LinkedList实现

java中LinkedList集合也是使用双向链表实现，并提供了增删改查等相关方法

1.底层是否用双向链表实现；

2.结点类是否有三个域

1.2.3 链表的复杂度分析

get(int i):每一次查询，都需要从链表的头部开始，依次向后查找，随着数据元素N的增多，比较的元素越多，时间

复杂度为O(n)

insert(int i,T t):每一次插入，需要先找到i位置的前一个元素，然后完成插入操作，随着数据元素N的增多，查找的

元素越多，时间复杂度为O(n);

remove(int i):每一次移除，需要先找到i位置的前一个元素，然后完成插入操作，随着数据元素N的增多，查找的元

素越多，时间复杂度为O(n)

相比较顺序表，链表插入和删除的时间复杂度虽然一样，但仍然有很大的优势，因为链表的物理地址是不连续的，

它不需要预先指定存储空间大小，或者在存储过程中涉及到扩容等操作,,同时它并没有涉及的元素的交换。

相比较顺序表，链表的查询操作性能会比较低。因此，如果我们的程序中查询操作比较多，建议使用顺序表，增删

操作比较多，建议使用链表

1.2.4 链表反转

单链表的反转，是面试中的一个高频题目。

需求：

原链表中数据为：1->2->3>4

反转后链表中数据为：4->3->2->1

反转API：

public void reverse()：对整个链表反转

public Node reverse(Node curr)：反转链表中的某个结点curr,并把反转后的curr结点返回

使用递归可以完成反转，递归反转其实就是从原链表的第一个存数据的结点开始，依次递归调用反转每一个结点，

直到把最后一个结点反转完毕，整个链表就反转完毕。

代码:

public void reverse(){
if (N==0){
//当前是空链表，不需要反转
return;
}
reverse(head.next);
}
/**
*
* @param curr 当前遍历的结点
* @return 反转后当前结点上一个结点
*/
public Node reverse(Node curr){
//已经到了最后一个元素
if (curr.next==null){
//反转后，头结点应该指向原链表中的最后一个元素
head.next=curr;
return curr;
}
//当前结点的上一个结点
Node pre = reverse(curr.next);
pre.next = curr;
//当前结点的下一个结点设为null
curr.next=null;
//返回当前结点
return curr;
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
LinkList<Integer> list = new LinkList<>();
list.insert(1);
list.insert(2);
list.insert(3);
list.insert(4);
for (Integer i : list) {
System.out.print(i+" ");
}
System.out.println();
System.out.println("--------------------");
list.reverse();
for (Integer i : list) {
System.out.print(i+" ");
}
}
}

1.2.5 快慢指针

快慢指针指的是定义两个指针，这两个指针的移动速度一块一慢，以此来制造出自己想要的差值，这个差值可以然

我们找到链表上相应的结点。一般情况下，快指针的移动步长为慢指针的两倍

1.2.5.1 中间值问题

我们先来看下面一段代码，然后完成需求。

//测试类

public class Test {
public static void main(String[] args) throws Exception {
Node<String> first = new Node<String>("aa", null);
Node<String> second = new Node<String>("bb", null);
Node<String> third = new Node<String>("cc", null);
Node<String> fourth = new Node<String>("dd", null);
Node<String> fifth = new Node<String>("ee", null);
Node<String> six = new Node<String>("ff", null);
Node<String> seven = new Node<String>("gg", null);
//完成结点之间的指向
first.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
fifth.next = six;
six.next = seven;
//查找中间值
String mid = getMid(first);
System.out.println("中间值为："+mid);
}
/**
* @param first 链表的首结点
* @return 链表的中间结点的值
*/
public static String getMid(Node<String> first) {
return null;
}
//结点类
private static class Node<T> {
//存储数据
T item;
//下一个结点
Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
}

需求：

请完善测试类Test中的getMid方法，可以找出链表的中间元素值并返回。

利用快慢指针，我们把一个链表看成一个跑道，假设a的速度是b的两倍，那么当a跑完全程后，b刚好跑一半，以

此来达到找到中间节点的目的。

如下图，最开始，slow与fast指针都指向链表第一个节点，然后slow每次移动一个指针，fast每次移动两个指针。

代码：

/**
* @param first 链表的首结点
* @return 链表的中间结点的值
*/
public static String getMid(Node<String> first) {
Node<String> slow = first;
Node<String> fast = first;
while(fast!=null && fast.next!=null){
fast=fast.next.next;
slow=slow.next;
}
return slow.item;
}

1.2.5.2 单向链表是否有环问题

看下面代码，完成需求：

//测试类

public class Test {
public static void main(String[] args) throws Exception {
Node<String> first = new Node<String>("aa", null);
Node<String> second = new Node<String>("bb", null);
Node<String> third = new Node<String>("cc", null);
Node<String> fourth = new Node<String>("dd", null);
Node<String> fifth = new Node<String>("ee", null);
Node<String> six = new Node<String>("ff", null);
Node<String> seven = new Node<String>("gg", null);
//完成结点之间的指向
first.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
fifth.next = six;
six.next = seven;
//产生环
seven.next = third;
//判断链表是否有环
boolean circle = isCircle(first);
System.out.println("first链表中是否有环："+circle);
}
/**
* 判断链表中是否有环
* @param first 链表首结点
* @return ture为有环，false为无环
*/
public static boolean isCircle(Node<String> first) {
return false;
}
//结点类
private static class Node<T> {
//存储数据
T item;
//下一个结点
Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
}

需求：

请完善测试类Test中的isCircle方法，返回链表中是否有环。

使用快慢指针的思想，还是把链表比作一条跑道，链表中有环，那么这条跑道就是一条圆环跑道，在一条圆环跑道

中，两个人有速度差，那么迟早两个人会相遇，只要相遇那么就说明有环。

代码：

/**
* 判断链表中是否有环
* @param first 链表首结点
* @return ture为有环，false为无环
*/
public static boolean isCircle(Node<String> first) {
Node<String> slow = first;
Node<String> fast = first;
while(fast!=null && fast.next!=null){
fast = fast.next.next;
slow = slow.next; 
if (fast.equals(slow)){
return true;
}
}
return false;
}

1.2.5.3 有环链表入口问题

同样看下面这段代码，完成需求：

//测试类

public class Test {
public static void main(String[] args) throws Exception {
Node<String> first = new Node<String>("aa", null);
Node<String> second = new Node<String>("bb", null);
Node<String> third = new Node<String>("cc", null);
Node<String> fourth = new Node<String>("dd", null);
Node<String> fifth = new Node<String>("ee", null);
Node<String> six = new Node<String>("ff", null);
Node<String> seven = new Node<String>("gg", null);
//完成结点之间的指向
first.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
fifth.next = six;
six.next = seven;
//产生环
seven.next = third;
//查找环的入口结点
Node<String> entrance = getEntrance(first);
System.out.println("first链表中环的入口结点元素为："+entrance.item);
}
/**
* 查找有环链表中环的入口结点
* @param first 链表首结点
* @return 环的入口结点
*/
public static Node getEntrance(Node<String> first) {
return null;
}
//结点类
private static class Node<T> {
//存储数据
T item;
//下一个结点
Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
}

需求：

请完善Test类中的getEntrance方法，查找有环链表中环的入口结点。

当快慢指针相遇时，我们可以判断到链表中有环，这时重新设定一个新指针指向链表的起点，且步长与慢指针一样

为1，则慢指针与“新”指针相遇的地方就是环的入口。证明这一结论牵涉到数论的知识，这里略，只讲实现。

代码： 
/**
* 查找有环链表中环的入口结点
* @param first 链表首结点
* @return 环的入口结点 
*/
public static Node getEntrance(Node<String> first) {
Node<String> slow = first;
Node<String> fast = first;
Node<String> temp = null;
while(fast!=null && fast.next!=null){
fast = fast.next.next;
slow=slow.next;
if (fast.equals(slow)){
temp = first;
continue;
}
if (temp!=null){
temp=temp.next;
if (temp.equals(slow)){
return temp;
}
}
}
return null;
}

1.2.6 循环链表

循环链表，顾名思义，链表整体要形成一个圆环状。在单向链表中，最后一个节点的指针为null，不指向任何结

点，因为没有下一个元素了。要实现循环链表，我们只需要让单向链表的最后一个节点的指针指向头结点即可。

循环链表的构建：

public class Test {
public static void main(String[] args) throws Exception {
//构建结点
Node<Integer> first = new Node<Integer>(1, null);
Node<Integer> second = new Node<Integer>(2, null);
Node<Integer> third = new Node<Integer>(3, null);
Node<Integer> fourth = new Node<Integer>(4, null);
Node<Integer> fifth = new Node<Integer>(5, null);
Node<Integer> six = new Node<Integer>(6, null);
Node<Integer> seven = new Node<Integer>(7, null); 
//构建单链表
first.next = second;
second.next = third;
third.next = fourth;
fourth.next = fifth;
fifth.next = six;
six.next = seven;
//构建循环链表,让最后一个结点指向第一个结点
seven.next = first;
}
}

1.2.7 约瑟夫问题

问题描述：

传说有这样一个故事，在罗马人占领乔塔帕特后，39 个犹太人与约瑟夫及他的朋友躲到一个洞中，39个犹太人决

定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，第一个人从1开始报数，依次往

后，如果有人报数到3，那么这个人就必须自杀，然后再由他的下一个人重新从1开始报数，直到所有人都自杀身亡

为止。然而约瑟夫和他的朋友并不想遵从。于是，约瑟夫要他的朋友先假装遵从，他将朋友与自己安排在第16个与

第31个位置，从而逃过了这场死亡游戏。

问题转换：

41个人坐一圈，第一个人编号为1，第二个人编号为2，第n个人编号为n。

1.编号为1的人开始从1报数，依次向后，报数为3的那个人退出圈；

2.自退出那个人开始的下一个人再次从1开始报数，以此类推；

3.求出最后退出的那个人的编号。

图示：

解题思路：

1.构建含有41个结点的单向循环链表，分别存储1~41的值，分别代表这41个人；

2.使用计数器count，记录当前报数的值；

3.遍历链表，每循环一次，count++；

4.判断count的值，如果是3，则从链表中删除这个结点并打印结点的值，把count重置为0；

代码:

public class Test {
public static void main(String[] args) throws Exception {
//1.构建循环链表
Node<Integer> first = null;
//记录前一个结点
Node<Integer> pre = null;
for (int i = 1; i <= 41; i++) {
//第一个元素
if (i==1){
first = new Node(i,null);
pre = first; 
continue;
}
Node<Integer> node = new Node<>(i,null);
pre.next = node;
pre = node;
if (i==41){
//构建循环链表，让最后一个结点指向第一个结点
pre.next=first;
}
}
//2.使用count，记录当前的报数值
int count=0;
//3.遍历链表，每循环一次，count++
Node<Integer> n = first;
Node<Integer> before = null;
while(n!=n.next){
//4.判断count的值，如果是3，则从链表中删除这个结点并打印结点的值，把count重置为0；
count++;
if (count==3){
//删除当前结点
before.next = n.next;
System.out.print(n.item+",");
count=0;
n = n.next;
}else{
before=n;
n = n.next;
}
}
/*打印剩余的最后那个人*/
System.out.println(n.item);
}
}

1.3 栈

1.3.1 栈概述

1.3.1.1 生活中的栈

存储货物或供旅客住宿的地方,可引申为仓库、中转站。例如我们现在生活中的酒店，在古时候叫客栈，是供旅客

休息的地方，旅客可以进客栈休息，休息完毕后就离开客栈。

1.3.1.2 计算机中的栈

我们把生活中的栈的概念引入到计算机中，就是供数据休息的地方，它是一种数据结构，数据既可以进入到栈中，

又可以从栈中出去。

栈是一种基于先进后出(FILO)的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出

的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一

个数据被第一个读出来）。

我们称数据进入到栈的动作为压栈，数据从栈中出去的动作为弹栈。

1.3.2 栈的实现

1.3.2.1 栈API设计

1.3.2.2 栈代码实现

此处首节点是栈顶元素。创建一个node，node的item为null,next也为null.一直往下插入节点。这个node 一直为head。就是它的item为null，next指向下一个节点，所有节点都往node下面插入。

//栈代码
import java.util.Iterator;
public class Stack<T> implements Iterable<T>{
//记录首结点
private Node head;
//栈中元素的个数
private int N;
public Stack() {
head = new Node(null,null);
N=0;
}
//判断当前栈中元素个数是否为0
public boolean isEmpty(){
return N==0;
}
//把t元素压入栈
public void push(T t){
Node oldNext = head.next;
Node node = new Node(t, oldNext);
head.next = node;
//个数+1
N++;
}
//弹出栈顶元素
public T pop(){
Node oldNext = head.next;
if (oldNext==null){
return null;
}
//删除首个元素
head.next = head.next.next;
//个数-1
N--;
return oldNext.item;
}
//获取栈中元素的个数
public int size(){
return N;
}
@Override
public Iterator<T> iterator() {
return new SIterator();
}
private class SIterator implements Iterator<T>{
private Node n = head;
@Override
public boolean hasNext() {
return n.next!=null;
}
@Override
public T next() {
Node node = n.next;
n = n.next;
return node.item;
}
}
private class Node{
public T item;
public Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
Stack<String> stack = new Stack<>();
stack.push("a");
stack.push("b");
stack.push("c");
stack.push("d");
for (String str : stack) {
System.out.print(str+" ");
}
System.out.println("-----------------------------");
String result = stack.pop();
System.out.println("弹出了元素："+result);
System.out.println(stack.size());
}
}

1.3.3 案例

1.3.3.1 括号匹配问题

问题描述:

给定一个字符串，里边可能包含"()"小括号和其他字符，请编写程序检查该字符串的中的小括号是否成对出现。

例如：

"(上海)(长安)"：正确匹配

"上海((长安))"：正确匹配

"上海(长安(北京)(深圳)南京)":正确匹配

"上海(长安))"：错误匹配

"((上海)长安"：错误匹配

示例代码：

public class BracketsMatch {
public static void main(String[] args) {
String str = "(上海(长安)())";
boolean match = isMatch(str);
System.out.println(str+"中的括号是否匹配："+match);
}
/**
* 判断str中的括号是否匹配
* @param str 括号组成的字符串
* @return 如果匹配，返回true，如果不匹配，返回false
*/
public static boolean isMatch(String str){
return false;
}
}

请完善 isMath方法。

分析：

1.创建一个栈用来存储左括号

2.从左往右遍历字符串，拿到每一个字符

3.判断该字符是不是左括号，如果是，放入栈中存储

4.判断该字符是不是右括号，如果不是，继续下一次循环

5.如果该字符是右括号，则从栈中弹出一个元素t；

6.判断元素t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的左括号

7.循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配

代码实现：

public class BracketsMatch {
public static void main(String[] args) {
String str = "(fdafds(fafds)())";
boolean match = isMatch(str);
System.out.println(str + "中的括号是否匹配：" + match);
}
/**
* 判断str中的括号是否匹配
*
* @param str 括号组成的字符串
* @return 如果匹配，返回true，如果不匹配，返回false
*/
public static boolean isMatch(String str) {
//1.创建一个栈用来存储左括号
Stack<String> chars = new Stack<>();
//2.从左往右遍历字符串，拿到每一个字符
for (int i = 0; i < str.length(); i++) {
String currChar = str.charAt(i) + "";
//3.判断该字符是不是左括号，如果是，放入栈中存储
if (currChar.equals("(")) {
chars.push(currChar);
} else if (currChar.equals(")")) {//4.判断该字符是不是右括号，如果不是，继续下一次循
环
//5.如果该字符是右括号，则从栈中弹出一个元素t；
String t = chars.pop();
//6.判断元素t是否为null，如果不是，则证明有对应的左括号，如果不是，则证明没有对应的
左括号
if (t == null) {
return false;
}
}
}
//7.循环结束后，判断栈中还有没有剩余的左括号，如果有，则不匹配，如果没有，则匹配
if (chars.size() == 0) {
return true;
} else {
return false;
}
}
}

1.3.3.2 逆波兰表达式求值问题

逆波兰表达式求值问题是我们计算机中经常遇到的一类问题，要研究明白这个问题，首先我们得搞清楚什么是逆波

兰表达式？要搞清楚逆波兰表达式，我们得从中缀表达式说起。

中缀表达式：

　　中缀表达式就是我们平常生活中使用的表达式，例如：1+3*2,2-(1+3)等等，中缀表达式的特点是：二元运算符总

是置于两个操作数中间。

　　中缀表达式是人们最喜欢的表达式方式，因为简单，易懂。但是对于计算机来说就不是这样了，因为中缀表达式的

运算顺序不具有规律性。不同的运算符具有不同的优先级，如果计算机执行中缀表达式，需要解析表达式语义，做

大量的优先级相关操作。

逆波兰表达式(后缀表达式)：

　　逆波兰表达式是波兰逻辑学家J・卢卡西维兹(J・ Lukasewicz)于1929年首先提出的一种表达式的表示方法，后缀表

达式的特点：运算符总是放在跟它相关的操作数之后。

需求：

给定一个只包含加减乘除四种运算的逆波兰表达式的数组表示方式，求出该逆波兰表达式的结果。
public class ReversePolishNotation {
public static void main(String[] args) {
//中缀表达式3*（17-15）+18/6的逆波兰表达式如下
String[] notation = {"3", "17", "15", "-", "*","18", "6","/","+"};
int result = caculate(notation);
System.out.println("逆波兰表达式的结果为："+result);
}
/**
* @param notaion 逆波兰表达式的数组表示方式
* @return 逆波兰表达式的计算结果
*/
public static int caculate(String[] notaion){
return -1;
}
}

完善caculate方法，计算出逆波兰表达式的结果。

分析：

1.创建一个栈对象oprands存储操作数

2.从左往右遍历逆波兰表达式，得到每一个字符串

3.判断该字符串是不是运算符，如果不是，把该该操作数压入oprands栈中

4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2

5.使用该运算符计算o1和o2，得到结果result

6.把该结果压入oprands栈中

7.遍历结束后，拿出栈中最终的结果返回

代码实现：

public class ReversePolishNotation {
public static void main(String[] args) {
//中缀表达式3*（17-15）+18/6的逆波兰表达式如下
String[] notation = {"3", "17", "15", "-", "*", "18", "6", "/", "+"};
int result = caculate(notation);
System.out.println("逆波兰表达式的结果为：" + result);
}
/**
* @param notaion 逆波兰表达式的数组表示方式
* @return 逆波兰表达式的计算结果
*/
public static int caculate(String[] notaion) {
//1.创建一个栈对象oprands存储操作数
Stack<Integer> oprands = new Stack<>();
//2.从左往右遍历逆波兰表达式，得到每一个字符串
for (int i = 0; i < notaion.length; i++) {
String curr = notaion[i];
//3.判断该字符串是不是运算符，如果不是，把该该操作数压入oprands栈中
Integer o1;
Integer o2;
Integer result;
switch (curr) {
case "+":
//4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
o1 = oprands.pop();
o2 = oprands.pop();
//5.使用该运算符计算o1和o2，得到结果result
result = o2 + o1;
//6.把该结果压入oprands栈中
oprands.push(result);
break;
case "-":
//4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
o1 = oprands.pop();
o2 = oprands.pop();
//5.使用该运算符计算o1和o2，得到结果result
result = o2 - o1;
//6.把该结果压入oprands栈中
oprands.push(result);
break;
case "*":
//4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
o1 = oprands.pop();
o2 = oprands.pop();
//5.使用该运算符计算o1和o2，得到结果result
result = o2 * o1;
//6.把该结果压入oprands栈中
oprands.push(result);
break;
case "/":
//4.如果是运算符，则从oprands栈中弹出两个操作数o1,o2
o1 = oprands.pop();
o2 = oprands.pop();
//5.使用该运算符计算o1和o2，得到结果result
result = o2 / o1;
//6.把该结果压入oprands栈中
oprands.push(result);
break;
default:
oprands.push(Integer.parseInt(curr));
break;
}
}
//7.遍历结束后，拿出栈中最终的结果返回
Integer result = oprands.pop();
return result;
}
}

1.4 队列

队列是一种基于先进先出(FIFO)的数据结构，是一种只能在一端进行插入,在另一端进行删除操作的特殊线性表，它

按照先进先出的原则存储数据，先进入的数据，在读取数据时先读被读出来。

1.4.1 队列的API设计

1.4.2 队列的实现

//队列代码
import java.util.Iterator;
public class Queue<T> implements Iterable<T>{
//记录首结点
private Node head;
//记录最后一个结点
private Node last;
//记录队列中元素的个数
private int N;
public Queue() {
head = new Node(null,null);
last=null;
N=0;
}
//判断队列是否为空
public boolean isEmpty(){
return N==0;
}
//返回队列中元素的个数
public int size(){
return N;
}
//向队列中插入元素t
public void enqueue(T t){
if (last==null){
last = new Node(t,null);
head.next=last;
}else{
Node oldLast = last;
last = new Node(t,null); 
oldLast.next=last;
}
//个数+1
N++;
}
//从队列中拿出一个元素
public T dequeue(){
if (isEmpty()){
return null;
}
Node oldFirst = head.next;
head.next = oldFirst.next;
N--;
if (isEmpty()){
last=null;
}
return oldFirst.item;
}
@Override
public Iterator<T> iterator() {
return new QIterator();
}
private class QIterator implements Iterator<T>{
private Node n = head;
@Override
public boolean hasNext() {
return n.next!=null;
}
@Override
public T next() {
Node node = n.next;
n = n.next;
return node.item;
}
}
private class Node{
public T item;
public Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
} 

//测试代码
public class Test {
public static void main(String[] args) throws Exception {
Queue<String> queue = new Queue<>();
queue.enqueue("a");
queue.enqueue("b");
queue.enqueue("c");
queue.enqueue("d");
for (String str : queue) {
System.out.print(str+" ");
}
System.out.println("-----------------------------");
String result = queue.dequeue();
System.out.println("出列了元素："+result);
System.out.println(queue.size());
}
}

一、符号表

符号表最主要的目的就是将一个键和一个值联系起来，符号表能够将存储的数据元素是一个键和一个值共同组成的

键值对数据，我们可以根据键来查找对应的值。

符号表中，键具有唯一性。

符号表在实际生活中的使用场景是非常广泛的，见下表：

1.1 符号表API设计

结点类：

符号表：

1.2 符号表实现

//符号表
public class SymbolTable<Key,Value> {
//记录首结点
private Node head;
//记录符号表中元素的个数
private int N;
public SymbolTable() {
head = new Node(null,null,null);
N=0;
}
//获取符号表中键值对的个数
public int size(){
return N;
}
//往符号表中插入键值对
public void put(Key key,Value value){
//先从符号表中查找键为key的键值对
Node n = head;
while(n.next!=null){
n = n.next;
if (n.key.equals(key)){
n.value=value;
return;
}
}
//符号表中没有键为key的键值对
Node oldFirst = head.next;
Node newFirst = new Node(key,value,oldFirst);
head.next = newFirst;
//个数+1
N++;
}
//删除符号表中键为key的键值对
public void delete(Key key){
Node n = head;
while(n.next!=null){
if (n.next.key.equals(key)){
n.next = n.next.next;
N--;
return;
}
n = n.next;
}
}
//从符号表中获取key对应的值
public Value get(Key key){
Node n = head;
while(n.next!=null){
n = n.next;
if (n.key.equals(key)){
return n.value;
}
}
return null;
}
private class Node{
//键
public Key key;
//值
public Value value;
//下一个结点
public Node next;
public Node(Key key, Value value, Node next) {
this.key = key;
this.value = value;
this.next = next;
}
}
}
//测试类
public class Test {
public static void main(String[] args) throws Exception {
SymbolTable<Integer, String> st = new SymbolTable<>();
st.put(1, "张三");
st.put(3, "李四");
st.put(5, "王五");
System.out.println(st.size());
st.put(1,"老三");
System.out.println(st.get(1));
System.out.println(st.size());
st.delete(1);
System.out.println(st.size());
}
}

1.3 有序符号表

刚才实现的符号表，我们可以称之为无序符号表，因为在插入的时候，并没有考虑键值对的顺序，而在实际生活

中，有时候我们需要根据键的大小进行排序，插入数据时要考虑顺序，那么接下来我们就实现一下有序符号表。

//有序符号表
public class OrderSymbolTable<Key extends Comparable<Key>,Value> {
//记录首结点
private Node head;
//记录符号表中元素的个数
private int N;
public OrderSymbolTable() {
head = new Node(null,null,null);
N=0;
}
//获取符号表中键值对的个数
public int size(){
return N;
}
//往符号表中插入键值对
public void put(Key key,Value value){
//记录当前结点
Node curr = head.next;
//记录上一个结点
Node pre = head;
//1.如果key大于当前结点的key，则一直寻找下一个结点
while(curr!=null && key.compareTo(curr.key)>0){
pre = curr;
curr = curr.next;
}
//2.如果当前结点curr的key和将要插入的key一样，则替换
if (curr!=null && curr.key.compareTo(key)==0){
curr.value=value;
return;
}
//3.没有找到相同的key，把新结点插入到curr之前
Node newNode = new Node(key, value, curr);
pre.next = newNode;
}
//删除符号表中键为key的键值对
public void delete(Key key){
Node n = head;
while(n.next!=null){
if (n.next.key.equals(key)){
n.next = n.next.next;
N--;
return;
}
n = n.next;
}
}
//从符号表中获取key对应的值
public Value get(Key key){
Node n = head;
while(n.next!=null){
n = n.next;
if (n.key.equals(key)){
return n.value;
}
}
return null;
}
private class Node{
//键
public Key key;
//值
public Value value;
//下一个结点
public Node next;
public Node(Key key, Value value, Node next) {
this.key = key;
this.value = value;
this.next = next;
}
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
OrderSymbolTable<Integer, String> bt = new OrderSymbolTable<>();
bt.put(4, "二哈");
bt.put(3, "张三");
bt.put(1, "李四");
bt.put(1, "aa");
bt.put(5, "王五");
}
}

一、二叉树入门

之前我们实现的符号表中，不难看出，符号表的增删查操作，随着元素个数N的增多，其耗时也是线性增多的，时

间复杂度都是O(n),为了提高运算效率，接下来我们学习树这种数据结构。

1.1树的基本定义

树是我们计算机中非常重要的一种数据结构，同时使用树这种数据结构，可以描述现实生活中的很多事物，例如家

谱、单位的组织架构、等等。

树是由n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就

是说它是根朝上，而叶朝下的。

树具有以下特点：

1.每个结点有零个或多个子结点；

2.没有父结点的结点为根结点；

3.每一个非根结点只有一个父结点；

4.每个结点及其后代结点整体上可以看做是一棵树，称为当前结点的父结点的一个子树；

1.2 树的相关术语

结点的度：

一个结点含有的子树的个数称为该结点的度；

叶结点：

度为0的结点称为叶结点，也可以叫做终端结点

分支结点：

度不为0的结点称为分支结点，也可以叫做非终端结点

结点的层次：

从根结点开始，根结点的层次为1，根的直接后继层次为2，以此类推

结点的层序编号：

将树中的结点，按照从上层到下层，同层从左到右的次序排成一个线性序列，把他们编成连续的自然数。

树的度：树中所有结点的度的最大值

树的高度(深度)：树中结点的最大层次

森林：

m （m>=0）个互不相交的树的集合，将一颗非空树的根结点删去，树就变成一个森林；给森林增加一个统一的根

结点，森林就变成一棵树

孩子结点：

一个结点的直接后继结点称为该结点的孩子结点

双亲结点(父结点)：

一个结点的直接前驱称为该结点的双亲结点

兄弟结点：

同一双亲结点的孩子结点间互称兄弟结点

1.3 二叉树的基本定义

二叉树就是度不超过2的树(每个结点最多有两个子结点)

满二叉树：

一个二叉树，如果每一个层的结点树都达到最大值，则这个二叉树就是满二叉树。

完全二叉树：

叶节点只能出现在最下层和次下层，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树

1.4 二叉查找树的创建

1.4.1二叉树的结点类

根据对图的观察，我们发现二叉树其实就是由一个一个的结点及其之间的关系组成的，按照面向对象的思想，我们

设计一个结点类来描述结点这个事物。

结点类API设计：

代码实现：

private class Node<Key,Value>{
//存储键
public Key key;
//存储值
private Value value;
//记录左子结点
public Node left;
//记录右子结点
public Node right;
public Node(Key key, Value value, Node left, Node right) {
this.key = key;
this.value = value;
this.left = left;
this.right = right;
}
}

1.4.2 二叉查找树API设计

1.4.3 二叉查找树实现

插入方法put实现思想：

1.如果当前树中没有任何一个结点，则直接把新结点当做根结点使用

2.如果当前树不为空，则从根结点开始：

2.1如果新结点的key小于当前结点的key，则继续找当前结点的左子结点；

2.2如果新结点的key大于当前结点的key，则继续找当前结点的右子结点；

2.3如果新结点的key等于当前结点的key，则树中已经存在这样的结点，替换该结点的value值即可。

查询方法get实现思想：

从根节点开始：

1.如果要查询的key小于当前结点的key，则继续找当前结点的左子结点；

2.如果要查询的key大于当前结点的key，则继续找当前结点的右子结点；

3.如果要查询的key等于当前结点的key，则树中返回当前结点的value。

删除方法delete实现思想：

1.找到被删除结点；

2.找到被删除结点右子树中的最小结点minNode

3.删除右子树中的最小结点

4.让被删除结点的左子树称为最小结点minNode的左子树，让被删除结点的右子树称为最小结点minNode的右子树

5.让被删除结点的父节点指向最小结点minNode

代码：

//二叉树代码
public class BinaryTree<Key extends Comparable<Key>, Value> {
//记录根结点
private Node root;
//记录树中元素的个数
private int N;
//获取树中元素的个数
public int size() {
return N;
}
//向树中添加元素key-value
public void put(Key key, Value value) {
root = put(root, key, value);
}
//向指定的树x中添加key-value,并返回添加元素后新的树
private Node put(Node x, Key key, Value value) {
if (x == null) {
//个数+1
N++;
return new Node(key, value, null, null);
}
int cmp = key.compareTo(x.key);
if (cmp > 0) {
//新结点的key大于当前结点的key，继续找当前结点的右子结点
x.right = put(x.right, key, value);
} else if (cmp < 0) {
//新结点的key小于当前结点的key，继续找当前结点的左子结点
x.left = put(x.left, key, value);
} else {
//新结点的key等于当前结点的key，把当前结点的value进行替换
x.value = value;
}
return x;
}
//查询树中指定key对应的value
public Value get(Key key) {
return get(root, key);
}
//从指定的树x中，查找key对应的值
public Value get(Node x, Key key) {
if (x == null) {
return null;
}
int cmp = key.compareTo(x.key);
if (cmp > 0) {
//如果要查询的key大于当前结点的key，则继续找当前结点的右子结点；
return get(x.right, key);
} else if (cmp < 0) {
//如果要查询的key小于当前结点的key，则继续找当前结点的左子结点；
return get(x.left, key);
} else {
//如果要查询的key等于当前结点的key，则树中返回当前结点的value。
return x.value;
}
}
//删除树中key对应的value
public void delete(Key key) {
root = delete(root, key);
}
//删除指定树x中的key对应的value，并返回删除后的新树
public Node delete(Node x, Key key) {
if (x == null) {
return null;
}
int cmp = key.compareTo(x.key);
if (cmp > 0) {
//新结点的key大于当前结点的key，继续找当前结点的右子结点
x.right = delete(x.right, key);
} else if (cmp < 0) {
//新结点的key小于当前结点的key，继续找当前结点的左子结点
x.left = delete(x.left, key);
} else {
//新结点的key等于当前结点的key,当前x就是要删除的结点
//1.如果当前结点的右子树不存在，则直接返回当前结点的左子结点
if (x.right == null) {
return x.left;
}
//2.如果当前结点的左子树不存在，则直接返回当前结点的右子结点
if (x.left == null) {
return x.right;
}
//3.当前结点的左右子树都存在
//3.1找到右子树中最小的结点
Node minNode = x.right;
while (minNode.left != null) {
minNode = minNode.left;
}
//3.2删除右子树中最小的结点
Node n = x.right; 
while (n.left != null) {
if (n.left.left == null) {
n.left = null;
} else {
n = n.left;
}
}
//3.3让被删除结点的左子树称为最小结点minNode的左子树，让被删除结点的右子树称为最小结点
minNode的右子树
minNode.left = x.left;
minNode.right = x.right;
//3.4让被删除结点的父节点指向最小结点minNode
x = minNode;
//个数-1
N--;
}
return x;
}
private class Node {
//存储键
public Key key;
//存储值
private Value value;
//记录左子结点
public Node left;
//记录右子结点
public Node right;
public Node(Key key, Value value, Node left, Node right) {
this.key = key;
this.value = value;
this.left = left;
this.right = right;
}
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
BinaryTree<Integer, String> bt = new BinaryTree<>();
bt.put(4, "二哈");
bt.put(1, "张三");
bt.put(3, "李四");
bt.put(5, "王五");
System.out.println(bt.size());
bt.put(1,"老三");
System.out.println(bt.get(1));
System.out.println(bt.size());
bt.delete(1);
System.out.println(bt.size());
}
}

1.4.4 二叉查找树其他便捷方法

1.4.4.1 查找二叉树中最小的键

在某些情况下，我们需要查找出树中存储所有元素的键的最小值，比如我们的树中存储的是学生的排名和姓名数

据，那么需要查找出排名最低是多少名？这里我们设计如下两个方法来完成：

//找出整个树中最小的键
public Key min(){
return min(root).key;
}
//找出指定树x中最小的键所在的结点
private Node min(Node x){
if (x.left!=null){
return min(x.left);
}else{
return x;
}
}

1.4.4.2 查找二叉树中最大的键

在某些情况下，我们需要查找出树中存储所有元素的键的最大值，比如比如我们的树中存储的是学生的成绩和学生

的姓名，那么需要查找出最高的分数是多少？这里我们同样设计两个方法来完成：

//找出整个树中最大的键

public Key max(){

return max(root).key;

}

//找出指定树x中最大键所在的结点

public Node max(Node x){

if (x.right!=null){

return max(x.right);

}else{

return x;

}

1.5 二叉树的基础遍历

很多情况下，我们可能需要像遍历数组数组一样，遍历树，从而拿出树中存储的每一个元素，由于树状结构和线性

结构不一样，它没有办法从头开始依次向后遍历，所以存在如何遍历，也就是按照什么样的搜索路径进行遍历的问

题。

我们把树简单的画作上图中的样子，由一个根节点、一个左子树、一个右子树组成，那么按照根节点什么时候被访

问，我们可以把二叉树的遍历分为以下三种方式：

1.前序遍历；

先访问根结点，然后再访问左子树，最后访问右子树

2.中序遍历；

先访问左子树，中间访问根节点，最后访问右子树

3.后序遍历；

先访问左子树，再访问右子树，最后访问根节点

如果我们分别对下面的树使用三种遍历方式进行遍历，得到的结果如下：

1.5.1 前序遍历

我们在4.4中创建的树上，添加前序遍历的API：

public Queue<Key> preErgodic()：使用前序遍历，获取整个树中的所有键

private void preErgodic(Node x,Queue<Key> keys)：使用前序遍历，把指定树x中的所有键放入到keys队列中

实现过程中，我们通过前序遍历，把,把每个结点的键取出，放入到队列中返回即可。

实现步骤：

1.把当前结点的key放入到队列中;

2.找到当前结点的左子树，如果不为空，递归遍历左子树

3.找到当前结点的右子树，如果不为空，递归遍历右子树

代码：

//使用前序遍历，获取整个树中的所有键
public Queue<Key> preErgodic(){
Queue<Key> keys = new Queue<>();
preErgodic(root,keys);
return keys;
}
//使用前序遍历，把指定树x中的所有键放入到keys队列中
private void preErgodic(Node x,Queue<Key> keys){
if (x==null){
return;
} 
//1.把当前结点的key放入到队列中;
keys.enqueue(x.key);
//2.找到当前结点的左子树，如果不为空，递归遍历左子树
if (x.left!=null){
preErgodic(x.left,keys);
}
//3.找到当前结点的右子树，如果不为空，递归遍历右子树
if (x.right!=null){
preErgodic(x.right,keys);
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
BinaryTree<String, String> bt = new BinaryTree<>();
bt.put("E", "5");
bt.put("B", "2");
bt.put("G", "7");
bt.put("A", "1");
bt.put("D", "4");
bt.put("F", "6");
bt.put("H", "8");
bt.put("C", "3");
Queue<String> queue = bt.preErgodic();
for (String key : queue) {
System.out.println(key+"="+bt.get(key));
}
}
}

1.5.2 中序遍历

我们在4.4中创建的树上，添加前序遍历的API：

public Queue<Key> midErgodic()：使用中序遍历，获取整个树中的所有键

private void midErgodic(Node x,Queue<Key> keys)：使用中序遍历，把指定树x中的所有键放入到keys队列中

实现步骤：

1.找到当前结点的左子树，如果不为空，递归遍历左子树

2.把当前结点的key放入到队列中;

3.找到当前结点的右子树，如果不为空，递归遍历右子树

代码：

//使用中序遍历，获取整个树中的所有键

public Queue<Key> midErgodic(){
Queue<Key> keys = new Queue<>();
midErgodic(root,keys); 
}
//使用中序遍历，把指定树x中的所有键放入到keys队列中
private void midErgodic(Node x,Queue<Key> keys){
if (x==null){
return;
}
//1.找到当前结点的左子树，如果不为空，递归遍历左子树
if (x.left!=null){
midErgodic(x.left,keys);
}
//2.把当前结点的key放入到队列中;
keys.enqueue(x.key);
//3.找到当前结点的右子树，如果不为空，递归遍历右子树
if (x.right!=null){
midErgodic(x.right,keys);
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
BinaryTree<String, String> bt = new BinaryTree<>();
bt.put("E", "5");
bt.put("B", "2");
bt.put("G", "7");
bt.put("A", "1");
bt.put("D", "4");
bt.put("F", "6");
bt.put("H", "8");
bt.put("C", "3");
Queue<String> queue = bt.midErgodic();
for (String key : queue) {
System.out.println(key+"="+bt.get(key));
}
}
}

1.5.3 后序遍历

我们在4.4中创建的树上，添加前序遍历的API：

public Queue<Key> afterErgodic()：使用后序遍历，获取整个树中的所有键

private void afterErgodic(Node x,Queue<Key> keys)：使用后序遍历，把指定树x中的所有键放入到keys队列中

实现步骤：

1.找到当前结点的左子树，如果不为空，递归遍历左子树

2.找到当前结点的右子树，如果不为空，递归遍历右子树

3.把当前结点的key放入到队列中;

代码：

//使用后序遍历，获取整个树中的所有键
public Queue<Key> afterErgodic(){
Queue<Key> keys = new Queue<>();
afterErgodic(root,keys);
return keys;
}
//使用后序遍历，把指定树x中的所有键放入到keys队列中
private void afterErgodic(Node x,Queue<Key> keys){
if (x==null){
return;
}
//1.找到当前结点的左子树，如果不为空，递归遍历左子树
if (x.left!=null){
afterErgodic(x.left,keys);
}
//2.找到当前结点的右子树，如果不为空，递归遍历右子树
if (x.right!=null){
afterErgodic(x.right,keys);
}
//3.把当前结点的key放入到队列中;
keys.enqueue(x.key);
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
BinaryTree<String, String> bt = new BinaryTree<>();
bt.put("E", "5");
bt.put("B", "2");
bt.put("G", "7");
bt.put("A", "1");
bt.put("D", "4");
bt.put("F", "6");
bt.put("H", "8");
bt.put("C", "3");
Queue<String> queue = bt.afterErgodic();
for (String key : queue) {
System.out.println(key+"="+bt.get(key));
}
}
}

1.6 二叉树的层序遍历

所谓的层序遍历，就是从根节点（第一层）开始，依次向下，获取每一层所有结点的值，有二叉树如下：

那么层序遍历的结果是：EBGADFHC

我们在4.4中创建的树上，添加层序遍历的API：

public Queue<Key> layerErgodic()：使用层序遍历，获取整个树中的所有键

实现步骤：

1.创建队列，存储每一层的结点；

2.使用循环从队列中弹出一个结点：

2.1获取当前结点的key；

2.2如果当前结点的左子结点不为空，则把左子结点放入到队列中

2.3如果当前结点的右子结点不为空，则把右子结点放入到队列中

代码：

//使用层序遍历得到树中所有的键
public Queue<Key> layerErgodic(){
Queue<Key> keys = new Queue<>();
Queue<Node> nodes = new Queue<>();
nodes.enqueue(root);
while(!nodes.isEmpty()){
Node x = nodes.dequeue();
keys.enqueue(x.key);
if (x.left!=null){
nodes.enqueue(x.left);
}
if (x.right!=null){
nodes.enqueue(x.right);
}
} 
return keys;
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
BinaryTree<String, String> bt = new BinaryTree<>();
bt.put("E", "5");
bt.put("B", "2");
bt.put("G", "7");
bt.put("A", "1");
bt.put("D", "4");
bt.put("F", "6");
bt.put("H", "8");
bt.put("C", "3");
Queue<String> queue = bt.layerErgodic();
for (String key : queue) {
System.out.println(key+"="+bt.get(key));
}
}
}

1.7 二叉树的最大深度问题

需求：

给定一棵树，请计算树的最大深度（树的根节点到最远叶子结点的最长路径上的结点数）;

上面这棵树的最大深度为4。

实现：

我们在1.4中创建的树上，添加如下的API求最大深度：

public int maxDepth()：计算整个树的最大深度

private int maxDepth(Node x):计算指定树x的最大深度

实现步骤：

1.如果根结点为空，则最大深度为0；

2.计算左子树的最大深度；

3.计算右子树的最大深度；

4.当前树的最大深度=左子树的最大深度和右子树的最大深度中的较大者+1

代码：

//计算整个树的最大深度
public int maxDepth() {
return maxDepth(root);
}
//计算指定树x的最大深度
private int maxDepth(Node x) {
//1.如果根结点为空，则最大深度为0；
if (x == null) {
return 0;
}
int max = 0;
int maxL = 0;
int maxR = 0;
//2.计算左子树的最大深度；
if (x.left != null) {
maxL = maxDepth(x.left);
}
//3.计算右子树的最大深度；
if (x.right != null) {
maxR = maxDepth(x.right);
}
//4.当前树的最大深度=左子树的最大深度和右子树的最大深度中的较大者+1
max = maxL > maxR ? maxL + 1 : maxR + 1;
return max;
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
BinaryTree<String, String> bt = new BinaryTree<>();
bt.put("E", "5");
bt.put("B", "2");
bt.put("G", "7");
bt.put("A", "1");
bt.put("D", "4");
bt.put("F", "6");
bt.put("H", "8");
bt.put("C", "3");
int i = bt.maxDepth();
System.out.println(i);
}
}

1.8 折纸问题

需求：

请把一段纸条竖着放在桌子上，然后从纸条的下边向上方对折1次，压出折痕后展开。此时折痕是凹下去的，即折

痕突起的方向指向纸条的背面。如果从纸条的下边向上方连续对折2 次，压出折痕后展开，此时有三条折痕，从上

到下依次是下折痕、下折痕和上折痕。

给定一个输入参数N，代表纸条都从下边向上方连续对折N次，请从上到下打印所有折痕的方向例如：N=1时，打

印： down；N=2时，打印： down down up

分析：

我们把对折后的纸张翻过来，让粉色朝下，这时把第一次对折产生的折痕看做是根结点，那第二次对折产生的下折

痕就是该结点的左子结点，而第二次对折产生的上折痕就是该结点的右子结点，这样我们就可以使用树型数据结构

来描述对折后产生的折痕。

这棵树有这样的特点：

1.根结点为下折痕；

2.每一个结点的左子结点为下折痕；

3.每一个结点的右子结点为上折痕；

实现步骤：

1.定义结点类

构建深度为N的折痕树；

使用中序遍历，打印出树中所有结点的内容；

构建深度为N的折痕树：

1.第一次对折，只有一条折痕，创建根结点；

2.如果不是第一次对折，则使用队列保存根结点；

3.循环遍历队列：

3.1

从队列中拿出一个结点；

3.2如果这个结点的左子结点不为空，则把这个左子结点添加到队列中；

3.3

如果这个结点的右子结点不为空，则把这个右子结点添加到队列中；

3.4

判断当前结点的左子结点和右子结点都不为空，如果是，则需要为当前结点创建一个值为down的左子结点，一

个值为up的右子结点。

代码：

public class PaperFolding {
public static void main(String[] args) {
//构建折痕树
Node tree = createTree(3);
//遍历折痕树，并打印
printTree(tree);
}
//3.使用中序遍历，打印出树中所有结点的内容；
private static void printTree(Node tree) { 
if (tree==null){
return;
}
printTree(tree.left);
System.out.print(tree.item+",");
printTree(tree.right);
}
//2.构建深度为N的折痕树；
private static Node createTree(int N) {
Node root = null;
for (int i = 0; i <N ; i++) {
if (i==0){
//1.第一次对折，只有一条折痕，创建根结点；
root = new Node("down",null,null);
}else{
//2.如果不是第一次对折，则使用队列保存根结点；
Queue<Node> queue = new Queue<>();
queue.enqueue(root);
//3.循环遍历队列：
while(!queue.isEmpty()){
//3.1从队列中拿出一个结点；
Node tmp = queue.dequeue();
//3.2如果这个结点的左子结点不为空，则把这个左子结点添加到队列中；
if (tmp.left!=null){
queue.enqueue(tmp.left);
}
//3.3如果这个结点的右子结点不为空，则把这个右子结点添加到队列中；
if (tmp.right!=null){
queue.enqueue(tmp.right);
}
//3.4判断当前结点的左子结点和右子结点都不为空，如果是，则需要为当前结点创建一个
值为down的左子结点，一个值为up的右子结点。
if (tmp.left==null && tmp.right==null){
tmp.left = new Node("down",null,null);
tmp.right = new Node("up",null,null);
}
}
}
}
return root;
}
//1.定义结点类
private static class Node{
//存储结点元素
String item;
//左子结点
Node left;
//右子结点
Node right; 
public Node(String item, Node left, Node right) {
this.item = item;
this.left = left;
this.right = right;
}
}
}

一、堆

1.1 堆的定义

堆是计算机科学中一类特殊的数据结构的统称，堆通常可以被看做是一棵完全二叉树的数组对象。

堆的特性：

1.它是完全二叉树，除了树的最后一层结点不需要是满的，其它的每一层从左到右都是满的，如果最后一层结点不

是满的，那么要求左满右不满

2.它通常用数组来实现。

具体方法就是将二叉树的结点按照层级顺序放入数组中，根结点在位置1，它的子结点在位置2和3，而子结点的子

结点则分别在位置4,5,6和7，以此类推。

如果一个结点的位置为k，则它的父结点的位置为[k/2],而它的两个子结点的位置则分别为2k和2k+1。这样，在不

使用指针的情况下，我们也可以通过计算数组的索引在树中上下移动：从a[k]向上一层，就令k等于k/2,向下一层就

令k等于2k或2k+1。

3.每个结点都大于等于它的两个子结点。这里要注意堆中仅仅规定了每个结点大于等于它的两个子结点，但这两个

子结点的顺序并没有做规定，跟我们之前学习的二叉查找树是有区别的。

1.2 堆的API设计

1.3 堆的实现

1.4.1 insert插入方法的实现

堆是用数组完成数据元素的存储的，由于数组的底层是一串连续的内存地址，所以我们要往堆中插入数据，我们只

能往数组中从索引0处开始，依次往后存放数据，但是堆中对元素的顺序是有要求的，每一个结点的数据要大于等

于它的两个子结点的数据，所以每次插入一个元素，都会使得堆中的数据顺序变乱，这个时候我们就需要通过一些

方法让刚才插入的这个数据放入到合适的位置。

所以，如果往堆中新插入元素，我们只需要不断的比较新结点a[k]和它的父结点a[k/2]的大小，然后根据结果完成

数据元素的交换，就可以完成堆的有序调整。

1.4.2 delMax删除最大元素方法的实现

由堆的特性我们可以知道，索引1处的元素，也就是根结点就是最大的元素，当我们把根结点的元素删除后，需要

有一个新的根结点出现，这时我们可以暂时把堆中最后一个元素放到索引1处，充当根结点，但是它有可能不满足

堆的有序性需求，这个时候我们就需要通过一些方法，让这个新的根结点放入到合适的位置。

所以，当删除掉最大元素后，只需要将最后一个元素放到索引1处，并不断的拿着当前结点a[k]与它的子结点a[2k]

和a[2k+1]中的较大者交换位置，即可完成堆的有序调整。

1.4.3 堆的实现代码

//堆代码
public class Heap<T extends Comparable<T>> {
//存储堆中的元素
private T[] items;
//记录堆中元素的个数
private int N;
public Heap(int capacity) {
items = (T[]) new Comparable[capacity+1];
N=0;
}
//判断堆中索引i处的元素是否小于索引j处的元素
private boolean less(int i,int j){
return items[i].compareTo(items[j])<0;
}
//交换堆中i索引和j索引处的值
private void exch(int i,int j){
T tmp = items[i];
items[i] = items[j];
items[j] = tmp;
}
//往堆中插入一个元素
public void insert(T t){
items[++N] = t;
swim(N);
}
//删除堆中最大的元素,并返回这个最大元素
public T delMax(){
T max = items[1];
//交换索引1处和索引N处的值
exch(1,N);
//删除最后位置上的元素
items[N]=null;
N--;//个数-1
sink(1);
return max;
}
//使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
private void swim(int k){
//如果已经到了根结点，就不需要循环了
while(k>1){
//比较当前结点和其父结点
if(less(k/2,k)){
//父结点小于当前结点，需要交换
exch(k/2,k);
}
k = k/2;
}
}
//使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
private void sink(int k){
//如果当前已经是最底层了，就不需要循环了
while(2*k<=N){
//找到子结点中的较大者
int max;
if (2*k+1<=N){//存在右子结点
if (less(2*k,2*k+1)){
max = 2*k+1;
}else{
max = 2*k;
}
}else{//不存在右子结点
max = 2*k;
} 
//比较当前结点和子结点中的较大者，如果当前结点不小，则结束循环
if (!less(k,max)){
break;
}
//当前结点小，则交换，
exch(k,max);
k = max;
}
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
Heap<String> heap = new Heap<String>(20);
heap.insert("S");
heap.insert("G");
heap.insert("I");
heap.insert("E");
heap.insert("N");
heap.insert("H");
heap.insert("O");
heap.insert("A");
heap.insert("T");
heap.insert("P");
heap.insert("R");
String del;
while((del=heap.delMax())!=null){
System.out.print(del+",");
}
}
}

1.4 堆排序

给定一个数组：

String[] arr = {"S","O","R","T","E","X","A","M","P","L","E"}

请对数组中的字符按从小到大排序。

实现步骤：

1.构造堆；

2.得到堆顶元素，这个值就是最大值；

3.交换堆顶元素和数组中的最后一个元素，此时所有元素中的最大元素已经放到合适的位置；

4.对堆进行调整，重新让除了最后一个元素的剩余元素中的最大值放到堆顶；

5.重复2~4这个步骤，直到堆中剩一个元素为止。

API设计：

1.4.1 堆构造过程

堆的构造，最直观的想法就是另外再创建一个和新数组数组，然后从左往右遍历原数组，每得到一个元素后，添加

到新数组中，并通过上浮，对堆进行调整，最后新的数组就是一个堆。

上述的方式虽然很直观，也很简单，但是我们可以用更聪明一点的办法完成它。创建一个新数组，把原数组

0~length-1的数据拷贝到新数组的1~length处，再从新数组长度的一半处开始往1索引处扫描（从右往左），然后

对扫描到的每一个元素做下沉调整即可。

1.4.2 堆排序过程

对构造好的堆，我们只需要做类似于堆的删除操作，就可以完成排序。

1.将堆顶元素和堆中最后一个元素交换位置；

2.通过对堆顶元素下沉调整堆，把最大的元素放到堆顶(此时最后一个元素不参与堆的调整，因为最大的数据已经到了数组的最右边)

3.重复1~2步骤，直到堆中剩最后一个元素。

代码：

//对排序代码
public class HeapSort {
//对source数组中的数据从小到大排序
public static void sort(Comparable[] source) {
//1.创建一个比原数组大1的数组
Comparable[] heap = new Comparable[source.length + 1];
//2.构造堆
createHeap(source,heap);
//3.堆排序
//3.1定义一个变量，记录heap中未排序的所有元素中最大的索引 
int N = heap.length-1;
while(N!=1){
//3.2交换heap中索引1处的元素和N处的元素
exch(heap,1,N);
N--;
//3.3对索引1处的元素在0~N范围内做下沉操作
sink(heap,1,N);
}
//4.heap中的数据已经有序，拷贝到source中
System.arraycopy(heap,1,source,0,source.length);
}
//根据原数组source，构造出堆heap
private static void createHeap(Comparable[] source, Comparable[] heap) {
//1.把source中的数据拷贝到heap中，从heap的1索引处开始填充
System.arraycopy(source,0,heap,1,source.length);
//2.从heap索引的一半处开始倒叙遍历，对得到的每一个元素做下沉操作
for (int i = (heap.length-1)/2; i>0 ; i--) {
sink(heap,i,heap.length-1);
}
}
//判断heap堆中索引i处的元素是否小于索引j处的元素
private static boolean less(Comparable[] heap, int i, int j) {
return heap[i].compareTo(heap[j])<0;
}
//交换heap堆中i索引和j索引处的值
private static void exch(Comparable[] heap, int i, int j) {
Comparable tmp = heap[i];
heap[i] = heap[j];
heap[j] = tmp;
}
//在heap堆中，对target处的元素做下沉，范围是0~range
private static void sink(Comparable[] heap, int target, int range){
//没有子结点了
while (2*target<=range){
//1.找出target结点的两个子结点中的较大值
int max=2*target;
if (2*target+1<=range){
//存在右子结点
if (less(heap,2*target,2*target+1)){
max=2*target+1;
}
}
//2.如果当前结点的值小于子结点中的较大值，则交换
if(less(heap,target,max)){
exch(heap,target,max);
 

}
//3.更新target的值
target=max;
}
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
HeapSort.sort(arr);
System.out.println(Arrays.toString(arr));
}
}

一、优先队列

　　普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在某些情况下，我们可能需要找出

队列中的最大值或者最小值，例如使用一个队列保存计算机的任务，一般情况下计算机的任务都是有优先级的，我

们需要在这些计算机的任务中找出优先级最高的任务先执行，执行完毕后就需要把这个任务从队列中移除。普通的

队列要完成这样的功能，需要每次遍历队列中的所有元素，比较并找出最大值，效率不是很高，这个时候，我们就

可以使用一种特殊的队列来完成这种需求，优先队列。

优先队列按照其作用不同，可以分为以下两种：

最大优先队列：

可以获取并删除队列中最大的值

最小优先队列：

可以获取并删除队列中最小的值

1.1 最大优先队列

我们之前学习过堆，而堆这种结构是可以方便的删除最大的值，所以，接下来我们可以基于堆区实现最大优先队

列。

1.1.1 最大优先队列API设计

1.1.2 最大优先队列代码实现

//最大优先队列代码
public class MaxPriorityQueue<T extends Comparable<T>> {
//存储堆中的元素
private T[] items;
//记录堆中元素的个数
private int N;
public MaxPriorityQueue(int capacity) {
items = (T[]) new Comparable[capacity+1];
N = 0;
}
//获取队列中元素的个数
public int size() {
return N;
}
//判断队列是否为空
public boolean isEmpty() {
return N == 0;
}
//判断堆中索引i处的元素是否小于索引j处的元素
private boolean less(int i, int j) {
return items[i].compareTo(items[j]) < 0;
}
//交换堆中i索引和j索引处的值
private void exch(int i, int j) {
T tmp = items[i]; 
items[i] = items[j];
items[j] = tmp;
}
//往堆中插入一个元素
public void insert(T t) {
items[++N] = t;
swim(N);
}
//删除堆中最大的元素,并返回这个最大元素
public T delMax() {
T max = items[1];
//交换索引1处和索引N处的值
exch(1, N);
//删除最后位置上的元素
items[N] = null;
N--;//个数-1
sink(1);
return max;
}
//使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
private void swim(int k) {
//如果已经到了根结点，就不需要循环了
while (k > 1) {
//比较当前结点和其父结点
if (less(k / 2, k)) {
//父结点小于当前结点，需要交换
exch(k / 2, k);
}
k = k / 2;
}
}
//使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
private void sink(int k) {
//如果当前已经是最底层了，就不需要循环了
while (2 * k <= N) {
//找到子结点中的较大者
int max = 2 * k;
if (2 * k + 1 <= N) {//存在右子结点
if (less(2 * k, 2 * k + 1)) {
max = 2 * k + 1;
}
}
//比较当前结点和子结点中的较大者，如果当前结点不小，则结束循环
if (!less(k, max)) {
break;
}
//当前结点小，则交换，
exch(k, max); 
k = max;
}
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
MaxPriorityQueue<String> maxpq = new MaxPriorityQueue<>(20);
for (String s : arr) {
maxpq.insert(s);
}
System.out.println(maxpq.size());
String del;
while(!maxpq.isEmpty()){
del = maxpq.delMax();
System.out.print(del+",");
}
}
}

1.2 最小优先队列

最小优先队列实现起来也比较简单，我们同样也可以基于堆来完成最小优先队列。

我们前面学习堆的时候，堆中存放数据元素的数组要满足都满足如下特性：

1.最大的元素放在数组的索引1处。

2.每个结点的数据总是大于等于它的两个子结点的数据。

其实我们之前实现的堆可以把它叫做最大堆，我们可以用相反的思想实现最小堆，让堆中存放数据元素的数组满足

如下特性：

1.最小的元素放在数组的索引1处。

2.每个结点的数据总是小于等于它的两个子结点的数据。

这样我们就能快速的访问到堆中最小的数据。

1.2.1 最小优先队列API设计

1.2.2 最小优先队列代码实现

//最小优先队列代码
public class MinPriorityQueue<T extends Comparable<T>> {
//存储堆中的元素
private T[] items;
//记录堆中元素的个数
private int N;
public MinPriorityQueue(int capacity) {
items = (T[]) new Comparable[capacity+1];
N = 0;
}
//获取队列中元素的个数
public int size() {
return N;
}
//判断队列是否为空
public boolean isEmpty() {
return N == 0;
}
//判断堆中索引i处的元素是否小于索引j处的元素
private boolean less(int i, int j) {
return items[i].compareTo(items[j]) < 0;
} 
//交换堆中i索引和j索引处的值
private void exch(int i, int j) {
T tmp = items[i];
items[i] = items[j];
items[j] = tmp;
}
//往堆中插入一个元素
public void insert(T t) {
items[++N] = t;
swim(N);
}
//删除堆中最小的元素,并返回这个最小元素
public T delMin() {
//索引1处的值是最小值
T min = items[1];
//交换索引1处和索引N处的值
exch(1, N);
//删除索引N处的值
items[N] = null;
//数据元素-1
N--;
//对索引1处的值做下沉，使堆重新有序
sink(1);
//返回被删除的值
return min;
}
//使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
private void swim(int k) {
//如果没有父结点，则不再上浮
while (k > 1) {
//如果当前结点比父结点小，则交换
if (less(k, k / 2)) {
exch(k, k / 2);
}
k = k / 2;
}
}
//使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
private void sink(int k) {
//如果没有子结点，则不再下沉
while (2 * k <= N) {
//找出子结点中的较小值的索引
int min = 2 * k;
if (2 * k + 1 <= N && less(2 * k + 1, 2 * k)) {
min = 2 * k + 1;
}
//如果当前结点小于子结点中的较小值，则结束循环
if (less(k, min)) {
break; 
}
//当前结点大，交换
exch(min, k);
k = min;
}
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
MinPriorityQueue<String> minpq = new MinPriorityQueue<>(20);
for (String s : arr) {
minpq.insert(s);
}
System.out.println(minpq.size());
String del;
while(!minpq.isEmpty()){
del = minpq.delMin();
System.out.print(del+",");
}
}
}

1.3 索引优先队列

在之前实现的最大优先队列和最小优先队列，他们可以分别快速访问到队列中最大元素和最小元素，但是他们有一

个缺点，就是没有办法通过索引访问已存在于优先队列中的对象，并更新它们。为了实现这个目的，在优先队列的

基础上，学习一种新的数据结构，索引优先队列。接下来我们以最小索引优先队列举列。

1.3.1 索引优先队列实现思路

步骤一：

存储数据时，给每一个数据元素关联一个整数，例如insert(int k,T t),我们可以看做k是t关联的整数，那么我们的实

现需要通过k这个值，快速获取到队列中t这个元素，此时有个k这个值需要具有唯一性。

最直观的想法就是我们可以用一个T[] items数组来保存数据元素，在insert(int k,T t)完成插入时，可以把k看做是

items数组的索引，把t元素放到items数组的索引k处，这样我们再根据k获取元素t时就很方便了，直接就可以拿到

items[k]即可。

步骤二：

　　步骤一完成后的结果，虽然我们给每个元素关联了一个整数，并且可以使用这个整数快速的获取到该元素，但是，

items数组中的元素顺序是随机的，并不是堆有序的，所以，为了完成这个需求，我们可以增加一个数组int[]pq,来

保存每个元素在items数组中的索引，pq数组需要堆有序，也就是说，pq[1]对应的数据元素items[pq[1]]要小于等

于pq[2]和pq[3]对应的数据元素items[pq[2]]和items[pq[3]]。

步骤三：

通过步骤二的分析，我们可以发现，其实我们通过上浮和下沉做堆调整的时候，其实调整的是pq数组。如果需要

对items中的元素进行修改，比如让items[0]=“H”,那么很显然，我们需要对pq中的数据做堆调整，而且是调整

pq[9]中元素的位置。但现在就会遇到一个问题，我们修改的是items数组中0索引处的值，如何才能快速的知道需

要挑中pq[9]中元素的位置呢？

　　最直观的想法就是遍历pq数组，拿出每一个元素和0做比较，如果当前元素是0，那么调整该索引处的元素即可，

但是效率很低。

　　我们可以另外增加一个数组，int[] qp,用来存储pq的逆序。例如：

在pq数组中：pq[1]=6;

　　那么在qp数组中，把6作为索引，1作为值，结果是：qp[6]=1;

当有了pq数组后，如果我们修改items[0]="H"，那么就可以先通过索引0，在qp数组中找到qp的索引：qp[0]=9,

那么直接调整pq[9]即可。

1.3.2 索引优先队列API设计

1.3.3 索引优先队列代码实现

//最小索引优先队列代码
package cn.itcast;
public class IndexMinPriorityQueue<T extends Comparable<T>> { 
//存储堆中的元素
private T[] items;
//保存每个元素在items数组中的索引，pq数组需要堆有序
private int[] pq;
//保存qp的逆序，pq的值作为索引，pq的索引作为值
private int[] qp;
//记录堆中元素的个数
private int N;
public IndexMinPriorityQueue(int capacity) {
items = (T[]) new Comparable[capacity + 1];
pq = new int[capacity + 1];
qp = new int[capacity + 1];
N = 0;
for (int i = 0; i < qp.length; i++) {
//默认情况下，qp逆序中不保存任何索引
qp[i] = -1;
}
}
//获取队列中元素的个数
public int size() {
return N;
}
//判断队列是否为空
public boolean isEmpty() {
return N == 0;
}
//判断堆中索引i处的元素是否小于索引j处的元素
private boolean less(int i, int j) {
//先通过pq找出items中的索引，然后再找出items中的元素进行对比
return items[pq[i]].compareTo(items[pq[j]]) < 0;
}
//交换堆中i索引和j索引处的值
private void exch(int i, int j) {
//先交换pq数组中的值
int tmp = pq[i];
pq[i] = pq[j];
pq[j] = tmp;
//更新qp数组中的值
qp[pq[i]] = i;
qp[pq[j]] = j;
}
//判断k对应的元素是否存在
public boolean contains(int k) {
//默认情况下，qp的所有元素都为-1，如果某个位置插入了数据，则不为-1
return qp[k] != -1; 
}
//最小元素关联的索引
public int minIndex() {
//pq的索引1处，存放的是最小元素在items中的索引
return pq[1];
}
//往队列中插入一个元素,并关联索引i
public void insert(int i, T t) {
//如果索引i处已经存在了元素，则不让插入
if (contains(i)) {
throw new RuntimeException("该索引已经存在");
}
//个数+1
N++;
//把元素存放到items数组中
items[i] = t;
//使用pq存放i这个索引
pq[N] = i;
//在qp的i索引处存放N
qp[i] = N;
//上浮items[pq[N]],让pq堆有序
swim(N);
}
//删除队列中最小的元素,并返回该元素关联的索引
public int delMin() {
//找到items中最小元素的索引
int minIndex = pq[1];
//交换pq中索引1处的值和N处的值
exch(1, N);
//删除qp中索引pq[N]处的值
qp[pq[N]] = -1;
//删除pq中索引N处的值
pq[N] = -1;
//删除items中的最小元素
items[minIndex] = null;
//元素数量-1
N--;
//对pq[1]做下沉，让堆有序
sink(1);
return minIndex;
}
//删除索引i关联的元素
public void delete(int i) {
//找出i在pq中的索引
int k = qp[i];
//把pq中索引k处的值和索引N处的值交换
exch(k, N);
//删除qp中索引pq[N]处的值 
qp[pq[N]] = -1;
//删除pq中索引N处的值
pq[N] = -1;
//删除items中索引i处的值
items[i] = null;
//元素数量-1
N--;
//对pq[k]做下沉，让堆有序
sink(k);
//对pq[k]做上浮，让堆有序
swim(k);
}
//把与索引i关联的元素修改为为t
public void changeItem(int i, T t) {
//修改items数组中索引i处的值为t
items[i] = t;
//找到i在pq中的位置
int k = qp[i];
//对pq[k]做下沉，让堆有序
sink(k);
//对pq[k]做上浮，让堆有序
swim(k);
}
//使用上浮算法，使索引k处的元素能在堆中处于一个正确的位置
private void swim(int k) {
//如果已经到了根结点，则结束上浮
while (k > 1) {
//比较当前结点和父结点，如果当前结点比父结点小，则交换位置
if (less(k, k / 2)) {
exch(k, k / 2);
}
k = k / 2;
}
}
//使用下沉算法，使索引k处的元素能在堆中处于一个正确的位置
private void sink(int k) {
//如果当前结点已经没有子结点了，则结束下沉
while (2 * k <= N) {
//找出子结点中的较小值
int min = 2 * k;
if (2 * k + 1 <= N && less(2 * k + 1, 2 * k)) {
min = 2 * k + 1;
}
//如果当前结点的值比子结点中的较小值小，则结束下沉
if (less(k, min)) {
break;
}
exch(k, min);
k = min; 
}
}
}
//测试代码
public class Test {
public static void main(String[] args) {
String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
IndexMinPriorityQueue<String> indexMinPQ = new IndexMinPriorityQueue<>(20);
//插入
for (int i = 0; i < arr.length; i++) {
indexMinPQ.insert(i,arr[i]);
}
System.out.println(indexMinPQ.size());
//获取最小值的索引
System.out.println(indexMinPQ.minIndex());
//测试修改
indexMinPQ.changeItem(0,"Z");
int minIndex=-1;
while(!indexMinPQ.isEmpty()){
minIndex = indexMinPQ.delMin();
System.out.print(minIndex+",");
}
}
}

一、平衡树

之前我们学习过二叉查找树，发现它的查询效率比单纯的链表和数组的查询效率要高很多，大部分情况下，确实是

这样的，但不幸的是，在最坏情况下，二叉查找树的性能还是很糟糕。

例如我们依次往二叉查找树中插入9,8,7,6,5,4,3,2,1这9个数据，那么最终构造出来的树是长得下面这个样子：

我们会发现，如果我们要查找1这个元素，查找的效率依旧会很低。效率低的原因在于这个树并不平衡，全部是向

左边分支，如果我们有一种方法，能够不受插入数据的影响，让生成的树都像完全二叉树那样，那么即使在最坏情

况下，查找的效率依旧会很好。

1.1 2-3查找树

为了保证查找树的平衡性，我们需要一些灵活性，因此在这里我们允许树中的一个结点保存多个键。确切的说，我

们将一棵标准的二叉查找树中的结点称为2-结点(含有一个键和两条链)，而现在我们引入3-结点，它含有两个键和

三条链。2-结点和3-结点中的每条链都对应着其中保存的键所分割产生的一个区间。

1.1.1 2-3查找树的定义

一棵2-3查找树要么为空，要么满足满足下面两个要求：

2-结点：

含有一个键(及其对应的值)和两条链，左链接指向2-3树中的键都小于该结点，右链接指向的2-3树中的键都大

于该结点。

3-结点：

含有两个键(及其对应的值)和三条链，左链接指向的2-3树中的键都小于该结点，中链接指向的2-3树中的键都

位于该结点的两个键之间，右链接指向的2-3树中的键都大于该结点。

1.1.2 查找

将二叉查找树的查找算法一般化我们就能够直接得到2-3树的查找算法。要判断一个键是否在树中，我们先将它和

根结点中的键比较。如果它和其中任意一个相等，查找命中；否则我们就根据比较的结果找到指向相应区间的连

接，并在其指向的子树中递归地继续查找。如果这个是空链接，查找未命中。

1.1.3 插入

1.1.3.1 向2-结点中插入新键

　　往2-3树中插入元素和往二叉查找树中插入元素一样，首先要进行查找，然后将节点挂到未找到的节点上。2-3树之

所以能够保证在最差的情况下的效率的原因在于其插入之后仍然能够保持平衡状态。如果查找后未找到的节点是一

个2-结点，那么很容易，我们只需要将新的元素放到这个2-结点里面使其变成一个3-结点即可。但是如果查找的节

点结束于一个3-结点，那么可能有点麻烦。

1.1.3.2 向一棵只含有一个3-结点的树中插入新键

　　假设2-3树只包含一个3-结点，这个结点有两个键，没有空间来插入第三个键了，最自然的方式是我们假设这个结

点能存放三个元素，暂时使其变成一个4-结点，同时他包含四条链接。然后，我们将这个4-结点的中间元素提升，

左边的键作为其左子结点，右边的键作为其右子结点。插入完成，变为平衡2-3查找树，树的高度从0变为1。

1.1.3.3 向一个父结点为2-结点的3-结点中插入新键

　　和上面的情况一样一样，我们也可以将新的元素插入到3-结点中，使其成为一个临时的4-结点，然后，将该结点中

的中间元素提升到父结点即2-结点中，使其父结点成为一个3-结点，然后将左右结点分别挂在这个3-结点的恰当位

置。

1.3.1.4 向一个父结点为3-结点的3-结点中插入新键

　　当我们插入的结点是3-结点的时候，我们将该结点拆分，中间元素提升至父结点，但是此时父结点是一个3-结点，

插入之后，父结点变成了4-结点，然后继续将中间元素提升至其父结点，直至遇到一个父结点是2-结点，然后将其

变为3-结点，不需要继续进行拆分。

1.3.1.5 分解根结点

　　当插入结点到根结点的路径上全部是3-结点的时候，最终我们的根结点会编程一个临时的4-结点，此时，就需要将

根结点拆分为两个2-结点，树的高度加1。

1.3.4 2-3树的性质

通过对2-3树插入操作的分析，我们发现在插入的时候，2-3树需要做一些局部的变换来保持2-3树的平衡。

一棵完全平衡的2-3树具有以下性质：

1.任意空链接到根结点的路径长度都是相等的。

2. 4-结点变换为3-结点时，树的高度不会发生变化，只有当根结点是临时的4-结点，分解根结点时，树高+1。

3. 2-3树与普通二叉查找树最大的区别在于，普通的二叉查找树是自顶向下生长，而2-3树是自底向上生长。

1.3.5 2-3树的实现

直接实现2-3树比较复杂，因为：

需要处理不同的结点类型，非常繁琐；

需要多次比较操作来将结点下移；

需要上移来拆分4-结点；

拆分4-结点的情况有很多种；

2-3查找树实现起来比较复杂，在某些情况插入后的平衡操作可能会使得效率降低。但是2-3查找树作为一种比较重

要的概念和思路对于我们后面要讲到的红黑树、B树和B+树非常重要。

1.2 红黑树

　　我们前面介绍了2-3树，可以看到2-3树能保证在插入元素之后，树依然保持平衡状态，它的最坏情况下所有子结点

都是2-结点，树的高度为lgN,相比于我们普通的二叉查找树，最坏情况下树的高度为N，确实保证了最坏情况下的

时间复杂度，但是2-3树实现起来过于复杂，所以我们介绍一种2-3树思想的简单实现：红黑树。

　　红黑树主要是对2-3树进行编码，红黑树背后的基本思想是用标准的二叉查找树(完全由2-结点构成)和一些额外的信

息(替换3-结点)来表示2-3树。我们将树中的链接分为两种类型：

　　红链接：将两个2-结点连接起来构成一个3-结点；

　　 黑链接：则是2-3树中的普通链接。

确切的说，我们将3-结点表示为由由一条左斜的红色链接(两个2-结点其中之一是另一个的左子结点)相连的两个2-

结点。这种表示法的一个优点是，我们无需修改就可以直接使用标准的二叉查找树的get方法。

1.2.1 红黑树的定义

红黑树是含有红黑链接并满足下列条件的二叉查找树：

1. 红链接均为左链接；

2. 没有任何一个结点同时和两条红链接相连；

3. 该树是完美黑色平衡的，即任意空链接到根结点的路径上的黑链接数量相同；

下面是红黑树与2-3树的对应关系：

1.2.2 红黑树结点API

　　因为每个结点都只会有一条指向自己的链接（从它的父结点指向它），我们可以在之前的Node结点中添加一个布

尔类型的变量color来表示链接的颜色。如果指向它的链接是红色的，那么该变量的值为true，如果链接是黑色

的，那么该变量的值为false。

API设计：

代码：

private class Node<Key,Value>{
//存储键
public Key key;
//存储值
private Value value;
//记录左子结点
public Node left;
//记录右子结点
public Node right;
//由其父结点指向它的链接的颜色
public boolean color;
public Node(Key key, Value value, Node left,Node right,boolean color) {
this.key = key;
this.value = value;
this.left = left;
this.right = right; 
this.color = color;
}
}

1.2.3 平衡化

在对红黑树进行一些增删改查的操作后，很有可能会出现红色的右链接或者两条连续红色的链接，而这些都不满足

红黑树的定义，所以我们需要对这些情况通过旋转进行修复，让红黑树保持平衡。

1.2.3.1 左旋

当某个结点的左子结点为黑色，右子结点为红色，此时需要左旋。

前提：当前结点为h，它的右子结点为x；

左旋过程：

1.让x的左子结点变为h的右子结点：h.right=x.left;

2.让h成为x的左子结点：x.left=h;

3.让h的color属性变为x的color属性值：x.color=h.color;

4.让h的color属性变为RED：h.color=true;

1.2.3.2 右旋

当某个结点的左子结点是红色，且左子结点的左子结点也是红色，需要右旋

前提：当前结点为h，它的左子结点为x；

右旋过程：

1. 让x的右子结点成为h的左子结点：h.left = x.right;

2. 让h成为x的右子结点：x.right=h;

3. 让x的color变为h的color属性值：x.color = h.color;

4.让h的color为RED；

1.2.4 向单个2-结点中插入新键

一棵只含有一个键的红黑树只含有一个2-结点。插入另一个键后，我们马上就需要将他们旋转。

如果新键小于当前结点的键，我们只需要新增一个红色结点即可，新的红黑树和单个3-结点完全等价。

如果新键大于当前结点的键，那么新增的红色结点将会产生一条红色的右链接，此时我们需要通过左旋，把

红色右链接变成左链接，插入操作才算完成。形成的新的红黑树依然和3-结点等价，其中含有两个键，一条红

色链接。

1.2.5 向底部的2-结点插入新键

用和二叉查找树相同的方式向一棵红黑树中插入一个新键，会在树的底部新增一个结点（可以保证有序性），唯一

区别的地方是我们会用红链接将新结点和它的父结点相连。如果它的父结点是一个2-结点，那么刚才讨论的两种方

式仍然适用。

1.2.6 颜色反转

当一个结点的左子结点和右子结点的color都为RED时，也就是出现了临时的4-结点，此时只需要把左子结点和右子

结点的颜色变为BLACK，同时让当前结点的颜色变为RED即可。

1.2.7 向一棵双键树(即一个3-结点)中插入新键

这种情况有可以分为三种子情况：

1. 新键大于原树中的两个键

2. 新键小于原树中的两个键：

3. 新键介于原数中两个键之间：

1.2.8 根结点的颜色总是黑色

之前我们介绍结点API的时候，在结点Node对象中color属性表示的是父结点指向当前结点的连接的颜色，由于根

结点不存在父结点，所以每次插入操作后，我们都需要把根结点的颜色设置为黑色。

1.2.9 向树底部的3-结点插入新键

假设在树的底部的一个3-结点下加入一个新的结点。前面我们所讲的3种情况都会出现。指向新结点的链接可能是

3-结点的右链接（此时我们只需要转换颜色即可），或是左链接(此时我们需要进行右旋转然后再转换)，或是中链

接(此时需要先左旋转然后再右旋转，最后转换颜色)。颜色转换会使中间结点的颜色变红，相当于将它送入了父结

点。这意味着父结点中继续插入一个新键，我们只需要使用相同的方法解决即可，直到遇到一个2-结点或者根结点

为止。

1.2.10 红黑树的API设计

1.2.11 红黑树的实现

//红黑树代码
public class RedBlackTree<Key extends Comparable<Key>, Value> { 
//根节点
private Node root;
//记录树中元素的个数
private int N;
//红色链接
private static final boolean RED = true;
//黑色链接
private static final boolean BLACK = false;
/**
* 判断当前节点的父指向链接是否为红色
*
* @param x
* @return
*/
private boolean isRed(Node x) {
//空结点默认是黑色链接
if (x == null) {
return false;
}
//非空结点需要判断结点color属性的值
return x.color == RED;
}
/**
* 左旋转
*
* @param h
* @return
*/
private Node rotateLeft(Node h) {
//找出当前结点h的右子结点
Node hRight = h.right;
//找出右子结点的左子结点
Node lhRight = hRight.left;
//让当前结点h的右子结点的左子结点成为当前结点的右子结点
h.right = lhRight;
//让当前结点h称为右子结点的左子结点
hRight.left = h;
//让当前结点h的color编程右子结点的color
hRight.color = h.color;
//让当前结点h的color变为RED
h.color = RED;
//返回当前结点的右子结点
return hRight;
}
/**
* 右旋
*
* @param h
* @return
*/
private Node rotateRight(Node h) {
//找出当前结点h的左子结点
Node hLeft = h.left;
//找出当前结点h的左子结点的右子结点
Node rHleft = hLeft.right;
//让当前结点h的左子结点的右子结点称为当前结点的左子结点
h.left = rHleft;
//让当前结点称为左子结点的右子结点
hLeft.right = h;
//让当前结点h的color值称为左子结点的color值
hLeft.color = h.color;
//让当前结点h的color变为RED
h.color = RED;
//返回当前结点的左子结点
return hLeft;
}
/**
* 颜色反转,相当于完成拆分4-节点
*
* @param h
*/
private void flipColors(Node h) {
//当前结点的color属性值变为RED；
h.color = RED;
//当前结点的左右子结点的color属性值都变为黑色
h.left.color = BLACK;
h.right.color = BLACK;
}
/**
* 在整个树上完成插入操作
*
* @param key
* @param val
*/
public void put(Key key, Value val) {
//在root整个树上插入key-val
root = put(root, key, val);
//让根结点的颜色变为BLACK
root.color = BLACK;
}
/**
* 在指定树中，完成插入操作,并返回添加元素后新的树
*
* @param h
* @param key
* @param val
*/
private Node put(Node h, Key key, Value val) {
if (h == null) { 
//标准的插入操作，和父结点用红链接相连
N++;
return new Node(key, val, null, null, RED);
}
//比较要插入的键和当前结点的键
int cmp = key.compareTo(h.key);
if (cmp < 0) {
//继续寻找左子树插入
h.left = put(h.left, key, val);
} else if (cmp > 0) {
//继续寻找右子树插入
h.right = put(h.right, key, val);
} else {
//已经有相同的结点存在，修改节点的值；
h.value = val;
}
//如果当前结点的右链接是红色，左链接是黑色，需要左旋
if (isRed(h.right) && !isRed(h.left)) {
h=rotateLeft(h);
}
//如果当前结点的左子结点和左子结点的左子结点都是红色链接，则需要右旋
if (isRed(h.left) && isRed(h.left.left)) {
h=rotateRight(h);
}
//如果当前结点的左链接和右链接都是红色，需要颜色变换
if (isRed(h.left) && isRed(h.right)) {
flipColors(h);
}
//返回当前结点
return h;
}
//根据key，从树中找出对应的值
public Value get(Key key) {
return get(root, key);
}
//从指定的树x中，查找key对应的值
public Value get(Node x, Key key) {
//如果当前结点为空，则没有找到,返回null
if (x == null) {
return null;
}
//比较当前结点的键和key
int cmp = key.compareTo(x.key);
if (cmp < 0) {
//如果要查询的key小于当前结点的key，则继续找当前结点的左子结点；
return get(x.left, key);
} else if (cmp > 0) {
//如果要查询的key大于当前结点的key，则继续找当前结点的右子结点；
return get(x.right, key);
} else {
//如果要查询的key等于当前结点的key，则树中返回当前结点的value。
return x.value;
}
}
//获取树中元素的个数
public int size() {
return N;
}
//结点类
private class Node {
//存储键
public Key key;
//存储值
private Value value;
//记录左子结点
public Node left;
//记录右子结点
public Node right;
//由其父结点指向它的链接的颜色
public boolean color;
public Node(Key key, Value value, Node left, Node right, boolean color) {
this.key = key;
this.value = value;
this.left = left;
this.right = right;
this.color = color;
}
}
}
//测试代码
public class Test {
public static void main(String[] args) throws Exception {
RedBlackTree<Integer, String> bt = new RedBlackTree<>();
bt.put(4, "二哈");
bt.put(1, "张三");
bt.put(3, "李四");
bt.put(5, "王五");
System.out.println(bt.size());
bt.put(1,"老三");
System.out.println(bt.get(1));
System.out.println(bt.size());
}
}

二、B-树

前面我们已经学习了二叉查找树、2-3树以及它的实现红黑树。2-3树中，一个结点做多能有两个key，它的实现红

黑树中使用对链接染色的方式去表达这两个key。接下来我们学习另外一种树型结构B树，这种数据结构中，一个结

点允许多于两个key的存在。

B树是一种树状数据结构，它能够存储数据、对其进行排序并允许以O(logn)的时间复杂度进行查找、顺序读取、插

入和删除等操作。

1.1 B树的特性

B树中允许一个结点中包含多个key，可以是3个、4个、5个甚至更多，并不确定，需要看具体的实现。现在我们选

择一个参数M，来构造一个B树，我们可以把它称作是M阶的B树，那么该树会具有如下特点：

每个结点最多有M-1个key，并且以升序排列；

每个结点最多能有M个子结点；

根结点至少有两个子结点；

在实际应用中B树的阶数一般都比较大（通常大于100），所以，即使存储大量的数据，B树的高度仍然比较小，这

样在某些应用场景下，就可以体现出它的优势。

2.2 B树存储数据

若参数M选择为5，那么每个结点最多包含4个键值对，我们以5阶B树为例，看看B树的数据存储。

2.3 B树在磁盘文件中的应用

　　在我们的程序中，不可避免的需要通过IO操作文件，而我们的文件是存储在磁盘上的。计算机操作磁盘上的文件是

通过文件系统进行操作的，在文件系统中就使用到了B树这种数据结构。

2.3.1 磁盘

　　磁盘能够保存大量的数据，从GB一直到TB级，但是他的读取速度比较慢，因为涉及到机器操作，读取速度为毫秒

级。

　　磁盘由盘片构成,每个盘片有两面，又称为盘面。盘片中央有一个可以旋转的主轴，他使得盘片以固定的旋转速率

旋转，通常是5400rpm或者是7200rpm,一个磁盘中包含了多个这样的盘片并封装在一个密封的容器内。盘片的每

个表面是由一组称为磁道同心圆组成的，每个磁道被划分为了一组扇区，每个扇区包含相等数量的数据位，通常

是512个子节，扇区之间由一些间隙隔开,这些间隙中不存储数据。

2.3.2 磁盘IO

　　磁盘用磁头来读写存储在盘片表面的位，而磁头连接到一个移动臂上，移动臂沿着盘片半径前后移动，可以将磁头

定位到任何磁道上，这称之为寻道操作。一旦定位到磁道后，盘片转动，磁道上的每个位经过磁头时，读写磁头就

可以感知到该位的值，也可以修改值。对磁盘的访问时间分为寻道时间，旋转时间，以及传送时间。

　　由于存储介质的特性，磁盘本身存取就比主存慢很多，再加上机械运动耗费，因此为了提高效率，要尽量减少磁盘

I/O，减少读写操作。为了达到这个目的，磁盘往往不是严格按需读取，而是每次都会预读，即使只需要一个字

节，磁盘也会从这个位置开始，顺序向后读取一定长度的数据放入内存。这样做的理论依据是计算机科学中著名的

局部性原理：当一个数据被用到时，其附近的数据也通常会马上被使用。由于磁盘顺序读取的效率很高（不需要寻

道时间，只需很少的旋转时间），因此预读可以提高I/O效率。

　　页是计算机管理存储器的逻辑块，硬件及操作系统往往将主存和磁盘存储区分割为连续的大小相等的块，每个存储

块称为一页（1024个字节或其整数倍），预读的长度一般为页的整倍数。主存和磁盘以页为单位交换数据。当程

序要读取的数据不在主存中时，会触发一个缺页异常，此时系统会向磁盘发出读盘信号，磁盘会找到数据的起始位

置并向后连续读取一页或几页载入内存中，然后异常返回，程序继续运行。

　　文件系统的设计者利用了磁盘预读原理，将一个结点的大小设为等于一个页（1024个字节或其整数倍），这样每

个结点只需要一次I/O就可以完全载入。那么3层的B树可以容纳1024*1024*1024差不多10亿个数据，如果换成二

叉查找树，则需要30层！假定操作系统一次读取一个节点，并且根节点保留在内存中，那么B树在10亿个数据中查

找目标值，只需要小于3次硬盘读取就可以找到目标值，但红黑树需要小于30次，因此B树大大提高了IO的操作效

率。

三、 B+树

B+树是对B树的一种变形树，它与B树的差异在于：

1. 非叶结点仅具有索引作用，也就是说，非叶子结点只存储key，不存储value；

2. 树的所有叶结点构成一个有序链表，可以按照key排序的次序遍历全部数据。

2.1 B+树存储数据

若参数M选择为5，那么每个结点最多包含4个键值对，我们以5阶B+树为例，看看B+树的数据存储。

2.2 B+树和B树的对比

B+ 树的优点在于：

1.由于B+树在非叶子结点上不包含真正的数据，只当做索引使用，因此在内存相同的情况下，能够存放更多的

key。 2.B+树的叶子结点都是相连的，因此对整棵树的遍历只需要一次线性遍历叶子结点即可。而且由于数据顺序

排列并且相连，所以便于区间查找和搜索。而B树则需要进行每一层的递归遍历。

B树的优点在于：

由于B树的每一个节点都包含key和value，因此我们根据key查找value时，只需要找到key所在的位置，就能找到

value，但B+树只有叶子结点存储数据，索引每一次查找，都必须一次一次，一直找到树的最大深度处，也就是叶

子结点的深度，才能找到value。

3.3 B+树在数据库中的应用

　　在数据库的操作中，查询操作可以说是最频繁的一种操作，因此在设计数据库时，必须要考虑到查询的效率问题，

　　在很多数据库中，都是用到了B+树来提高查询的效率；

　　在操作数据库时，我们为了提高查询效率，可以基于某张表的某个字段建立索引，就可以提高查询效率，那其实这

个索引就是B+树这种数据结构实现的。

3.3.1 未建立主键索引查询

执行 select * from user where id=18 ,需要从第一条数据开始，一直查询到第6条，发现id=18，此时才能查询出

目标结果，共需要比较6次；

3.3.2 建立主键索引查询

3.3.3 区间查询

　　执行 select * from user where id>=12 and id<=18 ,如果有了索引，由于B+树的叶子结点形成了一个有序链表，

所以我们只需要找到id为12的叶子结点，按照遍历链表的方式顺序往后查即可，效率非常高。

一、并查集

并查集是一种树型的数据结构，并查集可以高效地进行如下操作：

查询元素p和元素q是否属于同一组

合并元素p和元素q所在的组

1.1 并查集结构

并查集也是一种树型结构，但这棵树跟我们之前讲的二叉树、红黑树、B树等都不一样，这种树的要求比较简单：

1. 每个元素都唯一的对应一个结点；

2. 每一组数据中的多个元素都在同一颗树中；

3. 一个组中的数据对应的树和另外一个组中的数据对应的树之间没有任何联系；

4. 元素在树中并没有子父级关系的硬性要求；

1.2 并查集API设计

1.3 并查集的实现

1.3.1 UF(int N)构造方法实现

1. 初始情况下，每个元素都在一个独立的分组中，所以，初始情况下，并查集中的数据默认分为N个组；

2. 初始化数组eleAndGroup；

3. 把eleAndGroup数组的索引看做是每个结点存储的元素，把eleAndGroup数组每个索引处的值看做是该结点

所在的分组，那么初始化情况下，i索引处存储的值就是i

1.3.2 union(int p,int q)合并方法实现

1. 如果p和q已经在同一个分组中，则无需合并

2. 如果p和q不在同一个分组，则只需要将p元素所在组的所有的元素的组标识符修改为q元素所在组的标识符即可

3. 分组数量-1

3.3.3 代码

//并查集代码
public class UF {
//记录结点元素和该元素所在分组的标识
private int[] eleAndGroup;
//记录并查集中数据的分组个数
private int count;
//初始化并查集
public UF(int N){
//初始情况下，每个元素都在一个独立的分组中，所以，初始情况下，并查集中的数据默认分为N个组
this.count=N;
//初始化数组
eleAndGroup = new int[N];
//把eleAndGroup数组的索引看做是每个结点存储的元素，把eleAndGroup数组每个索引处的值看做是该
结点所在的分组，那么初始化情况下，i索引处存储的值就是i
for (int i = 0; i < N; i++) {
eleAndGroup[i]=i;
}
}
//获取当前并查集中的数据有多少个分组
public int count(){
return count;
}
//元素p所在分组的标识符
public int find(int p){
return eleAndGroup[p];
}
//判断并查集中元素p和元素q是否在同一分组中
public boolean connected(int p,int q){
return find(p)==find(q);
}
//把p元素所在分组和q元素所在分组合并
public void union(int p,int q){
//如果p和q已经在同一个分组中，则无需合并；
if (connected(p,q)){
return;
}
//如果p和q不在同一个分组，则只需要将p元素所在组的所有的元素的组标识符修改为q元素所在组的标识
符即可
int pGroup = find(p);
int qGroup = find(q);
for (int i = 0; i < eleAndGroup.length; i++) {
if (eleAndGroup[i]==pGroup){
eleAndGroup[i]=qGroup;
}
}
//分组数量-1
count--;
}
}
//测试代码
public class Test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入并查集中元素的个数:");
int N = sc.nextInt();
UF uf = new UF(N);
while(true){
System.out.println("请录入您要合并的第一个点:");
int p = sc.nextInt();
System.out.println("请录入您要合并的第二个点:");
int q = sc.nextInt();
//判断p和q是否在同一个组
if (uf.connected(p,q)){
System.out.println("结点："+p+"结点"+q+"已经在同一个组");
continue;
}
uf.union(p,q);
System.out.println("总共还有"+uf.count()+"个分组");
}
}
}

1.3.4 并查集应用举例

如果我们并查集存储的每一个整数表示的是一个大型计算机网络中的计算机，则我们就可以通过connected(int

p,int q)来检测，该网络中的某两台计算机之间是否连通？如果连通，则他们之间可以通信，如果不连通，则不能通

信，此时我们又可以调用union(int p,int q)使得p和q之间连通，这样两台计算机之间就可以通信了。

一般像计算机这样网络型的数据，我们要求网络中的每两个数据之间都是相连通的，也就是说，我们需要调用很多

次union方法，使得网络中所有数据相连，其实我们很容易可以得出，如果要让网络中的数据都相连，则我们至少

要调用N-1次union方法才可以，但由于我们的union方法中使用for循环遍历了所有的元素，所以很明显，我们之

前实现的合并算法的时间复杂度是O(N^2)，如果要解决大规模问题，它是不合适的，所以我们需要对算法进行优

化。

1.3.5 UF_Tree算法优化

为了提升union算法的性能，我们需要重新设计fifind方法和union方法的实现，此时我们先需要对我们的之前数据结

构中的eleAndGourp数组的含义进行重新设定：

1.我们仍然让eleAndGroup数组的索引作为某个结点的元素；

2.eleAndGroup[i]的值不再是当前结点所在的分组标识，而是该结点的父结点；

1.3.5.1 UF_Tree API设计

1.3.5.2 fifind(int p)查询方法实现

1.判断当前元素p的父结点eleAndGroup[p]是不是自己，如果是自己则证明已经是根结点了；

2.如果当前元素p的父结点不是自己，则让p=eleAndGroup[p]，继续找父结点的父结点,直到找到根结点为止；

1.3.5.3 union(int p,int q)合并方法实现

1. 找到p元素所在树的根结点

2. 找到q元素所在树的根结点

3. 如果p和q已经在同一个树中，则无需合并；

4. 如果p和q不在同一个分组，则只需要将p元素所在树根结点的父结点设置为q元素的根结点即可；

5. 分组数量-1

1.3.5.4 代码

package cn.itcast;
public class UF_Tree {
//记录结点元素和该元素所的父结点
private int[] eleAndGroup;
//记录并查集中数据的分组个数
private int count;
//初始化并查集
public UF_Tree(int N){
//初始情况下，每个元素都在一个独立的分组中，所以，初始情况下，并查集中的数据默认分为N个组
this.count=N;
//初始化数组
eleAndGroup = new int[N];
//把eleAndGroup数组的索引看做是每个结点存储的元素，把eleAndGroup数组每个索引处的值看做是该
结点的父结点，那么初始化情况下，i索引处存储的值就是i
for (int i = 0; i < N; i++) {
eleAndGroup[i]=i;
}
}
//获取当前并查集中的数据有多少个分组
public int count(){
return count;
}
//元素p所在分组的标识符
public int find(int p){
while(true){
//判断当前元素p的父结点eleAndGroup[p]是不是自己，如果是自己则证明已经是根结点了；
if (p==eleAndGroup[p]){
return p;
}
//如果当前元素p的父结点不是自己，则让p=eleAndGroup[p]，继续找父结点的父结点,直到找到根
结点为止；
p=eleAndGroup[p];
}
}
//判断并查集中元素p和元素q是否在同一分组中
public boolean connected(int p,int q){
return find(p)==find(q);
}
//把p元素所在分组和q元素所在分组合并
public void union(int p,int q){
//找到p元素所在树的根结点
int pRoot = find(p);
//找到q元素所在树的根结点
int qRoot = find(q);
//如果p和q已经在同一个树中，则无需合并；
if (pRoot==qRoot){
return;
}
//如果p和q不在同一个分组，则只需要将p元素所在树根结点的父结点设置为q元素的根结点即可；
eleAndGroup[pRoot]=qRoot;
//分组数量-1
count--;
} 
}

1.3.5.5 优化后的性能分析

我们优化后的算法union，如果要把并查集中所有的数据连通，仍然至少要调用N-1次union方法，但是，我们发现

union方法中已经没有了for循环，所以union算法的时间复杂度由O(N^2)变为了O(N)。

但是这个算法仍然有问题，因为我们之前不仅修改了union算法，还修改了fifind算法。我们修改前的fifind算法的时

间复杂度在任何情况下都为O(1)，但修改后的fifind算法在最坏情况下是O(N)：

在union方法中调用了fifind方法，所以在最坏情况下union算法的时间复杂度仍然为O(N^2)。

1.3.6 路径压缩

　　UF_Tree中最坏情况下union算法的时间复杂度为O(N^2)，其最主要的问题在于最坏情况下，树的深度和数组的大

小一样，如果我们能够通过一些算法让合并时，生成的树的深度尽可能的小，就可以优化fifind方法。

　　之前我们在union算法中，合并树的时候将任意的一棵树连接到了另外一棵树，这种合并方法是比较暴力的，如果

我们把并查集中每一棵树的大小记录下来，然后在每次合并树的时候，把较小的树连接到较大的树上，就可以减小

树的深度。

　　只要我们保证每次合并，都能把小树合并到大树上，就能够压缩合并后新树的路径，这样就能提高fifind方法的效

率。为了完成这个需求，我们需要另外一个数组来记录存储每个根结点对应的树中元素的个数，并且需要一些代码

调整数组中的值。

1.3.6.1 UF_Tree_Weighted API设计

1.3.6.2 代码

public class UF_Tree_Weighted {
//记录结点元素和该元素所的父结点
private int[] eleAndGroup;
//存储每个根结点对应的树中元素的个数
private int[] sz;
//记录并查集中数据的分组个数
private int count;
//初始化并查集
public UF_Tree_Weighted(int N){
//初始情况下，每个元素都在一个独立的分组中，所以，初始情况下，并查集中的数据默认分为N个组
this.count=N;
//初始化数组
eleAndGroup = new int[N];
sz = new int[N];
//把eleAndGroup数组的索引看做是每个结点存储的元素，把eleAndGroup数组每个索引处的值看做是该
结点的父结点，那么初始化情况下，i索引处存储的值就是i
for (int i = 0; i < N; i++) {
eleAndGroup[i]=i;
}
//把sz数组中所有的元素初始化为1，默认情况下，每个结点都是一个独立的树，每个树中只有一个元素
for (int i = 0; i < sz.length; i++) {
sz[i]=1;
}
}
//获取当前并查集中的数据有多少个分组
public int count(){
return count;
}
//元素p所在分组的标识符
public int find(int p){
while(true){
//判断当前元素p的父结点eleAndGroup[p]是不是自己，如果是自己则证明已经是根结点了；
 

if (p==eleAndGroup[p]){
return p;
}
//如果当前元素p的父结点不是自己，则让p=eleAndGroup[p]，继续找父结点的父结点,直到找到根
结点为止；
p=eleAndGroup[p];
}
}
//判断并查集中元素p和元素q是否在同一分组中
public boolean connected(int p,int q){
return find(p)==find(q);
}
//把p元素所在分组和q元素所在分组合并
public void union(int p,int q){
//找到p元素所在树的根结点
int pRoot = find(p);
//找到q元素所在树的根结点
int qRoot = find(q);
//如果p和q已经在同一个树中，则无需合并；
if (pRoot==qRoot){
return;
}
//如果p和q不在同一个分组，比较p所在树的元素个数和q所在树的元素个数,把较小的树合并到较大的树
上
if (sz[pRoot]<sz[qRoot]){
eleAndGroup[pRoot] = qRoot;
//重新调整较大树的元素个数
sz[qRoot]+=sz[pRoot];
}else{
eleAndGroup[qRoot]=pRoot;
sz[pRoot]+=sz[qRoot];
}
//分组数量-1
count--;
}
}

1.3.7 案例-畅通工程

某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目

标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问

最少还需要建设多少条道路？

在我们的测试数据文件夹中有一个trffiffiffic_project.txt文件，它就是诚征道路统计表，下面是对数据的解释：

总共有20个城市，目前已经修改好了7条道路，问还需要修建多少条道路，才能让这20个城市之间全部相通？

解题思路：

1.创建一个并查集UF_Tree_Weighted(20);

2.分别调用union(0,1),union(6,9),union(3,8),union(5,11),union(2,12),union(6,10),union(4,8)，表示已经修建好的

道路把对应的城市连接起来；

3.如果城市全部连接起来，那么并查集中剩余的分组数目为1，所有的城市都在一个树中，所以，只需要获取当前

并查集中剩余的数目，减去1，就是还需要修建的道路数目；

代码：

public class Traffic_Project {
public static void main(String[] args)throws Exception {
//创建输入流
BufferedReader reader = new BufferedReader(new
InputStreamReader(Traffic_Project.class.getClassLoader().getResourceAsStream("traffic_projec
t.txt")));
//读取城市数目，初始化并查集
int number = Integer.parseInt(reader.readLine());
UF_Tree_Weighted uf = new UF_Tree_Weighted(number);
//读取已经修建好的道路数目
int roadNumber = Integer.parseInt(reader.readLine());
//循环读取已经修建好的道路，并调用union方法
for (int i = 0; i < roadNumber; i++) {
String line = reader.readLine();
int p = Integer.parseInt(line.split(" ")[0]);
int q = Integer.parseInt(line.split(" ")[1]);
uf.union(p,q);
}
//获取剩余的分组数量
int groupNumber = uf.count();
//计算出还需要修建的道路
System.out.println("还需要修建"+(groupNumber-1)+"道路，城市才能相通");
}
}

【数据结构】线段树（Segment Tree）

假设我们现在拿到了一个非常大的数组，对于这个数组里面的数字要反复不断地做两个操作。

1、（query）随机在这个数组中选一个区间，求出这个区间所有数的和。

2、（update）不断地随机修改这个数组中的某一个值。

时间复杂度：

枚举：

枚举L~R的每个数并累加。

query：O（n）

找到要修改的数直接修改。

update：O（1）

如果query与update要做很多很多次，query的O（n）会被卡住，所以时间复杂度会非常慢。那么有没有办法把query的时间复杂度降成O（1）呢？其中一种方法如下：

先建立一个与a数组一样大的数组。

s[1]=a[1];s[2]=a[1]+a[2];s[3]=a[1]+a[2]+a[3];...;s[n]=a[1]+a[2]+a[3]+...+a[n]（在s数组中存入a的前缀和）

此时a[L]+a[L+1]+...+a[R]=s[R]-s[L-1]，query的时间复杂度降为O（1）。
但若要修改a[k]的值，随之也需修改s[k],s[k+1],...,s[n]的值，时间复杂度升为O（n）。

前缀和：

query：O（1）

update：O（n）

我们发现，当我们想尽方法把其中一个操作的时间复杂度改成O（1）后，另一个操作的时间复杂度就会变为O（n）。当query与update的操作特别多时，不论用哪种方法，总体的时间复杂度都不会特别快。
所以，我们将要讨论一种叫线段树的数据结构，它可以把这两个操作的时间复杂度平均一下，使得query和update的时间复杂度都落在O（n log n）上，从而增加整个算法的效率。

线段树

假设我们拿到了如下长度为6的数组：

在构建线段树之前，我们先阐述线段树的性质：

1、线段树的每个节点都代表一个区间。

2、线段树具有唯一的根节点，代表的区间是整个统计范围，如[1,N]。

3、线段树的每个叶节点都代表一个长度为1的元区间[x,x]。

4、对于每个内部节点[l,r]，它的左子结点是[l,mid]，右子节点是[mid+1,r]，其中mid=(l+r)/2（向下取整）。

依照这个数组，我们构建如下线段树（结点的性质为sum）：

若我们要求[2-5]区间中数的和：

若我们要把a[4]改为6：

先一层一层找到目标节点修改，在依次向上修改当前节点的父节点。

接下来的问题是：如何保存这棵线段树？

用数组存储。

若我们要取node结点的左子结点（left）与右子节点（right），方法如下：

left=2*node+1
right=2*ndoe+2

举结点5为例（左子结点为节点11，右子节点为节点12）：

left₅=2*5+1=11
right₅=2*5+2=12

接下来给出建树的代码：

#include<bits/stdc++.h>
using namespace std; 

const int N = 1000;

int a[] = {1, 3, 5, 7, 9, 11};
int size = 6;
int tree[N] = {0};

//建立范围为a[start]~a[end] 
void build(int a[], int tree[], int node/*当前节点*/, int start, int end){
    //递归边界(即遇到叶子节点时) 
    if (start == end){
        //直接存储a数组中的值 
        tree[node] = a[start];
    } 

    else {
        //将建立的区间分成两半 
        int mid = (start + end) / 2;
     
        int left  = 2 * node + 1;//左子节点的下标 
        int right = 2 * node + 2;//右子节点的下标 
        
        //求出左子节点的值(即从节点left开始,建立范围为a[start]~a[mid])
        build(a, tree, left,  start, mid);
        //求出右子节点的值(即从节点right开始,建立范围为a[start]~a[mid])
        build(a, tree, right, mid+1, end);
    
        //当前节点的职位左子节点的值加上右子节点的值 
        tree[node] = tree[left] + tree[right];
    }
}

int main(){
    //从根节点(即节点0)开始建树,建树范围为a[0]~a[size-1]
    build(a, tree, 0, 0, size-1);
    
    for(int i = 0; i <= 14; i ++)
        printf("tree[%d] = %d\n", i, tree[i]);
        
    return 0;
}

运行结果：

update操作：

确定需要改的分支，向下寻找需要修改的节点，再向上修改节点值。
与建树的函数相比，update函数增加了两个参数x，val，即把a[x]改为val。

例：把a[x]改为6（代码实现）

void update(int a[], int tree[], int node, int start, int end, int x, int val){
    //找到a[x],修改值 
    if (start == end){
        a[x] = val;
        tree[node] = val;
    }
    
    else {
        int mid = (start + end) / 2;
    
        int left  = 2 * node + 1;
        int right = 2 * node + 2;
    
        if (x >= start && x <= mid) {//如果x在左分支 
            update(a, tree, start, mid, x, val);
        }
        else {//如果x在右分支 
            update(a, tree, right, mid+1, end, x, val);
        }
        
        //向上更新值 
        tree[node] = tree[left] + tree[right]; 
    } 
}

在主函数中调用：
//把a[x]改成6
update(a, tree, 0, 0, size-1, 4, 6);

运行结果：

query操作：

向下依次寻找包含在目标区间中的区间，并累加。
与建树的函数相比，query函数增加了两个参数L，Rl，即把求a的区间[L,R]的和。

例：求a[2]+a[3]+...+a[5]的值（代码实现）

int query(int a[], int tree[], int node, int start, int end, int L,int R){
    //若目标区间与当时区间没有重叠,结束递归返回0 
    if (start > R || end < L){
        return 0;
    }
    
    //若目标区间包含当时区间,直接返回节点值 
    else if (L <=start && end <= R){
        return tree[node];
    }
    
    else {
        int mid = (start + end) / 2;
    
        int left  = 2 * node + 1;
        int right = 2 * node + 2;
    
        //计算左边区间的值 
        int sum_left  = query(a, tree, left,  start, mid, L, R);
        //计算右边区间的值 
        int sum_right = query(a, tree, right, mid+1, end, L, R);
        
        //相加即为答案 
        return sum_left + sum_right;
    } 
}

在主函数中调用：
//求区间[2,5]的和
int ans = query(a, tree, 0, 0, size-1, 2, 5);
printf("ans = %d", ans);

运行结果：

最后，献上完整的代码：

#include<bits/stdc++.h>
using namespace std; 

const int N = 1000;

int a[] = {1, 3, 5, 7, 9, 11};
int size = 6;
int tree[N] = {0};

//建立范围为a[start]~a[end] 
void build(int a[], int tree[], int node/*当前节点*/, int start, int end){
    //递归边界(即遇到叶子节点时) 
    if (start == end) {
        //直接存储a数组中的值 
        tree[node] = a[start];
    } 

    else {
        //将建立的区间分成两半 
        int mid = (start + end) / 2;
     
        int left  = 2 * node + 1;//左子节点的下标 
        int right = 2 * node + 2;//右子节点的下标 
        
        //求出左子节点的值(即从节点left开始,建立范围为a[start]~a[mid])
        build(a, tree, left,  start, mid);
        //求出右子节点的值(即从节点right开始,建立范围为a[start]~a[mid])
        build(a, tree, right, mid+1, end);
    
        //当前节点的职位左子节点的值加上右子节点的值 
        tree[node] = tree[left] + tree[right];
    }
}

void update(int a[], int tree[], int node, int start, int end, int x, int val){
    //找到a[x],修改值 
    if (start == end){
        a[x] = val;
        tree[node] = val;
    }
    
    else {
        int mid = (start + end) / 2;
    
        int left  = 2 * node + 1;
        int right = 2 * node + 2;
    
        if (x >= start && x <= mid) {//如果x在左分支 
            update(a, tree, left, start, mid, x, val);
        }
        else {//如果x在右分支 
            update(a, tree, right, mid+1, end, x, val);
        }
        
        //向上更新值 
        tree[node] = tree[left] + tree[right]; 
    } 
}

//求a[L]~a[R]的区间和 
int query(int a[], int tree[], int node, int start, int end, int L,int R){
    //若目标区间与当时区间没有重叠,结束递归返回0 
    if (start > R || end < L){
        return 0;
    }
    
    //若目标区间包含当时区间,直接返回节点值 
    else if (L <=start && end <= R){
        return tree[node];
    }
    
    else {
        int mid = (start + end) / 2;
    
        int left  = 2 * node + 1;
        int right = 2 * node + 2;
    
        //计算左边区间的值 
        int sum_left  = query(a, tree, left,  start, mid, L, R);
        //计算右边区间的值 
        int sum_right = query(a, tree, right, mid+1, end, L, R);
        
        //相加即为答案 
        return sum_left + sum_right;
    } 
}

int main(){
    //从根节点(即节点0)开始建树,建树范围为a[0]~a[size-1]
    build(a, tree, 0, 0, size-1);
    
    for(int i = 0; i <= 14; i ++)
        printf("tree[%d] = %d\n", i, tree[i]);
    printf("\n");    
        
    //把a[x]改成6
    update(a, tree, 0, 0, size-1, 4, 6); 
    
    for(int i = 0; i <= 14; i ++)
        printf("tree[%d] = %d\n", i, tree[i]);
    printf("\n");
    
    //求区间[2,5]的和
    int ans = query(a, tree, 0, 0, size-1, 2, 5);
    printf("ans = %d", ans); 
            
    return 0;
}

运行结果：

https://www.cnblogs.com/zhengchang/p/xianduanshu.html

posted @ 2021-07-29 18:10 wq9 阅读(230) 评论(0) 收藏举报

刷新页面返回顶部