（高级基础）09_数据结构和算法

一、基本概念和术语

1、数据（data)—所有能输入到计算机中去的描述客观事物的符号
数值型数据
非数值型数据（多媒体信息处理）
2、数据元素（data element）—数据的基本单位，也称结点（node）或记录（record）
3、数据项（data item）—有独立含义的数据最小单位，也称域(field)
4、数据对象(Data Object)：相同特性数据元素的集合，是数据的一个子集
整数数据对象 N = { 0, ±1, ±2, … }
学生数据对象 学生记录的集合
例：学生表 > 个人记录 > 学号、姓名……
data(数据) > data element（数据元素） > data item(数据项)
5、数据结构（Data Structure）：是相互之间存在一种或多种特定关系的数据元素的集合
数据结构是带“结构”的数据元素的集合，“结构”就是指数据元素之间存在的关系。
数据存储在数据库 —表--- 记录-----字段

二、数据逻辑结构

划分方法一
（1）线性结构：
1)线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系
2)线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的
3)链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息
4)线性结构常见的有：数组、队列、链表和栈，后面我们会详细讲解.
（2）非线性结构：
非线性结构包括：二维数组，多维数组，广义表，树结构，图结构

划分方法二

①集合——数据元素间除“同属于一个集合”外，无其它关系
例如：树、图

②线性结构——一个对一个，如线性表、栈、队列

③树形结构——一个对多个，如树

④图形结构——多个对多个，如图

三、数据存储结构

①存储结构（物理结构）----数据元素及其关系在计算机存储器中的存储方式。

②顺序存储结构——借助元素在存储器中的相对位置来表示数据元素间的逻辑关系

③链式存储结构——借助指示元素存储地址的指针表示数据元素间的 逻辑关系

四、常见的数据结构

①数据结构分为线性和非线性
②数据结构中线性结构指的是数据元素之间存在着“一对一”的线性关系的数据结构；
③线性结构包括：数组，链表，队列，栈；
④非线性结构包括：树，图，表

1.栈

①.栈介绍

1)栈的英文为(stack)
2)栈是一个先入后出(FILO-First In Last Out)的有序列表。
3)栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
4)根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
5)出栈(pop)和入栈(push)的概念(如图所示)

②.栈的应用场景

1)子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
2)处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
3)表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
4)二叉树的遍历。 图形的深度优先(depth一first)搜索法

③特点

栈特殊的线性表（顺序表、链表），它在操作上有一些特殊的要求和限制：栈的元素必须“后进先出”。
栈的表尾称为栈的栈顶（top），相应的表头称为栈底（bottom）
栈的操作只能在这个线性表的表尾进行。
定义栈的操作

public interface IStack {
	//1 判断栈是否为空
	boolean  isEmpty();
	//2 判断栈是否为满
	boolean  isFull();
	//3 入栈
	void push(Object obj);
	//4 出栈 删除并返回栈顶元素
	Object  pop();
	//5 获取栈顶元素
	Object getTop();
	//6 打印栈内元素
	void display();
	// 7 获取栈的容量
	int getStackSize();
	// 8 获取栈中元素的个数
	int  length();
}

栈的实现

package org.lanqiao.stack;
/*
 * 使用数组模拟栈的实现
 */
public class Stack implements IStack{
	private Object[] stack;
	private int  size ;//表示栈的容量
	private int top = -1;//栈顶标记
	//通过无参构造创建一个默认容量的栈
	public Stack(){
		this.size = 10;
		stack = new Object[this.size];
	}
	
	public Stack(int size) {
		this.size =size;
		stack = new Object[this.size];
	}
	/**
	 * 栈为空 返回true  否则返回false
	 */
	@Override
	public boolean isEmpty() {
		if(top == -1) {
			return true;	
		}
		return false;
	}
	/**
	 * 栈满 返回true  否则返回false
	 */
	@Override
	public boolean isFull() {
		if(top == (size- 1)) {
			return true;
		}
		return false;
	}
	//入栈
	@Override
	public void push(Object obj) {
		if(!isFull()) {
			stack[++top] = obj;
		}else {
			System.out.println("栈已满");
		}
		
	}
	//出栈
	@Override
	public Object pop() {
		 if(!isEmpty()) {
			return stack[top--] ; 
		 }else {
			 System.out.println("栈为空");
		 }
		return null;
	}
	//获取栈顶元素
	@Override
	public Object getTop() {
		if(!isEmpty()) {
			return stack[top] ; 
		 }else {
			 System.out.println("栈为空");
		 }
		return null;
	}

