From eca211499ac69e016651c1aa07251f6f3261700c Mon Sep 17 00:00:00 2001
From: Lee <501648152@qq.com>
Date: Fri, 1 Sep 2017 09:26:16 +0800
Subject: [PATCH] New File:Algorithm.md

---
 Algorithm.md          | 2178 +++++++++++++++++++++++++++++++++++++++++
 assets/algorithm1.gif |  Bin 0 -> 57313 bytes
 2 files changed, 2178 insertions(+)
 create mode 100644 Algorithm.md
 create mode 100644 assets/algorithm1.gif

diff --git a/Algorithm.md b/Algorithm.md
new file mode 100644
index 0000000..4a5a11e
--- /dev/null
+++ b/Algorithm.md
@@ -0,0 +1,2178 @@
+# 数据结构和算法
+
+该文章来自[我](https://www.github.com/lisongting) 的[https://github.com/lisongting/preparation](https://github.com/lisongting/preparation) ，这个preparation是我整理的一些面试知识点，其中有些内容和图片是来自知名博客，有些内容是我自己总结的。我打算逐渐将preparation中的内容推到[该项目](https://github.com/lisongting/android-interview-questions-cn)中，供更多人学习参考。欢迎提Issue和Pull Request.
+
+进入主题，该文档包含了以下算法的Java实现:
+
+<h3 id="index">目录</h3>
+
+* [1.表](#1)
+  * [1.1顺序表](#1.1)
+  * [1.2单链表](#1.2)
+  * [1.3双链表](#1.3)
+* [2.栈和队列](#2)
+   * [2.1顺序栈](#2.1)
+   * [2.2链式栈](#2.2)
+   * [2.3循环队列](#2.3)
+* [3.树](#3)
+   * [3.1普通二叉树](#3.1)
+   * [3.2二叉搜索树](#3.2)
+* [4.排序](#4)
+   * [4.1冒泡排序](#4.1)
+   * [4.2快速排序](#4.2)
+   * [4.3直接选择排序](#4.3)
+   * [4.4堆排序](#4.4)
+   * [4.5直接插入排序](#4.5)
+   * [4.6折半插入排序](#4.6)
+   * [4.7希尔排序](#4.7)
+   * [4.8归并排序](#4.8)
+   * [4.9基数排序](#4.9)
+   * [4.10复杂度比较](#4.10)
+* [5.查找](#5)
+   * [5.1朴素查找](#5.1)
+   * [5.2KMP](#5.2)
+
+<h2  id='1'>1.表</h2>
+
+<h3 id='1.1'>1.1顺序表</h3>
+
+```java
+import java.util.Arrays;
+
+public class SequenceList<T> {
+	private int DEFAULT_SIZE = 16;
+	private int capacity;
+	private Object[] elementData;
+	private int size = 0;
+	public SequenceList(){
+		capacity = DEFAULT_SIZE;
+		elementData = new Object[capacity];
+	}
+	public SequenceList(T element){
+		this();
+		elementData[0] = element;
+		size ++;
+	}
+	//初始化第一个元素，以指定大小创建List
+	public SequenceList(T element,int initSize){
+		capacity = 1;
+		//把capacity设为大于initSize的数，并且为2的n次方
+		while(capacity < initSize){
+			capacity = capacity * 2;
+		}
+		elementData = new Object[capacity];
+		elementData[0] = element;
+		size++;
+	}
+	public int length(){
+		return size;
+	}
+	public T get(int index){
+		if(index<0||index>size-1){
+			throw new IndexOutOfBoundsException("线性表索引越界");
+		}
+		return (T) elementData[index];
+	}
+	public int locate(T element){
+		for(int i=0;i<size;i++){
+			if(elementData[i].equals(element)){
+				return i;
+			}
+		}
+		return -1;
+	}
+	//向指定位置插入元素
+	public void insert(int index,T element){
+		if(index < 0 || index > size){
+			throw new IndexOutOfBoundsException("线性表索引越界");
+		}
+
+		ensureCapacity(size+1);
+		size ++;
+		//把index位置以后的元素都向后移
+		for(int i=size-1;i>index;i--){
+			elementData[i] = elementData[i-1];
+		}
+		elementData[index] = element;
+	}
+
+	//删除指定下标位置的元素
+	public void delete(int index){
+		if(index < 0 ||index> size-1){
+			throw new IndexOutOfBoundsException("线性表索引越界");
+		}
+		//把从指定位置的元素都往前移动
+		for(int i = index;i<size-1;i++){
+			elementData[i] = elementData[i+1];
+		}
+		elementData[size-1]=null;
+		size --;
+	}
+	//往末尾插入一个元素
+	public void add(T element){
+		insert(size,element);
+	}
+	public void remove(){
+		delete(size-1);
+	}
+	public boolean isEmpty(){
+		return size==0;
+	}
+	public void clear(){
+		for(int i=0;i<size;i++){
+			elementData[i] = null;
+		}
+		size = 0;
+	}
+	public String toString(){
+		if(size==0){
+			return "[]";
+		}else{
+			StringBuilder sb = new StringBuilder("[");
+			for(int i=0;i<size;i++){
+				sb.append(elementData[i].toString()+"  ");
+			}
+			sb.append(']');
+			return sb.toString();
+		}
+	}
+	//扩充底层数组的长度以确保数组容量够用
+	public void ensureCapacity(int needCapacity){
+		while(needCapacity > capacity){
+			capacity *= 2;
+		}
+		elementData = Arrays.copyOf(elementData, capacity);
+	}
+	public static void main(String[] args){
+		SequenceList<String> list = new SequenceList<>();
+		list.add("aaaa");
+		list.add("bbbb");
+		list.add("cccc");
+		System.out.println(list.get(2));
+		System.out.println(list.toString());
+		list.insert(1, "tttt");
+		System.out.println(list.toString());
+		list.delete(0);
+		System.out.println(list.toString());
+		System.out.println("tttt在线性表中的位置是:"+list.locate("tttt"));
+	}
+}
+```
+[回到目录](#index)
+
+<h3 id='1.2'>1.2单链表</h3>
+
+```java
+public class LinkList<T> {
+	//定义一个内部类
+	private class Node{
+		private T data;
+		private Node next;
+		public Node(){};
+		public Node(T data,Node next){
+			this.data = data;
+			this.next = next;
+		}
+	}
+	private Node header;
+	private Node tail;
+	private int size = 0;
+	public LinkList(){
+		//空链表
+		header = tail = null;
+	}
+	public LinkList(T element){
+		header = new Node(element,null);
+		tail = header;
+		size++;
+	}
+	public int length(){
+		return size;
+	}
+	//根据索引查找指定位置的节点
+	public Node getNodeByIndex(int index){
+		if(index < 0||index >size-1){
+			throw new IndexOutOfBoundsException("链表索引越界");
+		}
+		Node current = header;
+		for(int i=0;i < size && current!=null;i++){
+			if(i == index){
+				return current;
+			}
+			current = current.next;
+		}
+		return null;
+	}
+	//根据节点返回所在的位置
+	public int locate(T element){
+		Node current = header;
+		for(int i=0;i<size && current!= null;i++){
+			if(element.equals(current.data)){
+				return i;
+			}
+			current = current.next;
+		}
+		return -1;
+	}
+	//[重要]向指定下标处插入元素
+	public void insert(int index,T element){
+		if(index < 0 || index>size){
+			throw new IndexOutOfBoundsException("链表索引越界");
+		}
+		if(header == null){
+			add(element);
+		}else{
+			if(index==0){
+				addAtHeader(element);				
+			}else{
+				//获取插入节点的前一个节点
+				Node prev = getNodeByIndex(index -1);
+				//prev的next指向新节点
+				//让新节点的next指向原来prev的下一个节点
+				prev.next = new Node(element,prev.next);
+				size++;
+			}
+		}
+
+	}
+	public void add(T element){
+		if(header == null){
+			header = new Node(element,null);
+			tail = header;
+		}else{
+			Node newNode = new Node(element,null);
+			tail.next = newNode;
+			tail = newNode;
+		}
+		size ++;
+	}
+	public void addAtHeader(T element){
+		Node tmp = new Node(element,header);
+		header = tmp;
+		//如果在插入之前是空链表
+		if(tail == null){
+			tail = header;
+		}
+		size ++;
+	}
+	//[重要]删除指定索引处的元素
+	public void delete(int index){
+		if(index < 0 || index>size-1){
+			throw new IndexOutOfBoundsException("链表索引越界");
+		}
+		Node del = null;
+		//如果被删除的是头节点
+		if(index ==0){
+			header = null;
+			header = header.next;
+		}else{
+			//获取删除节点的前一个节点
+			Node prev = getNodeByIndex(index-1);
+			//获取将要被删除的节点
+			del = prev.next;
+			prev.next = del.next;
+			del = null;
+		}
+		size --;
+	}
+	public void remove(){
+		delete(size -1);
+	}
+	public boolean isEmpty(){
+		return size ==0;
+	}
+	public void clear(){
+		Node current = header;
+		for(int i=0;i<size && current != null;i++){
+			Node nextNode = current.next;
+			current = null;
+			current = nextNode;
+		}
+		size = 0;
+	}
+	public String toString(){
+		if(isEmpty()){
+			return "[]";
+		}else{
+			StringBuilder sb = new StringBuilder("[");
+			Node current = header;
+			for(int i=0;i<size && current !=null;i++){
+				sb.append(current.data+"  ");
+				current = current.next;
+			}
+			sb.append("]");
+			return sb.toString();
+		}
+
+	}
+	public static void main(String[] args) {
+		LinkList<String> list = new LinkList<>();
+		list.insert(0, "aaaa");
+		list.add("bbbb");
+		list.add("wwww");
+		System.out.println(list.toString());
+		list.addAtHeader("cccc");
+		System.out.println(list.toString());
+		System.out.println("1号位置是"+list.getNodeByIndex(1).data);
+		list.delete(1);
+		System.out.println(list.toString());
+		System.out.println("wwww在链表中的位置是："+list.locate("wwww"));
+
+	}
+
+}
+
+```
+[回到目录](#index)
+
+
+<h3 id='1.3'>1.3双链表</h3>
+
+```java
+package list;
+
+
+//双链表
+public class DoubleLinkList<T> {
+
+	private class Node{
+		private T data;
+		private Node prev;
+		private Node next;
+		public Node(){};
+		public Node(T data,Node prev,Node next){
+			this.data = data;
+			this.prev = prev;
+			this.next = next;
+		}
+	}
+	private Node header;
+	private Node tail;
+	private int size = 0;
+	public DoubleLinkList(){
+		header = tail = null;
+	}
+	public DoubleLinkList(T element){
+		header  = new Node(element,null,null);
+		tail = header;
+		size ++;
+	}
+	public int length(){
+		return size;
+	}
+	public boolean isEmpty(){
+		return 0 == size;
+	}
+	//获取下标为index的节点的值
+	public T get(int index){
+		return getNodeByIndex(index).data;
+	}
+	//根据索引查找节点
+	public Node getNodeByIndex(int index){
+		if(index < 0 || index > size-1){
+			throw new IndexOutOfBoundsException("链表索引越界");
+		}
+		if(index <= size/2){
+			Node current = header;
+			for(int i=0;i<=size/2 && current != null;i++){
+				if(i == index){
+					return current;
+				}
+				current = current.next;
+			}
+		}else{
+			Node current = tail;
+			for(int i=size -1;i>size/2&&current!=null ;i++){
+				if(i == index){
+					return current;
+				}
+				current = current.prev;
+			}
+		}
+		return null;
+	}
+
+	//根据值查找索引值
+	public int locate(T element){
+		Node current = header;
+		for(int i=0;i<size && current != null;i++){
+			if(element.equals(current.data)){
+				return i;
+			}
+			current = current.next;
+		}
+		return -1;
+	}
+	//[重要]向指定索引处插入插入元素
+	public void insert(T element,int index){
+		if(index < 0 || index > size-1){
+			throw new IndexOutOfBoundsException("链表索引越界");
+		}
+		if(header == null){
+			add(element);
+		}else{
+			if(index ==0){
+				addAtHeader(element);
+			}else{
+				//获取插入点的前一个节点
+				Node prev = getNodeByIndex(index-1);
+				//获取当前index处的节点
+				Node next = prev.next;
+				Node newNode = new Node(element,prev,next);
+				prev.next = newNode;
+				next.prev = newNode;
+				size++;
+			}
+		}
+
+	}
+	//在末尾插入元素
+	public void add(T element){
+		if(header ==null){
+			header = new Node(element,null,null);
+			tail = header;
+		}else{
+			Node newNode = new Node(element,tail,null);
+			tail.next = newNode;
+			tail = newNode;
+		}
+		size ++;
+	}
+	public void addAtHeader(T element){
+		Node newNode = new Node(element,null,header);
+		header = newNode;
+		//如果插入之前是空链表
+		if(tail == null){
+			tail = header;
+		}
+		size++;
+	}
+	//[重要]删除指定索引处的节点
+	public void delete(int index){
+		if(index < 0 || index > size-1){
+			throw new IndexOutOfBoundsException("链表索引越界");
+		}
+		//如果要删除的是头节点
+		if(index == 0){
+			header = header.next;
+			header.prev = null;
+		}else if(index == size -1){//如果要删除尾节点
+			Node prevNode = tail.prev;
+			tail = null;
+			prevNode.next=null;
+			tail = prevNode;
+		}else{
+			//找到index位置之前的节点
+			Node prevNode = getNodeByIndex(index-1);
+			Node delNode = prevNode.next;
+			Node nextNode = delNode.next;
+			delNode =null;
+			prevNode.next = nextNode;
+			nextNode.prev = prevNode;
+		}
+		size --;
+	}
+	//删除最后一个节点
+	public void remove(){
+		delete(size-1);
+	}
+	public void clear(){
+		Node current = header;
+		for(int i=0;i<size && current != null;i++){
+			Node nextNode = current.next;
+			current = null;
+			current = nextNode;
+		}
+		size = 0;
+	}
+	public String toString(){
+		if(isEmpty()){
+			return "[]";
+		}else{
+			StringBuilder sb = new StringBuilder("[");
+			Node current = header;
+			for(int i=0;i<size && current !=null;i++){
+				sb.append(current.data+"  ");
+				current = current.next;
+			}
+			sb.append("]");
+			return sb.toString();
+		}
+	}
+	public static void main(String[] args) {
+		DoubleLinkList<String> list = new DoubleLinkList<>();
+		list.add("aaa");
+		list.add("bbb");
+		list.insert("www", 1);
+		System.out.println(list.toString());
+		list.addAtHeader("ccc");
+		System.out.println(list.toString());
+		System.out.println("1号位置的元素是"+list.get(1));
+		list.delete(2);
+		System.out.println("调用delete(2)之后的链表："+list.toString());
+		list.remove();
+		System.out.println("调用remove()之后的链表："+list.toString());
+		list.add("ttt");
+		System.out.println("插入ttt之后"+list.toString());
+		System.out.println("ttt存放的索引值是:"+list.locate("ttt"));
+		list.clear();
+		System.out.println("清空链表之后 ,再次打印："+list.toString());
+	}
+
+}
+```
+[回到目录](#index)
+
+<h2 id="2">2.栈和队列</h2>
+
+<h3 id="2.1">2.1顺序栈</h3>
+
+```java
+import java.util.Arrays;
+
+public class SequenceStack<T> {
+	private int DEFAULT_SIZE = 10;
+	private int capacity;
+	//程序每次增加的数组长度
+	private int capacityIncrement = 0;
+	private Object[] elementData;
+	private int size = 0;
+	public SequenceStack(){
+		capacity = DEFAULT_SIZE;
+		elementData = new Object[capacity];
+	};
+	//以第一个初始元素来构造顺序栈
+	public SequenceStack(T element){
+		this();
+		elementData[0] = element;
+		size ++;
+	}
+	public SequenceStack(T element,int initSize){
+		this.capacity = initSize;
+		elementData = new Object[capacity];
+		elementData[0] = element;
+		size ++;
+	}
+	//以指定数组长度以及增量来创建顺序栈
+	public SequenceStack(T element,int initSize, int increment){
+		this.capacity = initSize;
+		this.capacityIncrement = increment;
+		elementData = new Object[capacity];
+		elementData[0] = element;
+		size++;
+	}
+	public int length(){
+		return size;
+	}
+	public boolean isEmpty(){
+		return 0 == size;
+	}
+	//[重要]入栈
+	public void push(T element){
+		ensureCapacity(size+1);
+		elementData[size] = element;
+		size++;
+	}
+	//确保容量
+	public void ensureCapacity(int needCapacity){
+		if(needCapacity > capacity){
+				if(capacityIncrement > 0){
+					while(needCapacity > capacity){
+						capacity += capacityIncrement;
+					}
+				}else{
+					while(needCapacity > capacity){
+						capacity *= 2;
+					}
+				}
+		}
+		elementData = Arrays.copyOf(elementData, capacity);
+	}
+	//入栈
+	public T pop(){
+		T tmp = (T) elementData[size-1];
+		elementData[size - 1] =null;
+		size--;
+		return tmp;
+	}
+	//返回栈顶元素，但不删除
+	public T peek(){
+		return (T) elementData[size-1];
+	}
+	public void clear(){
+		for(int i=0;i<size;i++){
+			elementData[i] = null;
+		}
+		size = 0;
+	}
+	public String toString(){
+		if(size == 0){
+			return "[]";
+		}
+		StringBuilder sb = new StringBuilder("[");
+		for(int i=0;i<size;i++){
+			sb.append(elementData[i]+" ");
+		}
+		sb.append(']');
+		return sb.toString();
+	}
+	public static void main(String[] args){
+		SequenceStack<String> stack = new SequenceStack<>();
+		stack.push("aaaa");
+		stack.push("bbbb");
+		System.out.println("此时栈顶元素是："+stack.peek());
+		stack.push("cccc");
+		System.out.println("自底向上栈内的元素为："+stack.toString());
+		stack.pop();
+		System.out.println("出栈后栈内的元素为："+stack.toString());
+		stack.push("eeee");
+		stack.push("tttt");
+		System.out.println("自底向上栈内的元素为："+stack.toString());
+		stack.clear();
+		System.out.println("清空后栈内的元素为："+stack.toString());
+	}
+}
+
+```
+[回到目录](#index)
+
+<h3 id="2.2">2.2链式栈</h3>
+
+```java
+public class LinkStack<T> {
+	private class Node{
+		private T data;
+		private Node next;//该next是往栈底指
+		public Node(){};
+		public Node(T element){
+			data = element;
+		}
+		public Node(T data,Node next){
+			this.data = data;
+			this.next = next;
+		}
+	}
+	//栈顶元素
+	private Node top;
+	private int size = 0;
+	public LinkStack(){
+		top = null;
+	};
+	public LinkStack(T element){
+		top = new Node(element,null);
+		size ++;
+	}
+	public int length(){
+		return size;
+	}
+	public boolean isEmpty(){
+		return size == 0;
+	}
+	//[重要]
+	public void push(T element){
+		Node newNode = new Node(element,top);
+		top = newNode;
+		size ++;
+	}
+	public T pop(){
+		Node oldTop = top;
+		top = null;
+		top = oldTop.next;
+		size --;
+		return oldTop.data;
+	}
+	public T peek(){
+		return top.data;
+	}
+	public void clear(){
+		Node current = top;
+		for(int i=0;i<size && current!=null;i++){
+			Node nextNode = current.next;
+			current = null;
+			current = nextNode;
+		}
+		size = 0;
+	}
+	public String toString(){
+		if(size == 0){
+			return "[]";
+		}
+		StringBuilder sb = new StringBuilder("[");
+		Node current = top;
+		for(int i=0;i<size && current!=null;i++){
+			sb.append(current.data+" ");
+			current = current.next;
+		}
+		sb.append(']');
+		return sb.toString();
+	}
+	public static void main(String[] args) {
+		LinkStack<String> stack = new LinkStack<>();
+		stack.push("aaaa");
+		stack.push("bbbb");
+		System.out.println("此时栈顶元素是："+stack.peek());
+		stack.push("cccc");
+		System.out.println("自顶向下栈内的元素为："+stack.toString());
+		stack.pop();
+		System.out.println("出栈后栈内的元素为："+stack.toString());
+		stack.push("eeee");
+		stack.push("tttt");
+		System.out.println("自顶向下栈内的元素为："+stack.toString());
+		stack.clear();
+		System.out.println("清空后栈内的元素为："+stack.toString());
+	}
+
+}
+
+```
+[回到目录](#index)
+
+<h3 id="2.3">2.3循环队列</h3>
+
+```java
+package queue;
+//循环队列
+public class LoopQueue<T> {
+	private int DEFAULT_SIZE = 10;
+	private int capacity;
+	private Object[] elementData;
+	//保存顺序队列中元素的当前个数
+	private int front = 0;
+	private int rear = 0;
+	public LoopQueue(){
+		capacity = DEFAULT_SIZE;
+		elementData = new Object[capacity];
+	}
+	public LoopQueue(T element){
+		this();
+		elementData = new Object[capacity];
+		rear++;
+	}
+	public LoopQueue(T element, int initSize){
+		this.capacity = initSize;
+		elementData = new Object[capacity];
+		elementData[0] = element;
+		rear ++;
+	}
+	public void add(T element){
+		if(rear == front && elementData[front]!=null){
+			throw new IndexOutOfBoundsException("队列已满");
+		}
+		elementData[rear] = element;
+		rear++;
+		//如果rear已经到最大了，则掉头
+		rear = rear==capacity? 0:rear;
+	}
+	//出队列
+	public T remove(){
+		if(isEmpty()){
+			throw new IndexOutOfBoundsException("队列已满");
+		}
+		T oldValue = (T)elementData[front];
+		elementData[front] = null;
+		front++;
+		//如果front到头则掉头
+		front = front==capacity? 0:front;
+		return oldValue;
+	}
+	//获取队列首部元素，不删除
+	public T element(){
+		if(isEmpty()){
+			throw new IndexOutOfBoundsException("队列已满");
+		}
+		return (T)elementData[front];
+	}
+	public int length(){
+		if(isEmpty()){
+			return 0;
+		}
+		return rear > front ? rear - front :capacity-(front-rear);
+	}
+	public boolean isEmpty(){
+		return rear == front && elementData[rear]==null;
+	}
+	public void clear(){
+		for(int i=0;i<capacity ;i++){
+			elementData[i] = null;
+		}
+		front = rear = 0;
+	}
+	public String toString(){
+		if(isEmpty()){
+			return "[]";
+		}
+		StringBuilder sb = new StringBuilder("[");		
+		//如果front<rear，那么有效元素就是front到rear之间的元素
+		if(front<rear){
+			for(int i=front;i<rear;i++){
+				sb.append(elementData[i]+" ");
+			}
+		}else{
+			//如果front>=rear，那么有效元素为front~capacity和0到rear之间的
+			for(int i=front;i<capacity;i++){
+				sb.append(elementData[i]+" ");
+			}
+			for(int j=0;j<rear;j++){
+				sb.append(elementData[j]+" ");				
+			}
+		}
+		sb.append(']');
+		return sb.toString();
+	}
+	public static void main(String[] args) {
+		LoopQueue<String> queue = new LoopQueue<>();
+		queue.add("aaaa");
+		queue.add("bbbb");
+		queue.add("cccc");
+		queue.add("dddd");
+		System.out.println(queue);
+		System.out.println("排在队首的元素是："+queue.element());
+		queue.remove();
+		System.out.println("出队列之后："+queue);
+		queue.add("wwww");
+		System.out.println("插入wwww之后："+queue);
+		queue.clear();
+		System.out.println("清空队列后："+queue);
+
+	}
+
+}
+
+```
+[回到目录](#index)
+
+<h2 id="3">3.树</h2>
+
+<h3 id="3.1">3.1普通二叉树</h3>
+
+```java
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Queue;
+
+//二叉链表树
+public class BinaryTree<T> {
+	class Node{
+		T data;
+		Node left;
+		Node right;
+		public Node(){};
+		public Node(T data){
+			this.data = data;
+		}
+		public Node(T data, Node left, Node right){
+			this.data = data;
+			this.left = left;
+			this.right = right;
+		}
+	}
+
+	private Node root;
+	public BinaryTree(){
+		root = new Node();
+	}
+	public BinaryTree(T data){
+		root = new Node(data,null,null);
+	}
+	//为指定节点添加子节点
+	public Node addNode(Node parent,T data,boolean isLeft){
+		if(parent == null){
+			throw new RuntimeException("parent节点为null,无法添加子节点");
+		}
+		if(isLeft && parent.left!=null){
+			throw new RuntimeException("parent已有左子节点,无法添加子节点");
+		}
+		if(!isLeft && parent.right!=null){
+			throw new RuntimeException("parent已有右子节点,无法添加子节点");
+		}
+		Node newNode = new Node(data);
+		if(isLeft){
+			parent.left = newNode;
+		}else{
+			parent.right = newNode;
+		}
+		return newNode;
+	}
+
+	public boolean isEmpty(){
+		return root.data == null;
+	}
+	//获取根节点
+	public Node root(){
+		if(isEmpty()){
+			throw new RuntimeException("树为空");
+		}
+		return root;
+	}
+	//[重要]获取树的深度
+	public int deep(Node root){
+		if(root == null){
+			return 0;
+		}else{
+			return 1+Math.max(deep(root.left),deep(root.right));
+		}
+	}
+
+	//[重要]先序遍历:先遍历根节点
+	//中序遍历和后序遍历都是同理
+	public void preVisit(){
+		List<Node> list = new ArrayList<>();
+		list = preVisit(root);
+		for(int i=0;i<list.size();i++){
+			System.out.print(list.get(i).data+" ");
+		}
+	}
+	public List<Node> preVisit(Node node){
+		List<Node> tmpList = new ArrayList<>();
+		//如果是中序遍历则将这行放在中间，如果是后序遍历则放在最后
+		tmpList.add(node);
+		//递归处理左子树
+		if(node.left != null){
+			tmpList.addAll(preVisit(node.left));
+		}
+		if(node.right != null){
+			tmpList.addAll(preVisit(node.right));
+		}
+		return tmpList;
+	}
+
+	//[重要]广度优先遍历
+	public void breadthFirst(){
+		Queue<Node> queue = new ArrayDeque<Node>();
+		List<Node> list = new ArrayList<>();
+		if(root != null){
+			queue.offer(root);
+		}
+		while(!queue.isEmpty()){
+			//将根元素加入队列
+			list.add(queue.peek());
+			//从队列头部取出元素
+			Node p = queue.poll();
+			//如果左子节点不为空，则加入到队列
+			if(p.left!=null){
+				queue.offer(p.left);
+			}
+			if(p.right!=null){
+				queue.offer(p.right);
+			}
+		}
+		//输出所有节点信息
+		for(int i=0;i<list.size();i++){
+			System.out.print(list.get(i).data+" ");
+		}
+
+	}
+
+	/**该测试二叉树如下：
+	 *               A
+	 *              / \
+	 *             B  C
+	 *               / \
+	 *              D   E
+	 *             /
+	 *             F
+	 */
+	public static void main(String[] args) {
+		BinaryTree<String> tree = new BinaryTree<>("A");
+		BinaryTree.Node tn1 = tree.addNode(tree.root(), "B", true);
+		BinaryTree.Node tn2 = tree.addNode(tree.root(), "C", false);
+		BinaryTree.Node tn3 = tree.addNode(tn2, "D", true);
+		BinaryTree.Node tn4 = tree.addNode(tn2, "E", false);
+		BinaryTree.Node tn5 = tree.addNode(tn3, "F", true);
+		System.out.println("C的左子节点："+tn2.left.data);
+		System.out.println("C的右子节点："+tn2.right.data);
+		System.out.println("D的左子节点: "+tn3.left.data);
+		System.out.println("深度:"+tree.deep(tree.root()));
+
+		System.out.print("先序遍历:");
+		tree.preVisit();
+		System.out.println();
+
+		System.out.print("广度优先遍历:");
+		tree.breadthFirst();
+		System.out.println();
+	}
+
+}
+/**
+ * 输出结果：
+    C的左子节点：D
+	C的右子节点：E
+	D的左子节点: F
+	深度:4
+	先序遍历:A B C D F E
+	广度优先遍历:A B C D E F
+*/
+
+```
+[回到目录](#index)
+
+<h3 id="3.2">3.2二叉搜索树</h3>
+
+二叉排序树，也叫二叉搜索树，该代码构建的二叉搜索树节点存放整数。（也可以构造其他类型的二叉树，存放其他对象，只要能进行某种性质上的大小比较）根据整数大小来存放，比父节点小的总是为父节点左子节点。比父节点大的总是为父节点的右子节点。
+
+```java
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Queue;
+
+public class BinarySearchTree {
+	private class Node{
+		int data;
+		Node left;
+		Node right;
+		public Node(){};
+		public Node(int element){
+			this.data = element;
+			left = right = null;
+		}
+		public Node(int element,Node left,Node right){
+			this(element);
+			this.left = left;
+			this.right = right;
+		}
+	}
+	private Node root;
+	public BinarySearchTree(){
+		root = null;
+	};
+	//以根节点创建二叉搜索树
+	public BinarySearchTree(int element){
+		root = new Node(element);
+	}
+	//[重要]插入操作
+	public void insert(int element){
+		if(root == null){
+			root = new Node(element);
+		}else{
+			Node current = root;
+			Node parent = null;
+			Node newNode = new Node(element,null,null);
+			//该变量标记新节点在左还是在右
+			boolean isLeft = false;
+			//寻找一个合适的位置作为插入点
+			while(current != null){
+				parent = current;
+				//如果新插入的节点大于当前的节点
+				if(element > current.data){
+					//则把当前节点右移
+					current = current.right;
+					isLeft = false;
+				}else{
+					//如果新节点小于等于当前节点，则把当前节点左移
+					current = current.left;
+					isLeft = true;
+				}
+			}
+			//如果是在左，则新节点放到最后一次parent的左边
+			if(isLeft){
+				parent.left = newNode;
+			}else{
+				parent.right = newNode;
+			}
+		}
+	}
+	//[重要]删除操作
+	public void remove(int element){
+		Node delNode = findNode(element);//先找到要删除的节点
+		if(delNode == null){
+			return;
+		}
+		//然后进行树结构调整操作
+		//如果要删除的节点没有左右子节点，即它本身就是叶子节点
+		if(delNode.left == null && delNode.right==null){
+			//找到父节点
+			Node parent = findParent(delNode);
+			//如果要删除的节点是左子节点
+			if(delNode == parent.left){
+				parent.left = null;
+				//这里手动将delNode设为null,如果不置为null起始也没关系
+				//反正遍历树已经访问不到它了（估计它应该会被GC回收吧）
+				delNode = null;
+			}
+			if(delNode == parent.right){
+				parent.right = null;
+				delNode = null;
+			}
+		}
+		//如果要删除的节点只有左子节点
+		else if(delNode.left!=null && delNode.right==null){
+			if(root == delNode){
+				root = root.left;
+			}else{
+				Node parent = findParent(delNode);
+				if(delNode == parent.left){
+					parent.left = delNode.left;
+				}else if(delNode == parent.right){
+					parent.right = delNode.left;
+				}
+			}
+
+		}
+		//如果要删除的节点只有右子节点
+		else if(delNode.left==null && delNode.right!=null){
+			if(delNode == root){
+				root = root.right;
+			}else{
+				Node parent = findParent(delNode);
+				if(delNode == parent.left){
+					parent.left = delNode.right;
+				}else if(delNode == parent.right){
+					parent.right = delNode.right;
+				}
+			}
+		}
+		//如果要删除的节点有左右子节点
+		else{
+			//首先在其左子树中找到最大的那个值
+			Node leftMaxNode = delNode.left;
+			while(leftMaxNode.right!=null ){
+				leftMaxNode = leftMaxNode.right;
+			}
+			//找到leftMaxNode的父节点
+			Node maxParent = findParent(leftMaxNode);
+			//找到delNode的父节点
+			Node delNodeParent = findParent(delNode);
+			//这种情况容易忽略，如果leftMaxNode的父节点刚好是要删除的节点
+			if(delNode == maxParent){
+				if(delNodeParent.left == delNode){
+					delNodeParent.left = leftMaxNode;
+				}else{
+					delNodeParent.right = leftMaxNode;
+				}
+				leftMaxNode.right = delNode.right;
+				delNode = null;
+			}else{
+				//由于leftMaxNode不可能是parent的左孩子,
+				//只可能是parent的右孩子
+				//而leftMaxNode一定没有右孩子
+				//所以将parentde右子节点指向leftMaxNode的左边(可能为null，也没关系)
+				//parent.right = null;
+				maxParent.right = leftMaxNode.left;
+				leftMaxNode.left = delNode.left;
+				leftMaxNode.right = delNode.right;
+
+				//下面还要在delNodeParent中对delNode的位置进行替换
+				//（孩子丢了,给老人家一个交代吧）
+				//如果delNode本来就是root节点
+				if(delNodeParent == null){
+					root = leftMaxNode;
+				}//如果delNode不是root节点
+				else{
+					if(delNode == delNodeParent.left){
+						//给老人家一个新儿子
+						delNodeParent.left = leftMaxNode;
+					}else{
+						delNodeParent.right = leftMaxNode;
+					}
+				}
+				delNode.left = null;
+				delNode.right = null;
+				delNode = null;
+			}
+		}
+	}
+	//根据数字查找节点
+	public Node findNode(int element){
+		if(root == null){
+			return null;
+		}
+		Node p = root;
+		while(p!=null){
+			if(element > p.data){
+				p = p.right;
+			}else if(element < p.data){
+				p = p.left;
+			}else{
+				return p;
+			}
+		}
+		return null;
+	}
+	//找到一个节点的父节点
+	public Node findParent(Node child){
+		if(child == null){
+			return null;
+		}
+		if(child == root){
+			return null;
+		}
+		Node current = root;
+		Node prev = current;
+		while(current!= null){
+			if(current.data < child.data){
+				prev = current;
+				current = current.right;
+			}else if(current.data > child.data){
+				prev = current;
+				current = current.left;
+			}else{
+
+				return prev;
+			}
+		}
+		return null;
+	}
+	//[重要]中序遍历:先遍历左子节点
+	public void middleVisit(){
+		List<Node> list = new ArrayList<>();
+		list = middleVisit(root);
+		for(int i=0;i<list.size();i++){
+			System.out.print(list.get(i).data+" ");
+		}
+	}
+	public List<Node> middleVisit(Node node){
+		List<Node> tmpList = new ArrayList<>();
+		//递归处理左子树
+		if(node.left != null){
+			tmpList.addAll(middleVisit(node.left));
+		}
+		tmpList.add(node);
+		if(node.right != null){
+			tmpList.addAll(middleVisit(node.right));
+		}
+		return tmpList;
+	}
+	//[重要]广度优先遍历
+		public void breadthFirst(){
+			Queue<Node> queue = new ArrayDeque<Node>();
+			List<Node> list = new ArrayList<>();
+			if(root != null){
+				queue.offer(root);
+			}
+			while(!queue.isEmpty()){
+				//将根元素加入队列
+				list.add(queue.peek());
+				//从队列头部取出元素
+				Node p = queue.poll();
+				//如果左子节点不为空，则加入到队列
+				if(p.left!=null){
+					queue.offer(p.left);
+				}
+				if(p.right!=null){
+					queue.offer(p.right);
+				}
+			}
+			//输出所有节点信息
+			for(int i=0;i<list.size();i++){
+				System.out.print(list.get(i).data+" ");
+			}
+
+		}
+	/**
+	 * 初始化建立起来的树为
+	 *           6
+	 *         /    \
+	 *        2      13
+	 *         \    /   \
+	 *          5  8     25
+	 *          /   \    / \
+	 *         3    10  20  36
+	 */
+	public static void main(String[] args) {
+		BinarySearchTree BSTree = new BinarySearchTree();
+		//注意：这个插入顺序重要，插入顺序不同，即使元素相同
+		//也不一定能得到相同的树结构
+		BSTree.insert(6);
+		BSTree.insert(13);
+		BSTree.insert(2);
+		BSTree.insert(5);
+		BSTree.insert(25);
+		BSTree.insert(3);
+		BSTree.insert(36);
+		BSTree.insert(8);
+		BSTree.insert(10);
+		BSTree.insert(20);
+		//中序遍历输出所有值
+		System.out.println("中序遍历输出所有节点：");
+		BSTree.middleVisit();System.out.println();
+		System.out.println("广度优先遍历为：");
+		BSTree.breadthFirst();System.out.println();
+		System.out.println("移除了13节点后的中序遍历：");
+		BSTree.remove(13);
+		BSTree.middleVisit();System.out.println();
+		System.out.println("广度优先遍历为：");
+		BSTree.breadthFirst();
+	}
+}
+/*输出结果：
+中序遍历输出所有节点：
+2 3 5 6 8 10 13 20 25 36
+广度优先遍历为：
+6 2 13 5 8 25 3 10 20 36
+移除了13节点后的中序遍历：
+2 3 5 6 8 10 20 25 36
+广度优先遍历为：
+6 2 10 5 8 25 3 20 36  
+*/
+```
+[回到目录](#index)
+
+<h2 id="4">4.排序</h2>
+
+<h3 id="4.1">4.1冒泡排序</h3>
+
+ **冒泡排序**
+
+ * （属于交换排序）
+ *  时间复杂度：O(n*n)
+ *  空间复杂度：O(1)
+ *  稳定性：稳定
+ *  分析：最慢，效率最低的排序算法
+
+
+
+```java
+import java.util.Arrays;
+
+public class BubbleSort {
+	public static void bubbleSort(int[] array){
+		System.out.println("开始排序：");
+		for(int i=0;i<array.length-1; i++){
+			//该flag用来标记某一趟是否经过了元素交换
+			boolean flag = false;
+			for(int j=0;j<array.length-1-i; j++){
+				//如果一个元素比它后面的一个大
+				if(array[j] > array[j+1]){
+					int tmp = array[j];
+					array[j] = array[j+1];
+					array[j+1] = tmp;
+					flag = true;
+				}
+			}
+			System.out.println(Arrays.toString(array));
+			//如果某一趟中元素没有交换，则说明数组已经有序
+			//为提高效率，则直接退出
+			if(!flag){
+				break;
+			}
+		}
+	}
+	public static void main(String[] args) {
+		int[] array = new int[]{5,10,3,29,12,52,36,25};
+		System.out.println("排序前：");
+		System.out.println(Arrays.toString(array));
+		BubbleSort.bubbleSort(array);
+		System.out.println("排序后：");
+		System.out.println(Arrays.toString(array));
+	}
+	/**[运行结果]
+	 * 排序前：
+	 * [5, 10, 3, 29, 12, 52, 36, 25]
+	 * 开始排序：
+	 * [5, 3, 10, 12, 29, 36, 25, 52]
+	 * [3, 5, 10, 12, 29, 25, 36, 52]
+	 * [3, 5, 10, 12, 25, 29, 36, 52]
+	 * [3, 5, 10, 12, 25, 29, 36, 52]
+	 * 排序后：
+	 * [3, 5, 10, 12, 25, 29, 36, 52]
+	 */
+}
+```
+
+
+
+
+
+[回到目录](#index)
+
+
+
+<h3 id="4.2">4.2快速排序</h3>
+
+  **快速排序**
+
+ * （属于交换排序）
+ *  时间复杂度：最好O(nlogn) 最坏O(n*n)
+ *  空间复杂度:O(logn)
+ *  稳定性：不稳定
+ *  分析：快速排序比大部分排序算法都要快。
+ *  快速排序思路：从待排序的数据序列中任意去一个数据作为分界，所有比它小的数据元素一律放在左边，所有比它大的元素一律放在右边，这样一趟下来，形成左右两个子序列，再对这两个子序列进行相同的处理，即重新选取中心元素。进行递归处理
+
+```java
+import java.util.Arrays;
+
+public class QuickSort {
+	public static void quickSort(int[] array,int start,int end){
+		//需要排序
+		if(start < end){
+			//以第一个元素作为分界值
+			int pivot = array[start];
+			//i从左边开始搜索，查找大于分界值的元素索引
+			int i = start;
+			//j从右边开始搜索，查找小于分界值的元素索引
+			int j = end;
+			while(true){
+				while(array[j]>=pivot && i<j){
+					j--;
+				}
+
+				while(array[i]<=pivot && i<j){
+					i++;
+				}
+				//如果i小于j则交换
+				if(i<j){
+					swap(array,i,j);
+				}else{
+					break;
+				}
+			}
+			//pivot是array[start],因此将pivot放到合适的位置
+			swap(array,start,j);
+			System.out.println(Arrays.toString(array));
+			quickSort(array,start,j-1);
+			quickSort(array,j+1,end);
+		}
+	}
+	//交换函数
+		public static void swap(int[] array,int i,int j){
+			int tmp = array[i];
+			array[i] = array[j];
+			array[j] = tmp;
+		}
+
+	public static void main(String[] args) {
+		int[] array = new int[]{9,5,23,2,0,21,30,13};
+		System.out.println("排序前：\n"+Arrays.toString(array));
+		System.out.println("开始排序：");
+		QuickSort.quickSort(array, 0,array.length-1);
+		System.out.println("排序后：\n"+Arrays.toString(array));
+	}
+	/*[运行结果]
+	 排序前：
+	[9, 5, 23, 2, 0, 21, 30, 13]
+	开始排序：
+	[2, 5, 0, 9, 23, 21, 30, 13]
+	[0, 2, 5, 9, 23, 21, 30, 13]
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	排序后：
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	 */
+}
+```
+
+[回到目录](#index)
+
+
+
+<h3 id="4.3">4.3直接选择排序</h3>
+
+ * 直接选择排序
+ * （属于选择排序）
+ * 时间复杂度：O(n*n)
+ * 空间复杂度：O(1)
+ * 稳定性：不稳定
+ * 分析：和冒泡排序一样效率较低
+ * 思路：第一趟从所有数据中选出最小的，放在第一位。第二趟从其他未排序位置中选出最小的，放在第二位，依次类推，一共需要进行n-1趟才能排好。
+
+```java
+import java.util.Arrays;
+
+public class SelectSort {
+	public static void selectSort(int[] array){
+		//进行n-1趟比较，第i趟比较将第i大的值选出来放在i位置上
+		for(int i=0;i<array.length-1;i++){
+			//第i个数据只需和它后面的数据比较
+			for(int j=i+1;j<array.length;j++){
+				//如果第i位的数据大于第j位的数据，则交换它们
+				if(array[i]>array[j]){
+					int tmp = array[i];
+					array[i] = array[j];
+					array[j] = tmp;
+				}
+			}
+			System.out.println(Arrays.toString(array));
+		}
+	}
+	public static void main(String[] args) {
+		int[] array = new int[]{9,5,23,2,0,21,30,13};
+		System.out.println("排序前：\n"+Arrays.toString(array));
+		System.out.println("开始排序：");
+		SelectSort.selectSort(array);
+		System.out.println("排序后：\n"+Arrays.toString(array));
+	}
+	/*[运行结果]
+	 排序前：
+	[9, 5, 23, 2, 0, 21, 30, 13]
+	开始排序：
+	[0, 9, 23, 5, 2, 21, 30, 13]
+	[0, 2, 23, 9, 5, 21, 30, 13]
+	[0, 2, 5, 23, 9, 21, 30, 13]
+	[0, 2, 5, 9, 23, 21, 30, 13]
+	[0, 2, 5, 9, 13, 23, 30, 21]
+	[0, 2, 5, 9, 13, 21, 30, 23]
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	排序后：
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	 */
+}
+```
+[回到目录](#index)
+
+
+
+<h3 id="4.4">4.4堆排序</h3>
+ **堆排序**
+
+ *  （属于选择排序）
+ *  时间复杂度：O(nlogn)
+ *  空间复杂度：O(1)
+ *  稳定性：不稳定
+ *  分析：通过 重建堆，从根结点开始进行从上向下的调整。每次调整都将未排序区中最大的元素放在堆顶，然后将堆顶的元素与未排序区中的最后一个元素交换，这个最大元素就进入排序区，然后再进行堆的重新调整操作。如此重复实现排序
+
+```java
+import java.util.Arrays;
+public class HeapSort {
+
+	public static void heapSort(int[] array){
+		//先把array数组构建成一个大顶堆
+		//从完全二叉树最右边的叶子节点的父节点开始
+		for(int i = array.length/2-1;i>=0;i--){
+			moveDown(array,i,array.length-1);
+		}
+		//经过上一轮的调整，已经将数组中最大的元素置于堆顶
+		//接下来进行堆排序
+		for(int i =array.length-1;i>=1;i--){
+			//将未排序的末尾元素与堆顶元素交换
+			//此时未排序区中的最大的元素会放在未排序区的最后
+			swap(array,0,i);
+			System.out.println(Arrays.toString(array));
+			//进行堆排序
+			moveDown(array,0,i-1);
+		}
+	}
+	//每一次moveDown都会把未排序区中最大的数挑出来放在堆顶
+	public static void moveDown(int[] array,int first,int last){
+		//将first的左子节点设为largest
+		int largest = first*2 +1;
+		while(largest <= last){
+			//如果first的右子节点大于左子节点
+			if(largest<last&&array[largest]<array[largest+1]){
+				//标记较大的那个右子节点
+				largest++;
+			}
+			//如果第一个元素小于largest元素
+			if(array[first]<array[largest]){
+				//将first和largest对应的元素进行交换
+				swap(array,first,largest);
+
+				//继续往下移动
+				first = largest;
+				largest = 2*first+1;
+			}else{
+				//如果该节点比它的两个孩子都大，则退出循环
+				break;
+			}
+		}
+	}
+	public static void swap(int[] array,int i,int j){
+		int tmp = array[i];
+		array[i] = array[j];
+		array[j] = tmp;
+	}
+
+	public static void main(String[] args) {
+		int[] array = new int[]{9,5,23,2,0,21,30,13};
+		System.out.println("排序前：\n"+Arrays.toString(array));
+		System.out.println("开始排序：");
+		heapSort(array);
+		System.out.println("排序后：\n"+Arrays.toString(array));
+	}
+	/*[运行结果]
+	排序前：
+	[9, 5, 23, 2, 0, 21, 30, 13]
+	开始排序：
+	[2, 13, 23, 5, 0, 21, 9, 30]
+	[9, 13, 21, 5, 0, 2, 23, 30]
+	[2, 13, 9, 5, 0, 21, 23, 30]
+	[0, 5, 9, 2, 13, 21, 23, 30]
+	[2, 5, 0, 9, 13, 21, 23, 30]
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	排序后：
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	 */
+
+}
+```
+[回到目录](#index)
+
+
+
+
+<h3 id="4.5">4.5直接插入排序</h3>
+
+ * 直接插入排序
+ * （属于插入排序）
+ * 时间复杂度：O(n*n)
+ * 空间复杂度：O(1)
+ * 稳定性：稳定
+ * 排序思路：将第一个元素看做有序区，使用游标从数组的第二个数开始扫描，然后将第二个数插入到有序区中的恰当位置，使有序区增长，游标依次后移，然后再把游标处的元素再次插入有序区
+
+```java
+import java.util.Arrays;
+
+public class InsertSort {
+
+	public static void insertSort(int[] array){
+		for(int i=1;i<array.length;i++){
+			//从第二个元素开始，依次向后
+			//将每个cursor插入到前面的已排序区域
+			int cursor = array[i];
+			//i-1索引之前的元素都已经有序，i-1处的元素就是最大的值
+			//如果i位置的元素比i-1处的小，则需要将该元素插入到有序区
+			if(array[i] < array[i-1]){
+				//将数组中的数据依次往后移动一位
+				int j;
+				//array[j]是有序区中最大的元素
+				for(j=i-1; j>=0&&cursor<array[j] ;j--){
+					//数组中的元素依次右移
+					array[j+1] = array[j];
+				}
+				//当找到合适cursor插入的位置j+1时
+				//将cursor的值放到合适的位置中去
+				array[j+1] = cursor;
+			}
+			System.out.println(Arrays.toString(array));
+		}
+	}
+	public static void main(String[] args) {
+		int[] array = new int[]{9,5,23,2,0,21,30,13};
+		System.out.println("排序前：\n"+Arrays.toString(array));
+		System.out.println("开始排序：");
+		insertSort(array);
+		System.out.println("排序后：\n"+Arrays.toString(array));
+	}
+	/*[运行结果]
+	 排序前：
+	[9, 5, 23, 2, 0, 21, 30, 13]
+	开始排序：
+	[5, 9, 23, 2, 0, 21, 30, 13]
+	[5, 9, 23, 2, 0, 21, 30, 13]
+	[2, 5, 9, 23, 0, 21, 30, 13]
+	[0, 2, 5, 9, 23, 21, 30, 13]
+	[0, 2, 5, 9, 21, 23, 30, 13]
+	[0, 2, 5, 9, 21, 23, 30, 13]
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	排序后：
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	 */
+}
+
+```
+[回到目录](#index)
+
+<h3 id="4.6">4.6折半插入排序</h3>
+
+ * 折半插入排序
+ * （属于插入排序）
+ * 时间复杂度：O(n*n)
+ * 空间复杂度：O(1)
+ * 稳定性：稳定
+ * 分析：是直接插入排序算法的改进，每次都将有序区折半，查找存放cursor的合适位置，这样可以加快查找速度
+
+```java
+import java.util.Arrays;
+public class HalfInsertSort {
+
+	public static void halfInsertSort(int[] array){
+		for(int i=1;i<array.length;i++){
+			int cursor = array[i];
+			//有序区的左边界0，右边界i-1
+			int low = 0;
+			int high = i-1;
+			//将有序区折半
+			while(low <= high){
+				//将有序区折半，查找存放cursor的合适位置
+				int mid = (low+high)/2;
+				//如果cursor比分界元素大，则在右半区域查找
+				if(cursor>array[mid]){
+					low = mid+1;
+				}else{
+					high = mid-1;
+				}
+			}
+			//将low到i的元素整体右移一位
+			for(int j= i;j>low;j--){
+				array[j] = array[j-1];
+			}
+			//low处的元素是有序区中刚好大于等于cursor的数的位置
+			array[low] = cursor;
+			System.out.println(Arrays.toString(array)+"low:"+low);
+		}
+	}
+	public static void main(String[] args) {
+		int[] array = new int[]{9,5,23,2,0,21,30,13};
+		System.out.println("排序前：\n"+Arrays.toString(array));
+		System.out.println("开始排序：");
+		halfInsertSort(array);
+		System.out.println("排序后：\n"+Arrays.toString(array));
+	}
+	/**[运行结果]
+	排序前：
+	[9, 5, 23, 2, 0, 21, 30, 13]
+	开始排序：
+	[5, 9, 23, 2, 0, 21, 30, 13]low:0
+	[5, 9, 23, 2, 0, 21, 30, 13]low:2
+	[2, 5, 9, 23, 0, 21, 30, 13]low:0
+	[0, 2, 5, 9, 23, 21, 30, 13]low:0
+	[0, 2, 5, 9, 21, 23, 30, 13]low:4
+	[0, 2, 5, 9, 21, 23, 30, 13]low:6
+	[0, 2, 5, 9, 13, 21, 23, 30]low:4
+	排序后：
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	 */
+}
+
+```
+[回到目录](#index)
+
+
+
+
+<h3 id="4.7">4.7希尔排序</h3>
+
+ * 希尔排序
+ * （属于插入排序）
+ * 时间复杂度：平均O(nlogn)^2   最坏O(n*n)
+ * 空间复杂度：O(1)
+ * 稳定性：不稳定
+ * 分析：Shell排序是递减增量排序法：增量为gap，先比较距离较远的元素，再比较距离较近的元素，每次间隔gap的距离，并且gap逐渐递减，直接插入排序相当于增量为1的希尔排序
+
+```java
+import java.util.Arrays;
+
+public class ShellSort {
+	public static void shellSort(int[] array){
+		//gap变量保存可变增量
+		int gap = 1;
+		//由Knuth提出的经验公式：gap = gap*3+1
+		//按照3*gap+1得到增量序列的最大值
+		while(gap <= array.length/3){
+			gap = gap*3+1;
+		}
+		while(gap>0){
+			System.out.println("gap的值："+gap);
+			for(int i=gap;i<array.length;i++){
+				int tmp = array[i];
+				//array[i-gap]是有序区的最大值
+				//这个“有序区"是不连续的，每个元素之间相隔gap
+
+				if(array[i] < array[i-gap]){
+					int j = i-gap;
+					//j每次减少gap的距离
+					for(; j>=0 && array[j]>tmp; j-=gap){
+						//将"有序区"中的元素依次向后移动
+						array[j+gap] = array[j];
+					}
+					array[j+gap] = tmp;
+				}
+				System.out.println(Arrays.toString(array));
+			}
+			//gap按照Knuth的经验公式逐渐减小
+			gap = (gap-1)/3;
+		}
+	}
+	public static void main(String[] args) {
+		int[] array = new int[]{9,5,23,2,0,21,30,13};
+		System.out.println("排序前：\n"+Arrays.toString(array));
+		System.out.println("开始排序：");
+		shellSort(array);
+		System.out.println("排序后：\n"+Arrays.toString(array));
+	}
+	/**[运行结果]
+	 排序前：
+	[9, 5, 23, 2, 0, 21, 30, 13]
+	开始排序：
+	gap的值：4
+	[0, 5, 23, 2, 9, 21, 30, 13]
+	[0, 5, 23, 2, 9, 21, 30, 13]
+	[0, 5, 23, 2, 9, 21, 30, 13]
+	[0, 5, 23, 2, 9, 21, 30, 13]
+	gap的值：1
+	[0, 5, 23, 2, 9, 21, 30, 13]
+	[0, 5, 23, 2, 9, 21, 30, 13]
+	[0, 2, 5, 23, 9, 21, 30, 13]
+	[0, 2, 5, 9, 23, 21, 30, 13]
+	[0, 2, 5, 9, 21, 23, 30, 13]
+	[0, 2, 5, 9, 21, 23, 30, 13]
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	排序后：
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	 */
+}
+
+```
+
+[回到目录](#index)
+
+
+
+<h3 id="4.8">4.8归并排序</h3>
+
+ * 归并排序
+ * 时间复杂度：O(nlogn)^2
+ * 空间复杂度：O(1)
+ * 稳定性：稳定
+ * 分析：将长度为n的无序序列看成是n个长度为1的有序子序列，首先做两两合并，得到一个n/2个长度为2的有序子序列，然后再将这些有序子序列进行两两合并，不断的重复这个过程，最终得到一个长度为n的有序序列。
+
+```java
+import java.util.Arrays;
+public class MergeSort {
+
+	//left是待排序数组的第一个位置索引，right是最后一个位置索引
+	public static void mergeSort(int[] array,int left,int right){
+		if(left < right){
+			int mid = (left+right)/2;
+			mergeSort(array,left,mid);
+			mergeSort(array,mid+1,right);
+			merge(array,left,mid,right);
+		}
+	}
+	public static void merge(int[] array,int left,int center,int right){
+		//定义一个与待排序数组一样大小的临时数组
+		int[] tmpArr = new int[array.length];
+		int mid = center+1;
+		//记录中间数组的索引
+		int third = left;
+		int tmp = third;
+		while(left<=center && mid<=right){
+			//从两个数组中取出较小的值放入中间数组
+			if(array[left] < array[mid]){
+				tmpArr[third++] = array[left++];
+			}else{
+				tmpArr[third++] = array[mid++];
+			}
+		}
+		//剩余部分依次放入中间数组
+		while(mid<=right){
+			tmpArr[third++] = array[mid++];
+		}
+		while(left<=center){
+			tmpArr[third++] = array[left++];
+		}
+		//将中间数组中的内容复制到原数组
+		while(tmp<=right){
+			array[tmp] = tmpArr[tmp++];
+		}
+		System.out.println(Arrays.toString(array));
+	}
+	public static void main(String[] args) {
+		int[] array = new int[]{9,5,23,2,0,21,30,13};
+		System.out.println("排序前：\n"+Arrays.toString(array));
+		System.out.println("开始排序：");
+		mergeSort(array,0,array.length-1);
+		System.out.println("排序后：\n"+Arrays.toString(array));
+	}
+	/**[运行结果]
+	 排序前：
+	[9, 5, 23, 2, 0, 21, 30, 13]
+	开始排序：
+	[5, 9, 23, 2, 0, 21, 30, 13]
+	[5, 9, 2, 23, 0, 21, 30, 13]
+	[2, 5, 9, 23, 0, 21, 30, 13]
+	[2, 5, 9, 23, 0, 21, 30, 13]
+	[2, 5, 9, 23, 0, 21, 13, 30]
+	[2, 5, 9, 23, 0, 13, 21, 30]
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	排序后：
+	[0, 2, 5, 9, 13, 21, 23, 30]
+	 */
+}
+
+```
+
+
+
+[回到目录](#index)
+<h3 id="4.9">4.9基数排序</h3>
+
+ * 基数排序
+ * 时间复杂度：平均O(k*n),k是位数个数。  最坏O(n*n)
+ * 空间复杂度：O(rd+n),r是关键码取值范围(如0-9，r是10),d是最长的位数
+ * 稳定性：稳定
+ * 分析：将待排序的数据拆分成多个关键字，然后根据子关键字
+
+    对数据进行排序
+
+```java
+import java.util.Arrays;
+
+public class RadixSort {
+	//maxLen代表最大的数有多少位
+	public static void radixSort(int[] array,int maxLen){
+		int a = 0;//数组array下标的标记符
+		int n =1;//n=1代表比较元素的个位，n=10代表比较元素的十位
+		int m =1;//控制键值排序依据在哪一位
+		//构造一个辅助二维数组，第一维代表可能的余数，第二维用来存放
+		//数组中余数相同的元素
+		int[][] tmp = new int[10][array.length];
+		//order代表同余数组
+		//0-9,表示余数为0-9的元素的个数
+		//余数为i的有h个，则order[i]=h。
+		int[] order = new int[10];
+
+		while(m <= maxLen){
+			for(int i=0;i<array.length;i++){
+				int lsd = (array[i]/n)%10;//n=1时，先取出个位
+				//将这个元素放在tmp这个二维数组中
+				tmp[lsd][order[lsd]] = array[i];
+				order[lsd]++;//order数组中的记录加一
+			}
+			//[Debug]输出tmp数组看看
+			System.out.println("该趟比较的位："+n+"。tmp数组如下：");
+			for(int i=0;i<10;i++){
+				for(int j=0;j<array.length;j++){
+					System.out.print(tmp[i][j]+" ");
+				}
+				System.out.println();
+			}
+
+			System.out.println("array数组变化为：");
+			for(int i=0;i<10;i++){
+				//如果有余数为i的数
+				if(order[i]!=0){
+					for(int j=0;j<order[i];j++){
+						//将tmp数组中的元素重新放到array中，完成对array的重排序
+						//?这里还有点费解
+						array[a] = tmp[i][j];
+						a++;
+					}
+					System.out.println(Arrays.toString(array));
+				}
+				order[i] = 0;
+			}
+			n = n*10;
+			a = 0;
+			m++;
+
+		}
+	}
+	public static void main(String[] args) {
+		int[] array = new int[]{9,288,5,156,23,2,103,0,21,1007,98,30,13};
+		System.out.println("排序前：\n"+Arrays.toString(array));
+		System.out.println("开始排序：");
+		radixSort(array,4);
+		System.out.println("排序后：\n"+Arrays.toString(array));
+	}
+	/**[运行结果]
+	 排序前：
+	[9, 288, 5, 156, 23, 2, 103, 0, 21, 1007, 98, 30, 13]
+	开始排序：
+	该趟比较的位：1。tmp数组如下：
+	0 30 0 0 0 0 0 0 0 0 0 0 0
+	21 0 0 0 0 0 0 0 0 0 0 0 0
+	2 0 0 0 0 0 0 0 0 0 0 0 0
+	23 103 13 0 0 0 0 0 0 0 0 0 0
+	0 0 0 0 0 0 0 0 0 0 0 0 0
+	5 0 0 0 0 0 0 0 0 0 0 0 0
+	156 0 0 0 0 0 0 0 0 0 0 0 0
+	1007 0 0 0 0 0 0 0 0 0 0 0 0
+	288 98 0 0 0 0 0 0 0 0 0 0 0
+	9 0 0 0 0 0 0 0 0 0 0 0 0
+	array数组变化为：
+	[0, 30, 5, 156, 23, 2, 103, 0, 21, 1007, 98, 30, 13]
+	[0, 30, 21, 156, 23, 2, 103, 0, 21, 1007, 98, 30, 13]
+	[0, 30, 21, 2, 23, 2, 103, 0, 21, 1007, 98, 30, 13]
+	[0, 30, 21, 2, 23, 103, 13, 0, 21, 1007, 98, 30, 13]
+	[0, 30, 21, 2, 23, 103, 13, 5, 21, 1007, 98, 30, 13]
+	[0, 30, 21, 2, 23, 103, 13, 5, 156, 1007, 98, 30, 13]
+	[0, 30, 21, 2, 23, 103, 13, 5, 156, 1007, 98, 30, 13]
+	[0, 30, 21, 2, 23, 103, 13, 5, 156, 1007, 288, 98, 13]
+	[0, 30, 21, 2, 23, 103, 13, 5, 156, 1007, 288, 98, 9]
+	该趟比较的位：10。tmp数组如下：
+	0 2 103 5 1007 9 0 0 0 0 0 0 0
+	13 0 0 0 0 0 0 0 0 0 0 0 0
+	21 23 0 0 0 0 0 0 0 0 0 0 0
+	30 103 13 0 0 0 0 0 0 0 0 0 0
+	0 0 0 0 0 0 0 0 0 0 0 0 0
+	156 0 0 0 0 0 0 0 0 0 0 0 0
+	156 0 0 0 0 0 0 0 0 0 0 0 0
+	1007 0 0 0 0 0 0 0 0 0 0 0 0
+	288 98 0 0 0 0 0 0 0 0 0 0 0
+	98 0 0 0 0 0 0 0 0 0 0 0 0
+	array数组变化为：
+	[0, 2, 103, 5, 1007, 9, 13, 5, 156, 1007, 288, 98, 9]
+	[0, 2, 103, 5, 1007, 9, 13, 5, 156, 1007, 288, 98, 9]
+	[0, 2, 103, 5, 1007, 9, 13, 21, 23, 1007, 288, 98, 9]
+	[0, 2, 103, 5, 1007, 9, 13, 21, 23, 30, 288, 98, 9]
+	[0, 2, 103, 5, 1007, 9, 13, 21, 23, 30, 156, 98, 9]
+	[0, 2, 103, 5, 1007, 9, 13, 21, 23, 30, 156, 288, 9]
+	[0, 2, 103, 5, 1007, 9, 13, 21, 23, 30, 156, 288, 98]
+	该趟比较的位：100。tmp数组如下：
+	0 2 5 1007 9 13 21 23 30 98 0 0 0
+	103 156 0 0 0 0 0 0 0 0 0 0 0
+	288 23 0 0 0 0 0 0 0 0 0 0 0
+	30 103 13 0 0 0 0 0 0 0 0 0 0
+	0 0 0 0 0 0 0 0 0 0 0 0 0
+	156 0 0 0 0 0 0 0 0 0 0 0 0
+	156 0 0 0 0 0 0 0 0 0 0 0 0
+	1007 0 0 0 0 0 0 0 0 0 0 0 0
+	288 98 0 0 0 0 0 0 0 0 0 0 0
+	98 0 0 0 0 0 0 0 0 0 0 0 0
+	array数组变化为：
+	[0, 2, 5, 1007, 9, 13, 21, 23, 30, 98, 156, 288, 98]
+	[0, 2, 5, 1007, 9, 13, 21, 23, 30, 98, 103, 156, 98]
+	[0, 2, 5, 1007, 9, 13, 21, 23, 30, 98, 103, 156, 288]
+	该趟比较的位：1000。tmp数组如下：
+	0 2 5 9 13 21 23 30 98 103 156 288 0
+	1007 156 0 0 0 0 0 0 0 0 0 0 0
+	288 23 0 0 0 0 0 0 0 0 0 0 0
+	30 103 13 0 0 0 0 0 0 0 0 0 0
+	0 0 0 0 0 0 0 0 0 0 0 0 0
+	156 0 0 0 0 0 0 0 0 0 0 0 0
+	156 0 0 0 0 0 0 0 0 0 0 0 0
+	1007 0 0 0 0 0 0 0 0 0 0 0 0
+	288 98 0 0 0 0 0 0 0 0 0 0 0
+	98 0 0 0 0 0 0 0 0 0 0 0 0
+	array数组变化为：
+	[0, 2, 5, 9, 13, 21, 23, 30, 98, 103, 156, 288, 288]
+	[0, 2, 5, 9, 13, 21, 23, 30, 98, 103, 156, 288, 1007]
+	排序后：
+	[0, 2, 5, 9, 13, 21, 23, 30, 98, 103, 156, 288, 1007]
+	 */
+}
+
+```
+
+
+
+[回到目录](#index)
+<h3 id="4.10">4.10复杂度比较</h3>
+
+![pic](assets/algorithm1.gif)
+
+[回到目录](#index)
+
+
+
+<h2 id="5">5.查找</h2>
+
+<h3 id="5.1">5.1朴素查找</h3>
+
+朴素匹配算法，也叫BF匹配算法或暴力匹配算法,
+将文本串一位一位地与模式串进行对比，如果中途有一位不相同，
+则将文本串的下标后移一位，再重新从模式串的第一位开始进行对比,
+该算法效率低
+
+```java
+public class NativeSearch {
+	public static int nativeSearch(String pattern,String text){
+		int plen = pattern.length();
+		int tlen = text.length();
+		int t = 0;//标记text的下标
+		if(tlen<plen || tlen==0 || plen==0){
+			return -1;
+		}
+		while(t<tlen){
+			int p=0;
+			int count=0;//count用来标记匹配成功了几个字符
+			while(p<plen){
+				//为了体现匹配的过程，因此没有直接使用text.indexOf(pattern)
+				if(pattern.charAt(p)==text.charAt(t)){
+					p++;t++;count++;
+				}else{
+					//如果中途有一位没有匹配成功
+					p = 0;
+					count =0;
+					break;
+				}
+				//匹配成功,count的值和模式串长度相等
+				if(count == plen){
+					//返回刚好匹配到的位置索引
+					return t - plen;
+				}
+			}
+			t++;
+		}
+		return -1;
+	}
+	public static void main(String[] args) {
+		String pattern = "abbc";
+		String text = "abbdmnerabcdabbcdbccc";
+		System.out.println(text.indexOf(pattern));
+		System.out.println("朴素匹配到的位置是："+nativeSearch(pattern,text));
+	}
+	/**[运行结果]
+	 * 12
+	 * 朴素匹配到的位置是：12
+	 */
+}
+```
+
+[回到目录](#index)
+
+
+
+<h3 id="5.2">5.2KMP</h3>
+
+//朴素匹配算法的低效：当模式串与文本进行匹配时，如果出现中途有一位匹配失败，便将模式串右移一位，用模式串的第一位与原来匹配的起点的后一位进行匹配。
+
+KMP算法是找到模式串中的next数组，next数组描述的是每个字符对应的最长公共前后缀，当模式串与文本进行匹配时，当匹配到某一位不匹配时，由next数组可得知模式串应该后移的位数，从而避免像朴素匹配算法一样的低效匹配
+
+```java
+import java.util.Arrays;
+
+public class KMPSearch {
+	//下面方法用来得到模式串的next数组，next数组描述的是每个字符对应的最长公共前后缀
+	public static int[] getNext(String pattern){
+		char[] p = pattern.toCharArray();
+		int[] next = new int[p.length];
+		next[0] = -1;
+		int left = -1;//left作为前缀的索引
+		int right = 0;//right作为后缀的索引
+		//根据已知前right位推测出第right+1位
+		while(right<p.length-1){
+			//left等于-1表示初始时候的进入条件
+			if(left==-1||p[right]==p[left]){
+				right++;left++;
+				next[right] = left;
+			}else{
+				left = next[left];
+			}
+		}
+		return next;
+	}
+
+	public static int kmpSearch(String pattern,String text){
+		int[] next = getNext(pattern);
+		System.out.println("next数组为："+Arrays.toString(next));
+		int t = 0;//text的下标
+		int p = 0;//pattern的下标
+		int plen = pattern.length();
+		int tlen = text.length();
+		while(p<plen && t<tlen){
+			//如果在某一位匹配到，则p和t都加一
+			if(p==-1||pattern.charAt(p)==text.charAt(t)){
+				p++;t++;
+			}else{
+				//如果没有匹配到，则按照next数组进行移位
+				p = next[p];
+			}
+		}
+		//如果匹配成功，则返回所在位置的下标
+		if(plen == p){
+			return t - plen;
+		}else{
+			return -1;
+		}		
+	}
+
+	public static void main(String[] args) {
+		String pattern = "ababaaaba";
+		String text = "abacaaababaaabaabaabb";
+		System.out.println(text.indexOf(pattern));
+		System.out.println("KMP算法查找到的位置是："+kmpSearch(pattern,text));
+	}
+	/**
+	 6
+	next数组为：[-1, 0, 0, 1, 2, 3, 1, 1, 2]
+	KMP算法查找到的位置是：6
+	 */
+}
+```
+
+[回到目录](#index)
diff --git a/assets/algorithm1.gif b/assets/algorithm1.gif
new file mode 100644
index 0000000000000000000000000000000000000000..c0585657ee271f80163995166db0f60407050310
GIT binary patch
literal 57313
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

literal 0
HcmV?d00001