	@Override
	public void display() {
		if(!isEmpty()) {
			 for(int i = 0 ; i <=top ; i++) {
				 System.out.print(stack[i] +"  ");
			 }
			System.out.println();
		}
		
	}
	//获取栈的容量
	@Override
	public int getStackSize() {
		
		return size;
	}
	//获取栈中元素的个数
	@Override
	public int length() {
		 
		return top+1;
	}

}

利用栈实现字符串逆序
我们知道栈是后进先出，我们可以将一个字符串分隔为单个的字符，然后将字符一个一个push()进栈，在一个一个pop()出栈就是逆序显示了。

2.队列

①.介绍

队列是一种先进先出(FIFO) 的线性表. 在表一端插入,在另一端删除

1. 定义
只能在表的一端（队尾）进行插入，在另一端（队头）进行删除运算的线性表
2. 逻辑结构
与线性表相同，仍为一对一关系
3. 存储结构
用顺序队列或链队存储均可
4.运算规则
先进先出（FIFO）
5.实现方式
关键是编写入队和出队函数，具体实现依顺序队或链队的不同而不同

②.实现

线性表有顺序存储和链式存储，队列是一种特殊的线性表，同样也存在这两种存储方式。我们先来看一下队列的顺序存储。
1、顺序队列的“假溢出”：

上图中，front指针指向队头元素，rear指针指向队尾元素的下一个位置。图(d)中b、c、d出队后，front指针指向元素e，rear指针在数组外面。假设这个队列的总个数不超过5个，但目前如果接着入队的话，因数组末尾元素已经被占用，再向后加就会产生数组越界的错误，可实际上队列在下标为0、1、2、3、4的地方还是空闲的，我们把这种现象叫做“假溢出”。

如何判断循环队列究竟是空的还是满的：
　　现在问题又来了，我们之前说，空队列时，front指针等于rear指针，那么现在循环队列满的时候，也是front等于rear，那么如何判断循环队列究竟是空的还是满的？有如下办法：
　　
　　
办法1：设置一个标志位flag。初始时置flag=0；每当入队列操作成功就置flag=1；
每当出队列操作成功就置flag=0。则队列空的判断条件为：rear == front && flag==0；
队列满的判断条件为：rear = = front && flag= =1。
办法2：保留一个元素的存储空间。此时，队列满时的判断条件为 (rear + 1) % maxSize
== front；队列空的判断条件还是front == rear。
办法3：设计一个计数器count，统计队列中的元素个数。此时，队列满的判断条件为：
count > 0 && rear == front ；队列空的判断条件为count == 0。 入队：
rear = (rear+ 1) % maxSize; 出队： front = (front + 1) % maxSize;

使用方式三实现：

public interface IQueue {
	
	//1 判断队列是否为满
	public boolean isFull();
	//2 判断队列是否为空
	boolean isEmpty();
	//3 入队
	void delete();
	//4 出队
	Object append(Object obj);
	//5 获取元素的个数
	int length();
	//6 输出
	public void display() ;
}

public class Queue implements IQueue {
	private Object[] queue;
	private int count = 0;//统计元素个数
	private int front = 0 ;//队头
	private int rear = 0;//队尾
	private int size;//容量
	public Queue() {
		this.size = 10;
		queue = new Object[this.size];
	}
	public Queue(int size) {
		this.size = size;
		queue = new Object[this.size];
	}
/*
 * 设计一个计数器count，统计队列中的元素个数。
 * 此时，队列满的判断条件为：count > 0 && rear == front ；
 * 队列空的判断条件为count == 0。
 *   
 * 入队：rear = (rear+ 1) % maxSize;   
 * 出队： front = (front + 1) % maxSize;
 */
	@Override
	public boolean isFull() {
		if(count > 0 && rear == front) {
			return true;
		}
		return false;
	}

	@Override
	public boolean isEmpty() {
		if(count ==0 ) {
			return true;
		}
		return false;
	}

	@Override
	public Object delete() {
		if(!isEmpty()) {
			Object obj = queue[front];//先获取元素  再移动指针
			front = (front+ 1) % size;
			count--;
			return obj;
		}else {
			throw new QueueException("队列为空");
		}
	}

	@Override
	public void append(Object obj) {
		 if(!isFull()) {
			 queue[rear]= obj;
			 rear = (rear + 1)% size;
			 count++;
		 }else {
			 throw new QueueException("队列已满");
		 }
	
	}

	@Override
	public int length() {
		return  count;
	}
	@Override
	public void display() {
		 for(int i = 0 ; i < count ; i++) {
			 System.out.print(queue[(front + i)% size]+"   ");
		 }
		 System.out.println();
		
	}

}

public class QueueException extends RuntimeException {
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	public QueueException() {
		super();
	}
	public QueueException(String msg) {
		super(msg);
	}
}

public class Test {
	public static void main(String[] args) {
		Queue q = new Queue(5);
		q.append(12);
		q.append(true);
		q.append("中北大学");
		q.append('A');
		q.append(21.0);
		Object o1 = q.delete();
		System.out.println("出队元素：" + o1);
		Object o2 = q.delete();
		System.out.println("出队元素：" + o2);
		Object o3 = q.delete();
		System.out.println("出队元素：" + o3);
		Object o4 = q.delete();
		System.out.println("出队元素：" + o4);
		Object o5 = q.delete();
		System.out.println("出队元素：" + o5);
		Object o6 = q.delete();
		System.out.println("出队元素：" + o6);
		q.display();
		
	}
}

3.链表

1、介绍

①链表通常由一连串节点组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向上一个/或下一个节点的位置的链接（“links”）
②链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。
③使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
④单向链表（Single-Linked List）:
单链表是链表中结构最简单的。一个单链表的节点(Node)分为两个部分，第一个部分(data)保存或者显示关于节点的信息，另一个部分存储下一个节点的地址。最后一个节点存储地址的部分指向空值。
⑤单向链表只可向一个方向遍历，一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。而插入一个节点，对于单向链表，我们只提供在链表头插入，只需要将当前插入的节点设置为头节点，next指向原头节点即可。删除一个节点，我们将该节点的上一个节点的next指向该节点的下一个节点。

在表头增加节点：

删除节点：

2、特点

①查找只能单向查找 ：每次需要从头节点开始
②插入的方式：头插 /尾插
③尾节点：next =null

3、实现

public interface ILinkedList {
	
	//1 添加元素
	boolean addElement(Object obj);
	//2 删除头元素
	boolean deleteHeadElement();
	//2.1 删除指定的元素
	boolean deleteElement(Object obj);
	//3 查找元素(判断指定数据是否在链表中存在)
	Object findElement(Object obj);
	//4 获取链表长度
	int  length();
	//5 遍历链表
	void diplay();
	//6 判断链表是否为空
	boolean isEmpty();
	
}

package org.lanqiao.linkedList;

public class SingleLinkedList   implements ILinkedList{
	
	private int size;//表示当前链表的节点数量
	private Node  head;//表示头节点
	
	
	// 使用成员内部类来实现节点
	public class Node {
		Object data;
		Node next ;//Object  obj = new Object()
		
		public Node() {
			super();
		}

		
		public Node(Object data) {
			super();
			this.data = data;
		}


		public Node(Object data, Node next) {
			super();
			this.data = data;
			this.next = next;
		}
		
	}
	/*
	 * 采用头插法
	 */
	@Override
	public boolean addElement(Object obj) {
		Node newNode = new Node(obj,null);
		if(isEmpty()) {//如果当前链表为空 
			head = newNode;
		}else { //当前链表不为空
			newNode.next = head;
			head = newNode;
		}
		size++;
		return true;
	}

	@Override
	public boolean deleteHeadElement() {
//		if(size == 1) {
//			head = null;
//		}else {
//			head = head.next;
//		}
		head = head.next;
		size--;
		return true;
	}
	//删除指定元素
	@Override
	public boolean deleteElement(Object obj) {
		Node  currentNode = head;
		Node  frontNode = head;
		int tempSize = size;//记录删除节点所在位置
		if(isEmpty()) {
			return false;
		}else {
			while(tempSize > 0) {
				if(currentNode.data.equals(obj)) {//当前节点是我们要找的节点
					if(currentNode.equals(head)) {
						deleteHeadElement();
						return true;
					}else {
						frontNode.next = currentNode.next;
					}
					
					size--;
					return true;
				}else {//当前节点不是我们要找的节点
					frontNode = currentNode;
					currentNode = currentNode.next;
					tempSize--;
				}
				
			}	
		}
		return false;
	}

	@Override
	public Object findElement(Object obj) {
		Node  currentNode = head;
		int tempSize = size;//记录删除节点所在位置
		if(isEmpty()) {
			return false;
		}else {
			while(tempSize > 0) {
				if(currentNode.data.equals(obj)) {//当前节点是我们要找的节点
					return currentNode.data;
				}else {//当前节点不是我们要找的节点
					currentNode = currentNode.next;
					tempSize--;
				}
				
			}	
		}
		return null;
	}

	@Override
	public int length() {
		// TODO Auto-generated method stub
		return size;
	}
	/*
	 * 显示的格式： [ o1 -> o2 ->o3->o4]
	 */
	@Override
	public void diplay() {
		Node currentNode = head;
		 if(isEmpty()) {
			 System.out.println("[]");
		 }else {
			 if(size == 1) {
				System.out.println("["+currentNode.data+"]"); 
			 }else {
				 System.out.print("[");
				 int tempSize = size;
				 while(tempSize > 0) {
					 System.out.print(currentNode.data+"->");
					 currentNode = currentNode.next;
					 tempSize--;
				 }
				 System.out.print("]");
				 
			 }
		 }
		System.out.println();
	}

	@Override
	public boolean isEmpty() {
		 
		return size == 0 ? true : false;
	}

}

public class Test {
	public static void main(String[] args) {
		SingleLinkedList sll = new SingleLinkedList();
		sll.addElement("aaa");
		sll.addElement("bbb");
		sll.addElement("ccc");
		sll.addElement("ddd");
		sll.diplay();
//		sll.deleteHeadElement();
//		sll.diplay();
//		sll.deleteHeadElement();
//		sll.diplay();
		Object obj = sll.findElement("aaa");
		System.out.println(obj);
	}
}

双向链表： 
头元素的front = null
尾元素的next = null
循环链表实在双向链表的基础上 
头元素的front = 尾元素
尾元素的next = 头元素

4.栈、队列与链表的区别

栈、队列是一种特殊（操作受限）的线性表

区别：仅在于运算规则不同
链表和数组是常用的两种数据存储结构，都能用来保存特定类型的数据。两者存在着一些差异
1.占用的内存空间
链表存放的内存空间可以是连续的，也可以是不连续的，数组则是连续的一段内存空间。一般情况下存放相同多的数据数组占用较小的内存，而链表还需要存放其前驱和后继的空间。
2.长度的可变性
链表的长度是按实际需要可以伸缩的，而数组的长度是在定义时要给定的，如果存放的数据个数超过了数组的初始大小，则会出现溢出现象。
3.对数据的访问
链表方便数据的移动而访问数据比较麻烦；数组访问数据很快捷而移动数据比较麻烦
链表和数组的差异决定了它们的不同使用场景，如果需要很多对数据的访问，则适合使用数组；如果需要对数据进行很多移位操作，则设和使用链表。

链表                                   
逻辑结构：一对一                     
存储结构：顺序表、链表         
运算规则：随机、顺序存取
栈
逻辑结构：一对一                     
存储结构：顺序栈、链栈
运算规则：后进先出
队列
逻辑结构：一对一                     
存储结构：顺序队、链队
运算规则：先进先出

五、算法

1.算法概述

①算法简单来说就是解决问题的步骤。
在Java中，算法通常都是由类的方法来实现的。前面的数据结构，比如链表为啥插入、删除快，而查找慢，平衡的二叉树插入、删除、查找都快，这都是实现这些数据结构的算法所造成的。
②逻辑结构和存储结构都相同, 但运算不同, 则数据结构不同. 例如, 栈与队列
③对于一种数据结构, 常见的运算
插入
删除
修改
查找
排序
④算法的五个特征
①、有穷性：对于任意一组合法输入值，在执行有穷步骤之后一定能结束，即：算法中的每个步骤都能在有限时间内完成。
②、确定性：在每种情况下所应执行的操作，在算法中都有确切的规定，使算法的执行者或阅读者都能明确其含义及如何执行。并且在任何条件下，算法都只有一条执行路径
③、可行性：算法中的所有操作都必须足够基本，都可以通过已经实现的基本操作运算有限次实现之。
④、有输入：作为算法加工对象的量值，通常体现在算法当中的一组变量。有些输入量需要在算法执行的过程中输入，而有的算法表面上可以没有输入，实际上已被嵌入算法之中。
⑤、有输出：它是一组与“输入”有确定关系的量值，是算法进行信息加工后得到的结果，这种确定关系即为算法功能
⑤算法的设计原则
　　①、正确性：首先，算法应当满足以特定的“规则说明”方式给出的需求。其次，对算法是否“正确”的理解可以有以下四个层次：
　　　一、程序语法错误。
　　　二、程序对于几组输入数据能够得出满足需要的结果。
　　　三、程序对于精心选择的、典型、苛刻切带有刁难性的几组输入数据能够得出满足要求的结果。
　　　四、程序对于一切合法的输入数据都能得到满足要求的结果。
　　　PS：通常以第 三 层意义的正确性作为衡量一个算法是否合格的标准。
　　②、可读性：算法为了人的阅读与交流，其次才是计算机执行。因此算法应该易于人的理解；另一方面，晦涩难懂的程序易于隐藏较多的错误而难以调试。
　　③、健壮性：当输入的数据非法时，算法应当恰当的做出反应或进行相应处理，而不是产生莫名其妙的输出结果。并且，处理出错的方法不应是中断程序执行，而是应当返回一个表示错误或错误性质的值，以便在更高的抽象层次上进行处理。
　　④、高效率与低存储量需求：通常算法效率值得是算法执行时间；存储量是指算法执行过程中所需要的最大存储空间，两者都与问题的规模有关。

2.递归

　百度百科中的解释是这样的：递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
　

递归，就是在运行的过程中调用自己。
　　递归必须要有三个要素：
　　①、边界条件
　　②、递归前进段
　　③、递归返回段
　　当边界条件不满足时，递归前进；当边界条件满足时，递归返回。
递归的二分查找
　在有序数组array[]中，不断将数组的中间值（mid）和被查找的值比较，如果被查找的值等于array[mid],就返回下标mid; 否则，就将查找范围缩小一半。如果被查找的值小于array[mid], 就继续在左半边查找;如果被查找的值大于array[mid], 就继续在右半边查找。 直到查找到该值或者查找范围为空时， 查找结束。
　
　二分查找用递归来实现，相信也很简单。边界条件是找到当前值，或者查找范围为空。否则每一次查找都将范围缩小一半。
分治算法
　　当我们求解某些问题时，由于这些问题要处理的数据相当多，或求解过程相当复杂，使得直接求解法在时间上相当长，或者根本无法直接求出。对于这类问题，我们往往先把它分解成几个子问题，找到求出这几个子问题的解法后，再找到合适的方法，把它们组合成求整个问题的解法。如果这些子问题还较大，难以解决，可以再把它们分成几个更小的子问题，以此类推，直至可以直接求出解为止。这就是分治策略的基本思想。
　　上面讲的递归的二分查找法就是一个分治算法的典型例子，分治算法常常是一个方法，在这个方法中含有两个对自身的递归调用，分别对应于问题的两个部分。
二分查找中，将查找范围分成比查找值大的一部分和比查找值小的一部分，每次递归调用只会有一个部分执行。

3.排序算法

排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程。

1.排序的分类

1) 内部排序:指将需要处理的所有数据都加载到内部存储器中进行排序。
2) 外部排序法：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。
3) 常见的排序算法分类(见下图):

2.算法的时间复杂度

度量一个程序(算法)执行时间的两种方法：
1)事后统计的方法
这种方法可行, 但是有两个问题：一是要想对设计的算法的运行性能进行评测，需要实际运行该程序；二是所得时间的统计量依赖于计算机的硬件、软件等环境因素, 这种方式，要在同一台计算机的相同状态下运行，才能比较那个算法速度更快。
2)事前估算的方法
通过分析某个算法的时间复杂度来判断哪个算法更优.
时间频度
时间频度：一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。==一个算法中的语句执行次数称为语句频度或时间频度。==记为T(n)。
时间复杂度
1)一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作 T(n)=Ｏ( f(n) )，称Ｏ( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度。
2)T(n) 不同，但时间复杂度可能相同。 如：T(n)=n²+7n+6 与 T(n)=3n²+2n+2 它们的T(n) 不同，但时间复杂度相同，都为O(n²)。
3)计算时间复杂度的方法：
•用常数1代替运行时间中的所有加法常数 T(n)=n²+7n+6 => T(n)=n²+7n+1
•修改后的运行次数函数中，只保留最高阶项 T(n)=n²+7n+1 => T(n) = n²
•去除最高阶项的系数 T(n) = n² => T(n) = n² => O(n²)
常见的时间复杂度

1)常数阶O(1)
2)对数阶O(log2n)
3)线性阶O(n)
4)线性对数阶O(nlog2n)
5)平方阶O(n^2)
6)立方阶O(n^3)
7)k次方阶O(n^k)
8)指数阶O(2^n)

说明：
常见的算法时间复杂度由小到大依次为：Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜ Ο(nk) ＜Ο(2n) ，随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低
①从图中可见，我们应该尽可能避免使用指数阶的算法
②平均时间复杂度和最坏时间复杂度
1)平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下，该算法的运行时间。
2)最坏情况下的时间复杂度称最坏时间复杂度。一般讨论的时间复杂度均是最坏情况下的时间复杂度。 这样做的原因是：最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限，这就保证了算法的运行时间不会比最坏情况更长。
3)平均时间复杂度和最坏时间复杂度是否一致，和算法有关(如图:)。

3.算法的空间复杂度

1)类似于时间复杂度的讨论，一个算法的空间复杂度(Space Complexity)定义为该算法所耗费的存储空间，它也是问题规模n的函数。
2)空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，例如快速排序和归并排序算法就属于这种情况
3)在做算法分析时，主要讨论的是时间复杂度。从用户使用体验上看，更看重的程序执行的速度。一些缓存产品(redis, memcache)和算法(基数排序)本质就是用空间换时间.

以时间换空间 以空间换时间

六、树结构

1、二叉树

树的常用术语(结合示意图理解):
1)节点 2)根节点 3)父节点
4)子节点 5)叶子节点 (没有子节点的节点)
6)节点的权(节点值)
7)路径(从root节点找到该节点的路线)
8)层
9)子树
10)树的高度(最大层数)
11)森林 :多颗子树构成森林

1二叉树的概念

1)树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
2)二叉树的子节点分为左节点和右节点。
3)如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。
4)如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。

2.二叉树遍历的说明

前序遍历: 先输出父节点，再遍历左子树和右子树
中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
小结: 看输出父节点的顺序，就确定是前序，中序还是后序

前序遍历：ABDFGHIEC
中序遍历：FDHGIBEAC
后序遍历：FHIGDEBCA
层序遍历：ABCDEFGHI

2、红黑树

红黑树是一种含有红黑结点并能自平衡的二叉查找树。它必须满足下面性质：
性质1：每个节点要么是黑色，要么是红色。
性质2：根节点是黑色。
性质3：每个叶子节点（NIL）是黑色。
性质4：每个红色结点的两个子结点一定都是黑色。
性质5：任意一结点到每个叶子结点的路径都包含数量相同的黑结点。

从性质5又可以推出：
性质5.1：如果一个结点存在黑子结点，那么该结点肯定有两个子结点
上图就是一颗简单的红黑树。其中Nil为叶子结点，并且它是黑色的。(值得提醒注意的是，在Java中，叶子结点是为null的结点。)

小结：

数据结构：
算法：
时间复杂度：衡量算法的执行效率
空间复杂度：衡量算法在执行时的空间利用率
以时间换空间 以空间换时间
递归算法
针对有序序列的 二分查找法
排序算法：冒泡排序 快速排序 选择排序 插入排序
树结构
满二叉树
完全二叉树
二叉树的遍历：
前序遍历
中序遍历
后序遍历
上述遍历方式 都是针对父节点而言
层序遍历