20210130 数据结构java实现学习与疑惑记录1

程序=数据结构+算法，记录学习复习的过程中遇到的问题，与总结。

1 稀松数组

稀疏数组不保存默认数组的默认值，因为我们知道默认值就是0，只需要保存我们需要的数据，这样就能用小数组来存。稀疏数组为n行3列的二维数组，第1行存的是原数组的信息，几行几列有效数(不为零)的个数；从第2行开始，则是保存的数组有效(不为零)的信息，依次为有效数的行列以及数值，如下：
稀疏数组为~~~~
11 11 3
1 2 1
2 3 2
4 5 2
所以稀疏数组n行 = 有效个数 + 1，稀疏数组将大部分为0的数据省略，因为我们知道默认的就是0，比如在一个很大的矩阵里，只有几个有效的个数，用稀疏数组保存，节省空间，可以用在棋盘、矩阵的保存。

2 队列

队列，先进先出，后进后出，
数组模拟队列，需要的参数，
maxSize最大队列的最大容量， front=-1指向队列头部，rear =-1指向队列尾，arr数组模拟队列。
队列满rear =maxSize-1,队列空rear=front。
进队判断是否已经满，然后队尾rear++;
出队判断队列是否已经空，然后队首front++；

数组模拟队列有问题，存满后再全部取出来，无法再次存数据。因为最后rear = = front = = maxSize-1,队列已满。

需要改变front与rear的赋值方式，初始化0，使其能够形成循环的队列。
队满(rear + 1) % maxSize == front，
队空rear = = front，
进队判断是否已经满，然后队尾 rear = (rear + 1) % maxSize，
出队判断队列是否已经空，然后队首front = (front + 1) % maxSize；使rear、front能够构成环状。

3 链表

java来模拟链表，在类里面放类，就像是套娃，一层套一层，

3.1 单向链表

单向链表的节点里用1个节点类来存放下1个节点类；

3.1.1 求单向链表中节点的个数

	//求单链表的有效长度
	public static int getLength(HeroNode node){
		HeroNode temp = node;
		if(temp.next == null){
			return 0;
		}
		int count = 0;
		while(temp.next != null){
			count++;
			temp = temp.next;
		}
		return count;
	}

3.1.2 求单链表中倒数k个节点

	//求单链表倒数k个节点
	public static HeroNode findLastNode(HeroNode head, int index){
		if(head.next == null){
			return null;
		}
		//第一次遍历得到链表的长度
		int length = getLength(head);
		if(index < 0 || index > length){
			return null;
		}
		//第二次遍历取节点
		HeroNode temp = head.next;
		for(int i=0;i<length-index;i++){
			temp = temp.next;
		}
		return temp;
	}

3.1.3 单链表的反转

	public static void reverseList(HeroNode head){
		//只有头节点和有一个节点，不用反转
		if(head.next == null || head.next.next == null){
			return;
		}
		//2个节点及以上反转,从头到尾依次遍历，依次取下节点，另一个头节点(reverseHead)指向该节点，该节点指向reverseHead的下一个节点
		HeroNode current = head.next;
		HeroNode next = null;
		HeroNode reverseHead = new HeroNode(0, "", "");
		while(current != null){
			next = current.next;
			current.next = reverseHead.next;
			reverseHead.next = current;
			current = next;
		}
		//将头节点交换
		head.next = reverseHead.next;
	}

3.1.4 从尾到头打印单链表

将链表逆序输出，1，可以将其反转，再依次打印，但是会破坏原链表的结构 2，使用栈，进行打印
以下反转会破坏原链表的结构
使用栈，先进后出，逆序打印

	public static void reversePrint(HeroNode head){
		if(head.next == null){
			System.out.println("链表为空~~");
		}
		Stack<HeroNode> stack = new Stack<HeroNode>();
		HeroNode temp = head.next;
		while(temp != null){
			stack.push(temp);
			temp = temp.next;
		}
		System.out.println(stack.size());
		//错误写法，pop后，stack.size就会减少，i++又自增
//		for (int i=0;i<stack.size();i++) {
//			System.out.println(stack.pop());
//		}
		while(stack.size() > 0){
			System.out.println(stack.pop());
		}
	}

3.1.5 合并2个有序单链表

合并2个有序链表，普通方式，比较大小后拆下来，再组装上去；使用递归的方式。

package cn.qiuhao.datasructure.linkedlist;

//合并2个有序单链表
public class MergeTwoSingleLinkedListed {

	public static void main(String[] args) {
		LinkNode node1 = new LinkNode(1);
        LinkNode node2 = new LinkNode(2);
        LinkNode node3 = new LinkNode(3);
        LinkNode node4 = new LinkNode(4);
        LinkNode node5 = new LinkNode(5);
        node1.next = node3;
        node3.next = node5;
        node2.next = node4;
        //LinkNode node = mergeTwoList(node1, node2);
        LinkNode node = mergeTwoList2(node2, node1);
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
	}
	
	/**
     * 递归方式合并两个单链表
     *
     * @param head1 有序链表1
     * @param head2 有序链表2
     * @return 合并后的链表
     */
    public static LinkNode mergeTwoList(LinkNode head1, LinkNode head2) {
        //递归结束条件
        if (head1 == null) {
            return head2;
        }
        if (head2 == null) {
            return head1;
        }
        //合并后的链表
        LinkNode head = null;
        if (head1.data > head2.data) {
            //把head较小的结点给头结点
            head = head2;
            //继续递归head2
            head.next = mergeTwoList(head1, head2.next);
        } else {
            head = head1;
            head.next = mergeTwoList(head1.next, head2);
        }
        return head;
    }
 
    /**
     * 非递归方式
     *
     * @param head1 有序单链表1
     * @param head2 有序单链表2
     * @return 合并后的单链表
     */
    public static LinkNode mergeTwoList2(LinkNode head1, LinkNode head2) {
        if (head1 == null || head2 == null) {
            return head1 != null ? head1 : head2;
        }
        //合并后单链表头结点
        LinkNode head = head1.data < head2.data ? head1 : head2;
        LinkNode cur1 = head == head1 ? head1 : head2;
        LinkNode cur2 = head == head1 ? head2 : head1;
        LinkNode pre = null;//cur1前一个元素
        LinkNode next = null;//cur2的后一个元素
        while (cur1 != null && cur2 != null) {
            //第一次进来肯定走这里
            if (cur1.data <= cur2.data) {
                pre = cur1;
                cur1 = cur1.next;
            } else {
                next = cur2.next;
                pre.next = cur2;
                cur2.next = cur1;
                pre = cur2;
                cur2 = next;
            }
        }
        pre.next = cur1 == null ? cur2 : cur1;
        return head;
    }
}


class LinkNode{
	public int data;
	public LinkNode next;
	
	public LinkNode(int data) {
		super();
		this.data = data;
	}
}

3.2 双向链表

双向链表里节点里用2个节点类来存放下1个节点类和上一个节点类；

3.3 单向循环链表

单向循环链表，尾指针指向头指针，单向循环链表可以用于出圈问题。单向链表在遍历时，头节点不能动，需要辅助节点temp指针来进行遍历，如果做删除操作，temp指针遍历到要删除位置的上一个节点，判断条件则为，temp.next.no == no，如果遍历到要删除元素的位置，则无法进行删除，因为丢失了上一个节点的信息。

3.3.1 约瑟夫问题

约瑟夫出圈问题，例如5个人，从1开始数，数2下，1、2到2，与数7下，1、 2、3、 4、 5、 1、 2，不同，7多了一圈，虽然第一次都是到2，但是随着人数出圈，圈内人数越来越少，两者的结果完全不同，出圈顺序也不同。除非不出圈，只是数数，人数5，7与2相差正好一周期，那无所谓。

3.3.1.1 使用2个指针

使用单循环链表，用2个指针，删除当前元素的位置指针first，出圈的元素即就是要删除的元素，与删除前一个元素的位置指针last，删除时让last指向first.next元素，首先遍历找到指向head头节点的指针也就是last，然后first指针指向头节点，这是从头节点开始，如果开始数不为1，如果从startNo开始，那么就让这2个指针依次移动startNo-1次(在找last指针时可以优化，如果startNo从1开始，就需要遍历到最后找last，如果startNo不是从1开始，在挪动startNo-1次操作时，就能找到last节点)，元素出圈打印后，进行删除，先让first元素向下移动一个元素，然后让last指向first，当last==first元素时，则圈内只有一个元素；

	/**
	 * startNo 从第几个小孩开始数
	 * countNums 表示数几下
	 * nums 表示最开始小孩的个数
	* @author: qiuhao
	* @date: 2021年1月20日
	*
	 */
	public void countBoy(int startNo, int countNums, int nums){
		if(first == null || startNo < 1 || startNo > nums || countNums < 1){
			System.out.println("参数有误，请重新输入。");
		}
		//需要一个辅助指针，使其找到环形链表的最后
		Boy1 helper = first;
		//如果从1开始，是需要遍历到最后一个节点
		if(startNo == 1){
			while(true){
				if(helper.getNext() == first){
					break;
				}
				helper = helper.getNext();
			}
			//从 startNo 个开始，先挪动 startNo - 1次；
			for(int i=0;i< startNo-1;i++){
				first = first.getNext();
				helper = helper.getNext();
			}
		}else{
			//如果不是从1开始，helper就是那么遍历到第 startNo 个节点前一个节点
			Boy1 another = first;
			for(int i=0;i< startNo-1;i++){
				first = first.getNext();
				helper = another;
				another = another.getNext();
			}
		}

		while(true){
			if(helper == first){
				break;
			}
			for(int j=0;j<countNums-1;j++){
				first = first.getNext();
				helper = helper.getNext();
			}
			System.out.printf("小孩%d出圈\n", first.getNo());
			//以下都一样
			//first = first.getNext();
			//helper.setNext(first);
			helper.setNext(first.getNext());
			first = first.getNext();
		}
		System.out.printf("最后留在圈中的小孩编号%d \n", first.getNo());
	}

3.1.3.2 使用1个指针

也可以使用一个指针进行优化，先从startNo开始，挪动后，先用指针找到出圈元素的上一个元素，移动次数countNum-2次，即这里 countNum 分为2种情况，>=2时，不影响，<2时其实就是1，数一下，直接遍历就能得到出圈顺序。出圈问题，数countNum下，则需要移动的其实是countNum - 1下，从1开始，数3下，1、2、3，实际从1开始只需要移动2下。

	/**
	 * startNo 从第几个小孩开始数
	 * countNums 表示数几下
	 * nums 表示最开始小孩的个数
	* @author: qiuhao
	* @date: 2021年1月20日
	*
	 */
	public void countBoy(int startNo, int countNums, int nums){
		if(first == null || startNo < 1 || startNo > nums || countNums < 1){
			System.out.println("参数有误，请重新输入。");
		}

		//从 startNo 个开始，先挪动 startNo - 1次；
		for(int i=0;i< startNo-1;i++){
			first = first.getNext();
		}
			
		//数一下的话，需要找到最后一个节点,让first从最后一个开始,直接遍历，不用删除节点
		if(countNums == 1) {
			Boy2 temp = first;
			while(true){
				System.out.printf("小孩%d出圈\n", temp.getNo());
				if(temp.getNext() == first){
					break;
				}
				temp = temp.getNext();
			}
			return;
		}else {
			while(true){
				if(first.getNext() == first){
					break;
				}
				//如果数3下，移动2次当节点，上一个节点丢失，需要helper指针辅助，
				//如果只移动到出圈的上一个节点，则移动的是 countNums-2次
				//数一下的话，需要找到最后一个节点
				if(countNums >= 2) {
					for(int j=0;j<countNums-2;j++){
						first = first.getNext();
					}
					System.out.printf("小孩%d出圈\n", first.getNext().getNo());
				}
				first.setNext(first.getNext().getNext());
				first = first.getNext();
			}
			System.out.printf("最后留在圈中的小孩编号%d \n", first.getNo());
		}
	}

4 栈

栈、先进后出，后进先出
中缀表达式转后缀表达式，使用栈进行计算器计算字符串表达式，要复习。

4.1 数组模拟栈

package cn.qiuhao.datasructure.stack;

import java.util.Scanner;

public class ArrayStackDemo {

	public static void main(String[] args) {
		//测试一下ArrayStack 是否正确
		//先创建一个ArrayStack对象->表示栈
		ArrayStack stack = new ArrayStack(4);
		String key = "";
		boolean loop = true; //控制是否退出菜单
		Scanner scanner = new Scanner(System.in);
		
		while(loop) {
			System.out.println("show: 表示显示栈");
			System.out.println("exit: 退出程序");
			System.out.println("push: 表示添加数据到栈(入栈)");
			System.out.println("pop: 表示从栈取出数据(出栈)");
			System.out.println("请输入你的选择");
			key = scanner.next();
			switch (key) {
			case "show":
				stack.list();
				break;
			case "push":
				System.out.println("请输入一个数:");
				int value = scanner.nextInt();
				stack.push(value);
				break;
			case "pop":
				try {
					int res = stack.pop();
					System.out.printf("出栈的数据是 %d\n", res);
				} catch (Exception e) {
					// TODO: handle exception
					System.out.println(e.getMessage());
				}
				break;
			case "exit":
				scanner.close();
				loop = false;
				break;
			default:
				break;
			}
		}
		
		System.out.println("程序退出~~~");
	}

}

//定义一个 ArrayStack 表示栈
class ArrayStack {
	private int maxSize; // 栈的大小
	private int[] stack; // 数组，数组模拟栈，数据就放在该数组
	private int top = -1;// top表示栈顶，初始化为-1
	
	//构造器
	public ArrayStack(int maxSize) {
		this.maxSize = maxSize;
		stack = new int[this.maxSize];
	}
	
	//栈满
	public boolean isFull() {
		return top == maxSize - 1;
	}
	//栈空
	public boolean isEmpty() {
		return top == -1;
	}
	//入栈-push
	public void push(int value) {
		//先判断栈是否满
		if(isFull()) {
			System.out.println("栈满");
			return;
		}
		top++;
		stack[top] = value;
	}
	//出栈-pop, 将栈顶的数据返回
	public int pop() {
		//先判断栈是否空
		if(isEmpty()) {
			//抛出异常
			throw new RuntimeException("栈空，没有数据~");
		}
		int value = stack[top];
		top--;
		return value;
	}
	//显示栈的情况[遍历栈]， 遍历时，需要从栈顶开始显示数据
	public void list() {
		if(isEmpty()) {
			System.out.println("栈空，没有数据~~");
			return;
		}
		//需要从栈顶开始显示数据
		for(int i = top; i >= 0 ; i--) {
			System.out.printf("stack[%d]=%d\n", i, stack[i]);
		}
	}
}

4.2 链表模拟栈

链表模拟栈，push节点到链表的最后，有问题，显示的时候不好遍历，应该每次添加到head节点的下一个节点，然后顺序遍历。

package cn.qiuhao.datasructure.stack;

/**
 * 链表模拟栈，push节点添加到head节点的下一个节点，然后顺序遍历
* @author: qiuhao
* @date: 2021年1月21日
*
 */
public class LinkedListStackDemo2 {

	public static void main(String[] args) {
		LinkedListStack2 stack = new LinkedListStack2(5);
		LinkedListNode2 node1 = new LinkedListNode2(1, "张三");
		LinkedListNode2 node2 = new LinkedListNode2(2, "李四");
		LinkedListNode2 node3= new LinkedListNode2(3, "王五");
		LinkedListNode2 node4= new LinkedListNode2(4, "黑刘");
		LinkedListNode2 node5= new LinkedListNode2(5, "廖起");
		LinkedListNode2 node6= new LinkedListNode2(6, "吴撒");
		System.out.println("栈内元素~~~");
		stack.list();
		stack.push(node1);
		stack.push(node2);
		stack.push(node3);
		stack.push(node4);
		stack.push(node5);
		stack.push(node6);
		System.out.println("栈内元素~~~");
		stack.list();
		System.out.printf("出栈~~~~");
		stack.pop();
		System.out.printf("出栈~~~~");
		stack.pop();
		System.out.println("栈内元素~~~");
		stack.list();
	}
}

// 链表模拟栈
class LinkedListStack2 {

	// 栈的最大数量
	public int maxSize;

	// 定义一个头节点
	LinkedListNode2 head = new LinkedListNode2(0, "");

	public LinkedListStack2(int maxSize) {
		super();
		this.maxSize = maxSize;
	}

	// 栈满，判断节点的个数
	public boolean isFull() {
		LinkedListNode2 temp = head;
		int count = 0;
		while (true) {
			if (temp.next == null) {
				break;
			}
			temp = temp.next;
			count++;
		}
		return count == maxSize;
	}

	// 栈空
	public boolean isEmpty() {
		return head.next == null;
	}

	// 入栈
	public void push(LinkedListNode2 node) {
		if (isFull()) {
			System.out.println("栈满,不能入栈。");
			return;
		}
		LinkedListNode2 cur = head.next;
		head.next = node;
		node.next = cur;
		cur = node;
	}

	// 出栈
	public void pop() {
		if (isEmpty()) {
			System.out.println("\n栈空，没有数据~\n");
			return;
		}
		LinkedListNode2 cur = head.next;
		System.out.println(cur);
		cur = cur.next;
		head.next = cur;
	}

	// 显示栈数据
	public void list() {
		if (isEmpty()) {
			System.out.println("栈空，没有数据~");
			return;
		}
		LinkedListNode2 cur = head.next;
		while(cur != null){
			System.out.println(cur);
			cur = cur.next;
		}
	}
}

class LinkedListNode2 {

	public int num;

	public String name;

	public LinkedListNode2 next;

	public LinkedListNode2(int n, String name) {
		this.num = n;
		this.name = name;
	}

	@Override
	public String toString() {
		return "LinkedListNode2 [num=" + num + ", name=" + name + "]";
	}
}

4.3 使用数组栈模拟计算器

4.4 逆波兰计算器

4.5 中缀转后缀表达式

5 递归

递归需要遵守的重要规则

执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
方法的局部变量是独立的，不会相互影响, 比如n变量
如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据.
递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了:)
当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

5.1 迷宫问题

package cn.qiuhao.datasructure.recursion;
/**
 * @ClassName: MiGong.java
 * @Description: 使用递归，迷宫回溯，找通路
 * @author qiuhao
 * @date 2021年1月23日
 *
 */
public class MiGong {

	public static void main(String[] args) {
		//先创建一个二维数组,模拟迷宫
		//地图
		int [][] map = new int[8][7];
		//使用1表示墙
		//左右全部置为1
		for(int i=0;i<7;i++) {
			map[0][i] = 1;
			map[7][i] = 1;
		}
		
		//上下全部置为1
		for(int i=0;i<8;i++) {
			map[i][0] = 1;
			map[i][6] = 1;
		}
		
		//设置挡板
		map[3][1] = 1;
		map[3][2] = 1;
		
		
		// 输出地图
		System.out.println("地图的情况");
		for (int i = 0; i < 8; i++) {
			for (int j = 0; j < 7; j++) {
				System.out.print(map[i][j] + " ");
			}
			System.out.println();
		}
		
		//使用递归回溯给小球找路
		setWay(map, 1, 1);
		//setWay2(map, 1, 1);
		
		//输出新的地图, 小球走过，并标识过的递归
		System.out.println("小球走过，并标识过的 地图的情况");
		for (int i = 0; i < 8; i++) {
			for (int j = 0; j < 7; j++) {
				System.out.print(map[i][j] + " ");
			}
			System.out.println();
		}
		
	}
	
	//使用递归回溯来给小球找路
	//说明
	//1. map 表示地图
	//2. i,j 表示从地图的哪个位置开始出发 (1,1)
	//3. 如果小球能到 map[6][5] 位置，则说明通路找到.
	//4. 约定： 当map[i][j] 为 0 表示该点没有走过 当为 1 表示墙  ； 2 表示通路可以走 ； 3 表示该点已经走过，但是走不通
	//5. 在走迷宫时，需要确定一个策略(方法) 下->右->上->左 , 如果该点走不通，再回溯
	/**
	 * 
	 * @param map 表示地图
	 * @param i 从哪个位置开始找
	 * @param j 
	 * @return 如果找到通路，就返回true, 否则返回false
	 */
	public static boolean setWay(int[][] map, int i, int j) {
		if(map[6][5] == 2) { // 通路已经找到ok
			return true;
		} else {
			if(map[i][j] == 0) { //如果当前这个点还没有走过
				//按照策略 下->右->上->左  走
				map[i][j] = 2; // 假定该点是可以走通.
				if(setWay(map, i+1, j)) {//向下走
					return true;
				} else if (setWay(map, i, j+1)) { //向右走
					return true;
				} else if (setWay(map, i-1, j)) { //向上
					return true;
				} else if (setWay(map, i, j-1)){ // 向左走
					return true;
				} else {
					//说明该点是走不通，是死路
					map[i][j] = 3;
					return false;
				}
			} else { // 如果map[i][j] != 0 , 可能是 1， 2， 3
				return false;
			}
		}
	}
	
	//修改找路的策略，改成 上->右->下->左
	public static boolean setWay2(int[][] map, int i, int j) {
		if(map[6][5] == 2) { // 通路已经找到ok
			return true;
		} else {
			if(map[i][j] == 0) { //如果当前这个点还没有走过
				//按照策略 上->右->下->左
				map[i][j] = 2; // 假定该点是可以走通.
				if(setWay2(map, i-1, j)) {//向上走
					return true;
				} else if (setWay2(map, i, j+1)) { //向右走
					return true;
				} else if (setWay2(map, i+1, j)) { //向下
					return true;
				} else if (setWay2(map, i, j-1)){ // 向左走
					return true;
				} else {
					//说明该点是走不通，是死路
					map[i][j] = 3;
					return false;
				}
			} else { // 如果map[i][j] != 0 , 可能是 1， 2， 3
				return false;
			}
		}
	}
}

5.2 八皇后问题

疑惑：判断是否在同一条斜线上，使用斜率方式Math.abs(a)/Math.abs(b)= =1无法求解。
解：斜率为1思路没有问题，但是在java中，除法3/2==1，被除数应该强转成float或者double类型，否则 Math.abs(a) == Math.abs(b）是不等的条件。
八皇后问题实际上就是找出每一种可能的形式，8*8的棋盘，从棋盘左下角，第1行第1列开始放，每次放的皇后，都和前面放的所有的皇后进行判断，判断是否满足条件，如果满足就继续放，注意每次放皇后的时候都是进行了循环的，在递归的时候只要不满足，就会返回上一层，继续下一次循环。当第1行第1列这种情况找完了，就继续循环放，第1行第2列开始找。

package cn.qiuhao.datasructure.recursion;

/**
 * @ClassName: Queen8.java
 * @Description: 8皇后问题，2个皇后不能再同一行，同一列，同一斜线,有多少种摆法
 * 注意判断斜率的话，被除数要是float或者double类型，整型3/2==1
 * @author qiuhao
 * @date 2021年1月24日
 *
 */
public class Queen8 {

		//定义一个max表示共有多少个皇后
		int max = 8;
		//定义数组array, 保存皇后放置位置的结果,比如 arr = {0 , 4, 7, 5, 2, 6, 1, 3} 
		int[] array = new int[max];
		static int count = 0;
		static int judgeCount = 0;
		public static void main(String[] args) {
			//测试一把 ， 8皇后是否正确
			Queen8 queen = new Queen8();
			queen.check(0);
			System.out.printf("一共有%d解法", count);
			System.out.printf("一共判断冲突的次数%d次", judgeCount); // 1.5w
		}
		
		//编写一个方法，放置第n个皇后
		//特别注意： check 是 每一次递归时，进入到check中都有  for(int i = 0; i < max; i++)，因此会有回溯
		private void check(int n) {
			if(n == max) {  //n = 8 , 其实8个皇后就既然放好
				print();
				return;
			}
			
			//依次放入皇后，并判断是否冲突
			for(int i = 0; i < max; i++) {
				//先把当前这个皇后 n , 放到该行的第1列
				array[n] = i;
				//判断当放置第n个皇后到i列时，是否冲突
				if(judge(n)) { // 不冲突
					//接着放n+1个皇后,即开始递归
					check(n+1); //  
				}
				//如果冲突，就继续执行 array[n] = i; 即将第n个皇后，放置在本行得 后移的一个位置
			}
		}
		
		//查看当我们放置第n个皇后, 就去检测该皇后是否和前面已经摆放的皇后冲突
		/**
		 * 
		 * @param n 表示第n个皇后
		 * @return
		 */
//		private boolean judge(int n) {
//			judgeCount++;
//			for(int i = 0; i < n; i++) {
//				// 说明
//				//1. array[i] == array[n]  表示判断 第n个皇后是否和前面的n-1个皇后在同一列
//				//2. Math.abs(n-i) == Math.abs(array[n] - array[i]) 表示判断第n个皇后是否和第i皇后是否在同一斜线
//				// n = 1  放置第 2列 1 n = 1 array[1] = 1
//				// Math.abs(1-0) == 1  Math.abs(array[n] - array[i]) = Math.abs(1-0) = 1
//				//3. 判断是否在同一行, 没有必要，n 每次都在递增
//				if(array[i] == array[n] || Math.abs(n-i) == Math.abs(array[n] - array[i]) ) {
//					return false;
//				}
//			}
//			return true;
//		}
		
		//注意判断斜率的话，被除数要是float或者double类型，整型3/2==1
		private boolean judge(int n) {
			judgeCount++;
			for (int i = 0; i < n; i++) {
				if (array[n] == array[i] || ((Math.abs((n - i)) / (float)(Math.abs(array[n] - array[i])) == 1))) {
					return false;
				}
			}
			return true;
		}
		
		//写一个方法，可以将皇后摆放的位置输出
		private void print() {
			count++;
			for (int i = 0; i < array.length; i++) {
				System.out.print(array[i] + " ");
			}
			System.out.println();
		}
	}

6 八大排序

冒泡、选择、插入、希尔、快速、归并、基数、堆排序

6.1 冒泡排序

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。

冒泡排序慢、但是很稳定；时间复杂度 O(n^2),
10个数，比较9趟，第1趟比较9次，第2趟比较8次，第3趟比较7次，
n个数，比较n-1趟，每一趟比较n-1-i 次。
每次比完一趟，最大的数就会移动到最后。

冒泡排序可以优化，在一趟排序中，一次交换都没有发生过，则代表已经完成了排序，提前break

	public static void bubbleSort(int[] arr) {
		int temp = 0; // 临时变量
		boolean flag = false; // 标识变量，表示是否进行过交换
		for (int i = 0; i < arr.length - 1; i++) {

			for (int j = 0; j < arr.length - 1 - i; j++) {
				// 如果前面的数比后面的数大，则交换
				if (arr[j] > arr[j + 1]) {
					flag = true;
					temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
			//System.out.println("第" + (i + 1) + "趟排序后的数组");
			//System.out.println(Arrays.toString(arr));

			if (!flag) { // 在一趟排序中，一次交换都没有发生过
				break;
			} else {
				flag = false; // 重置flag!!!, 进行下次判断
			}
		}
	}

6.2 选择排序

选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。

选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从arr[0]_{arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]}arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]_{arr[n-1]中选取最小值，与arr[2]交换，…，第i次从arr[i-1]}arr[n-1]中选取最小值，与arr[i-1]交换，…, 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。
选

	//选择排序
	public static void selectSort(int[] arr) {
		//在推导的过程，我们发现了规律，因此，可以使用for来解决
		//选择排序时间复杂度是 O(n^2)
		for (int i = 0; i < arr.length - 1; i++) {
			int minIndex = i;
			int min = arr[i];
			for (int j = i + 1; j < arr.length; j++) {
				if (min > arr[j]) { // 说明假定的最小值，并不是最小
					min = arr[j]; // 重置min
					minIndex = j; // 重置minIndex
				}
			}

			// 将最小值，放在arr[0], 即交换
			if (minIndex != i) {
				arr[minIndex] = arr[i];
				arr[i] = min;
			}

			//System.out.println("第"+(i+1)+"轮后~~");
			//System.out.println(Arrays.toString(arr));// 1, 34, 119, 101
		}
  }

择排序是,让当前元素 去找 当前元素后最小的那个数。

6.3 插入排序

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

	//插入排序
	public static void insertSort(int[] arr) {
		int insertVal = 0;
		int insertIndex = 0;
		//使用for循环来把代码简化
		for(int i = 1; i < arr.length; i++) {
			//定义待插入的数
			insertVal = arr[i];
			insertIndex = i - 1; // 即arr[1]的前面这个数的下标
	
			// 给insertVal 找到插入的位置
			// 说明
			// 1. insertIndex >= 0 保证在给insertVal 找插入位置，不越界
			// 2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置
			// 3. 就需要将 arr[insertIndex] 后移
			while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
				arr[insertIndex + 1] = arr[insertIndex];// arr[insertIndex]
				insertIndex--;
			}
			// 当退出while循环时，说明插入的位置找到, insertIndex + 1
			//这里我们判断是否需要赋值 如果要插入的位置没有移动，则表示  insertVal == arr[insertIndex]
			if(insertIndex + 1 != i) {
				arr[insertIndex + 1] = insertVal;
			}
	
			//System.out.println("第"+i+"轮插入");
			//System.out.println(Arrays.toString(arr));
		}
	}

插入排序是找的当前元素，把当前元素拿去和前面的排。

6.4 希尔排序

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。

希尔排序法基本思想
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

移位法，交换位置，效率低。

	public static void shellSort(int[] arr) {
		int temp = 0;
		int count = 0;
		// 根据前面的逐步分析，使用循环处理
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			for (int i = gap; i < arr.length; i++) {
				// 遍历各组中所有的元素(共gap组，每组有个元素), 步长gap
				for (int j = i - gap; j >= 0; j -= gap) {
					// 如果当前元素大于加上步长后的那个元素，说明交换
					if (arr[j] > arr[j + gap]) {
						temp = arr[j];
						arr[j] = arr[j + gap];
						arr[j + gap] = temp;
					}
				}
			}
			//System.out.println("希尔排序第" + (++count) + "轮 =" + Arrays.toString(arr));
		}
	}

交换法

	//对交换式的希尔排序进行优化->移位法
	public static void shellSort2(int[] arr) {
		int count = 0;
		// 增量gap, 并逐步的缩小增量
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			// 从第gap个元素，逐个对其所在的组进行直接插入排序
			for (int i = gap; i < arr.length; i++) {
				int temp = arr[i];
				int j = i - gap ;
				while (j >= 0 && temp < arr[j]) {
					//移动
					arr[j + gap] = arr[j];
					j -= gap;
				}
				//当退出while后，就给temp找到插入的位置
				if(j + gap != i){
					arr[j + gap] = temp;
				}
				
//				for(;j>=0;j-=gap) {
//					if(temp < arr[j]) {
//						arr[j+gap] = arr[j];
//					}else {
//						break;
//					}
//				}
//				if(j+gap != i) {
//					arr[j+gap] = temp;
//				}
			}
			//System.out.println("希尔排序第" + (++count) + "轮 =" + Arrays.toString(arr));
			//System.out.println("希尔排序第" + (++count) + "轮 ");
		}
	}

希尔排序是插入排序的优化版，分为交换法与移位法，交换法每个数都要交换位置效率低，移位法移动元素的位置，没有进行交换的繁琐操作，所以效率快的多。希尔排序 arr.length/2=gap(步长), 10/2=5,步长5，组数5，每组2个元素。

6.5 快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

快速排序分2种，分别为中轴在前面与中轴在中间

6.5.1 中轴在中间

中轴在中间

	public static void quickSort(int[] arr,int left, int right) {
		int l = left; //左下标
		int r = right; //右下标
		//pivot 中轴值
		int pivot = arr[(left + right) / 2];
		int temp = 0; //临时变量，作为交换时使用
		//while循环的目的是让比pivot 值小放到左边
		//比pivot 值大放到右边
		while( l < r) { 
			//在pivot的左边一直找,找到大于等于pivot值,才退出
			//while( arr[l] <= pivot) 这个地方不能取<=,取=可能会导致l<r时，l和r都位于中轴的同侧, 例如 {9,9,9,9,10,-1};
			while( arr[l] < pivot) {
				l += 1;
			}
			//在pivot的右边一直找,找到小于等于pivot值,才退出
			//while(arr[r] >= pivot) 这个地方不能取<=,取=可能会导致l<r时，l和r都位于中轴的同侧, 例如 {9,9,9,9,10,-1};
			while(arr[r] > pivot) {
				r -= 1;
			}
			//如果l >= r说明pivot 的左右两的值，已经按照左边全部是
			//小于等于pivot值，右边全部是大于等于pivot值
			if( l >= r) {
				break;
			}
			
			//交换
			temp = arr[l];
			arr[l] = arr[r];
			arr[r] = temp;
			
			//注意这个地方是为了打破死循环，且防止下标越过中轴的下标，防止l、r下标跑到中轴的同一侧，
			//这样lr还是和中值比较交换，但是lr确在一侧，导致未被了中轴左边比它小，中轴右边比它大的思想。
			//如果交换完后，发现这个arr[l] == pivot值 相等 r--， 前移
			if(arr[l] == pivot) {
				r -= 1;
			}
			//如果交换完后，发现这个arr[r] == pivot值 相等 l++， 后移
			if(arr[r] == pivot) {
				l += 1;
			}
		}
		
		// 如果 l == r, 必须l++, r--,否则为出现栈溢出；将l、r错开，l、r作为下次递归的条件
		if (l == r) {
			l += 1;
			r -= 1;
		}
		//向左递归
		if(left < r) {
			quickSort(arr, left, r);
		}
		//向右递归
		if(right > l) {
			quickSort(arr, l, right);
		}
	}

疑惑：中轴在中间的时候，判断的时候的疑惑，左边= =中轴值，移动右边的下边，右边= =中轴值，移动左边的下边，为何不是左边相等后，移动左边，右边相等后，移动右边，这样会报错。
解：中轴在中间的时候，是为了保证移动的下标左边l与右边r只会汇聚在中轴值下标处，不会让他们交叉。这里做的这个判断是为了，打破死循环的僵局，如果arr[l]与arr[r]都等于中轴值，那么下次循环就会陷入死循环；相等情况下标往同侧移动的话，如果只有一方等于，另一方不等于的话，等于的这一方下标在同侧向中轴移动时，理想的情况下是，l和r在中轴下标重合，这样是没有问题的，但是假如l先到达了中轴，r还未达到中轴，下次判断的时候那么l就又会移动，注意这个时候l就越过了中轴，l与r都在中轴值的右侧了，进行交换时，就没有意义了，违背了快排中轴值左边全部比它小，右边全部比它大的思想。

中轴值取中间数的时候，第一个while内的那2个while条件， while( arr[l] < pivot) 与 while(arr[r] > pivot)都不能取等于，举例数据 {9,9,9,9,10,-1}。
必须保证 l 和 r 移动，只能相聚在中轴处，如果越过了中轴，l和r都位于中轴的同侧，再进行交换比较就没有意义了。if(arr[l] = = pivot) 与 if(arr[r] = = pivot) 做判断是为了打破死循环的僵局，但是必须移动的是对面的下标，如果移动同侧下标，也会出现下标越界的情况，严禁l与r在中轴同侧，只能汇聚在中轴处。

6.5.2 中轴在左边

中轴在左边，取第一个数。以下代码测试没有问题，总结完基数排序后，再举了一个例子，竟然错了，说明有时候算法测试的时候，很有可能测试数据刚好就漏掉了你没判断到的情况，错误示例：int[] arr = {9,9,8,-1};

	public static void quickSort1(int[] arr,int left, int right) {
		int pivot = arr[left];
		
		while(left < right) {
			while(left < right && arr[right] >= pivot) {
				right--;
			}
			arr[left] = arr[right];
			
			while(left < right && arr[left] <= pivot) {
				left++;
			}
			arr[right] = arr[left];
		}
		
		arr[left] = pivot;
		
		if(left < right-1) {
			quickSort1(arr, left, right-1);
		}
		if(right+1 < right) {
			quickSort1(arr, left+1, right);
		}
	}

正确代码如下，left 与 right应该记录下来，不应该直接移动，造成位置丢失。

	public static void quickSort1(int[] arr,int left, int right) {
		int l = left;
		int r = right;
		int pivot = arr[left];
		
		while(l < r) {
			while(l < r && arr[r] >= pivot) {
				r--;
			}
			arr[l] = arr[r];
			
			while(l < r && arr[l] <= pivot) {
				l++;
			}
			arr[r] = arr[l];
		}
		
		arr[l] = pivot;
		
		if(left < r-1) {
			quickSort1(arr, left, r-1);
		}
		if(r+1 < right) {
			quickSort1(arr, r+1, right);
		}
	}

测试取左边比取中间速度要快，随机1000w个数，取中间排序大致1.2s，取左边大致1s。

中轴取左边第一个数时，
判断条件 while(left < right && arr[right] >= pivot) 与 while(left < right && arr[left] <= pivot)
arr[right] >= pivot 与 arr[left] <= pivot 这里必须取到等于，如果不取等于，举例数据 int[] arr = {5,5,5,5,5,5}; 会陷入死循环；
其次，判断left < right 不能少，因为while刚开始进来是 left < right ，可能第一个while后，right–后可能就会越界了，right<left, 举例数据，int[] arr = {5,5,5,5,5,5};

总结：
中轴取中间，下标l与r必须相聚在中轴处，l与r不能越界，不能在中轴同侧，当判断值与中轴值相等时，则移动对面的下标，防止越界。
中轴取左边，下标 left < right， 防止 right-- 与 left++越界。

6.6 归并排序

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

归并排序思想
合并相邻有序子序列:我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]。

	// 分+合方法
	public static void mergeSort(int[] arr, int left, int right, int[] temp) {
		if (left < right) {
			int mid = (left + right) / 2; // 中间索引
			// 向左递归进行分解
			mergeSort(arr, left, mid, temp);
			// 向右递归进行分解
			mergeSort(arr, mid + 1, right, temp);
			// 合并
			merge(arr, left, mid, right, temp);
		}
	}

	/**
	 * 合并的方法
	 * 
	 * @param arr   排序的原始数组
	 * @param left  左边有序序列的初始索引
	 * @param mid   中间索引
	 * @param right 右边索引
	 * @param temp  做中转的数组
	 */
	public static void merge(int[] arr, int left, int mid, int right, int[] temp) {
		int i = left; // 初始化i, 左边有序序列的初始索引
		// 初始化j, 右边有序序列的初始索引 这个地方必须取mid+1,不然会下标越界
		// 例如数组{0,1},left=0, right=1, mid如果为0,在第一个while后, count已经移位置, temp[count++] = arr[j++]; count会越界
		int j = mid+1;
		int count = 0; // 指向temp数组的当前索引

		// (一)
		// 先把左右两边(有序)的数据按照规则填充到temp数组
		// 直到左右两边的有序序列，有一边处理完毕为止
		while (i <= mid && j <= right) {// 继续
			// 如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
			// 即将左边的当前元素，填充到 temp数组
			// 然后 t++, i++
			if (arr[i] <= arr[j]) {
				temp[count++] = arr[i++];
			} else { // 反之,将右边有序序列的当前元素，填充到temp数组
				temp[count++] = arr[j++];
			}
		}

		// (二)
		// 把有剩余数据的一边的数据依次全部填充到temp
		while (j <= right) { // 左边的有序序列还有剩余的元素，就全部填充到temp
			temp[count++] = arr[j++];
		}

		while (i <= mid) { // 右边的有序序列还有剩余的元素，就全部填充到temp
			temp[count++] = arr[i++];
		}

		// (三)
		// 将temp数组的元素拷贝到arr
		// 注意，并不是每次都拷贝所有
		count = 0;
		// 第一次合并 tempLeft = 0 , right = 1 // tempLeft = 2 right = 3 // tL=0 ri=3
		// 最后一次 tempLeft = 0 right = 7
		while (left <= right) {
			arr[left++] = temp[count++];
		}
		// 错误写法
//		while(count<temp.length) {
//			arr[left++] = temp[count++];
//		}
	}

总结：在合并的时候，mid必须取 (left+right)/2 + 1，如果没有+1，会导致count越界，数据举例{0,1}；left=0, right=1, mid如果为0,在第一个while后, i等于1，count等于1，count已经移位置, 判断while (j <= right)时 j等于0；j<=1，temp[count++] = arr[j++]; count会越界，temp[1]=arr[0]; temp[2]=arr[1];这个地方不+1思想就不对，左边取值[left, mid]，右边取值[mid+1, right]，牢记。
while (left <= right) 在最后循环赋值给arr时，实际上是从最里层开始，最里层分解后就2个数，第一次合并也就2个数，写成 while(count<temp.length)，temp数组每次都是arr.length的，所以会导致下标越界。

6.7 基数排序

将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

1、基数排序是对传统桶排序的扩展，速度很快。
2、基数排序是经典的空间换时间的方式，占用内存很大, 当对海量数据排序时，容易造成 OutOfMemoryError 。
3、基数排序是稳定的。[注:假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的]。

	public static void radixSort(int []arr) {
		//计算出数组的最大值
		int max = arr[0];
		for(int i=1; i<arr.length; i++) {
			if(arr[i] > max) {
				max = arr[i];
			}
		}
		System.out.println("最大元素是：" + max);
		//得到最大数是几位数
		int maxSize = (max + "").length();
		//定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
		//说明
		//1. 二维数组包含10个一维数组
		//2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为arr.length
		//3. 名明确，基数排序是使用空间换时间的经典算法
		int[][] bucket = new int[10][arr.length];
		
		//为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
		//可以这里理解
		//比如：bucketElementCounts[0] , 记录的就是  bucket[0] 桶的放入数据个数
		int []indexArr = new int[10];
		
		//最大数有多少位，就要循环多少次
		int temp;
		for(int j=0, n=1; j < maxSize; j++, n*=10) {
			//放进桶里
			for(int i=0;i<arr.length;i++) {
				//得到个位、十位、百位
				temp = arr[i] / n % 10;
				//放入到对应的桶中
				bucket[temp][indexArr[temp]++] = arr[i];
			}
			
			//从桶里取出来
			int count = 0;
			for(int i=0;i<indexArr.length;i++) {
				for(int k=0;k<indexArr[i];k++) {
					arr[count++] = bucket[i][k];
				}
				//下标数组取出来后就置0,下次还要用
				indexArr[i] = 0;
			}
		}
	}

注意每次根据下标数组取出桶中元素放入原数组后，应该将其下标置为0，下次放入桶中的元素，还需要再次记录。

java.lang.OutOfMemoryError这个错误我相信大部分开发人员都有遇到过，产生该错误的原因大都出于以下原因：JVM内存过小、程序不严密，产生了过多的垃圾。
导致OutOfMemoryError异常的常见原因有以下几种：
1、内存中加载的数据量过于庞大，如一次从数据库取出过多数据； 2. 集合类中有对对象的引用，使用完后未清空，使得JVM不能回收； 3. 代码中存在死循环或循环产生过多重复的对象实体； 4. 使用的第三方软件中的BUG； 5. 启动参数内存值设定的过小；

6.8 常用排序算法总结与对比

相关术语解释：

1、稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
2、不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
3、内排序：所有排序操作都在内存中完成；
4、外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
5、时间复杂度： 一个算法执行所耗费的时间。
6、空间复杂度：运行完一个程序所需内存的大小。
7、n: 数据规模
8、k: “桶”的个数
9、In-place: 不占用额外内存
10、Out-place: 占用额外内存

7 线性查找

线性查找，前提是整体必须的有序。

7.1 二分法查找

找到中间下标mid，比较mid的值与查找的值，改变左右区间，使用递归进行查找。

	/**
	 * 
	 * @param arr
	 *            数组
	 * @param left
	 *            左边的索引
	 * @param right
	 *            右边的索引
	 * @param findVal
	 *            要查找的值
	 * @return 如果找到就返回下标，如果没有找到，就返回 -1
	 */
	public static int binarySearch(int[] arr, int left, int right, int findVal) {
		// 当 left > right 时，说明递归整个数组，但是没有找到
		if (left > right) {
			return -1;
		}
		int mid = (left + right) / 2;
		int midVal = arr[mid];

		if (findVal > midVal) { // 向 右递归
			return binarySearch(arr, mid + 1, right, findVal);
		} else if (findVal < midVal) { // 向左递归
			return binarySearch(arr, left, mid - 1, findVal);
		} else {
			return mid;
		}
	}

7.2 插值查找

插值查找是对二分查找的优化，mid的是不再是二分得到，而是通过findValue计算得到。

int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);

但是感觉不严谨，如果数据量大，查找的数也很大，每次计算的mid，和下次调用mid+1再次计算出的mid一样，会造成栈溢出。也不清楚到底mid应该取一个什么范围的值合适，如果有懂的朋友，希望告知。

	//说明：插值查找算法，也要求数组是有序的
	/**
	 * 
	 * @param arr 数组
	 * @param left 左边索引
	 * @param right 右边索引
	 * @param findVal 查找值
	 * @return 如果找到，就返回对应的下标，如果没有找到，返回-1
	 */
	public static int insertValueSearch(int[] arr, int left, int right, int findVal) { 
		//注意：findVal < arr[0]  和  findVal > arr[arr.length - 1] 必须需要
		//否则我们得到的 mid 可能越界
		if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
			return -1;
		}

		// 求出mid, 自适应
		int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
		int midVal = arr[mid];
		if (findVal > midVal) { // 说明应该向右边递归
			return insertValueSearch(arr, mid + 1, right, findVal);
		} else if (findVal < midVal) { // 说明向左递归查找
			return insertValueSearch(arr, left, mid - 1, findVal);
		} else {
			return mid;
		}
	}

7.3 斐波拉契查找

斐波拉契（黄金分割）查找，主要来源于斐波拉契数列，将数组的下标，按照斐波拉契数列来进行分割查找。mid=low+F(k-1)-1，F代表斐波拉契数列。

对F(k-1)-1的理解：
1、由斐波那契数列 F[k]=F[k-1]+F[k-2] 的性质，可以得到 （F[k]-1）=（F[k-1]-1）+（F[k-2]-1）+1 。该式说明：只要顺序表的长度为F[k]-1，则可以将该表分成长度为F[k-1]-1和F[k-2]-1的两段，即如上图所示。从而中间位置为mid=low+F(k-1)-1。
2、类似的，每一子段也可以用相同的方式分割。
3、但顺序表长度n不一定刚好等于F[k]-1，所以需要将原来的顺序表长度n增加至F[k]-1。这里的k值只要能使得F[k]-1恰好大于或等于n即可，由以下代码得到,顺序表长度增加后，新增的位置（从n+1到F[k]-1位置），都赋为n位置的值即可(超出部分直接赋最后一个数的值)。

while(n>fib(k)-1)
    k++;

代码如下：

package cn.qiuhao.datasructure.search;

import java.util.Arrays;

/**
 * 
* @Description: 斐波那契查找
* @author: qiuhao
* @date: 2021年2月1日
*
 */
public class FibonacciSearch {

	public static int maxSize = 20;
	public static void main(String[] args) {
		int [] arr = {1,8, 10, 89, 1000, 1234};
		System.out.println("index=" + fibSearch(arr, 1024));// 0
	}

	//因为后面我们mid=low+F(k-1)-1，需要使用到斐波那契数列，因此我们需要先获取到一个斐波那契数列
	//非递归方法得到一个斐波那契数列
	public static int[] fib() {
		int[] f = new int[maxSize];
		f[0] = 1;
		f[1] = 1;
		for (int i = 2; i < maxSize; i++) {
			f[i] = f[i - 1] + f[i - 2];
		}
		return f;
	}
	
	//编写斐波那契查找算法
	//使用非递归的方式编写算法
	/**
	 * 
	 * @param a  数组
	 * @param key 我们需要查找的关键码(值)
	 * @return 返回对应的下标，如果没有-1
	 */
	public static int fibSearch(int[] a, int key) {
		int low = 0;
		int high = a.length - 1;
		int k = 0; //表示斐波那契分割数值的下标
		int mid = 0; //存放mid值
		int f[] = fib(); //获取到斐波那契数列
		//获取到斐波那契分割数值的下标
		while(high > f[k] - 1) {
			k++;
		}
		//因为 f[k] 值 可能大于 a 的 长度，因此我们需要使用Arrays类，构造一个新的数组，并指向temp[]
		//不足的部分会使用0填充
		int[] temp = Arrays.copyOf(a, f[k]);
		//实际上需求使用a数组最后的数填充 temp
		//举例:
		//temp = {1,8, 10, 89, 1000, 1234, 0, 0}  => {1,8, 10, 89, 1000, 1234, 1234, 1234,}
		for(int i = high + 1; i < temp.length; i++) {
			temp[i] = a[high];
		}
		
		// 使用while来循环处理，找到我们的数 key
		while (low <= high) { // 只要这个条件满足，就可以找
			mid = low + f[k - 1] - 1;
			if(key < temp[mid]) { //我们应该继续向数组的前面查找(左边)
				high = mid - 1;
				//为甚是 k--
				//说明
				//1. 全部元素 = 前面的元素 + 后边元素
				//2. f[k] = f[k-1] + f[k-2]
				//因为 前面有 f[k-1]个元素,所以可以继续拆分 f[k-1] = f[k-2] + f[k-3]
				//即 在 f[k-1] 的前面继续查找 k--
				//即下次循环 mid = f[k-1-1]-1
				k--;
			} else if ( key > temp[mid]) { // 我们应该继续向数组的后面查找(右边)
				low = mid + 1;
				//为什么是k -=2
				//说明
				//1. 全部元素 = 前面的元素 + 后边元素
				//2. f[k] = f[k-1] + f[k-2]
				//3. 因为后面我们有f[k-2] 所以可以继续拆分 f[k-2] = f[k-3] + f[k-4]
				//4. 即在f[k-2] 的前面进行查找 k -=2
				//5. 即下次循环 mid = f[k - 1 - 2] - 1
				k -= 2;
			} else { //找到
				//需要确定，返回的是哪个下标
				if(mid <= high) {
					return mid;
				} else {
					return high;
				}
			}
		}
		return -1;
	}
}

		while(high > f[k] - 1) {
			k++;
		}

最大的下标 要大于 f[k] - 1，实际上是为了保证数组的长度能够满足一个斐波拉契数列，不能让这个长度在数列2个数的中间，这样长度就不满足。
int [] arr = {1,8, 10, 89, 1000, 1234};
斐波拉契数列为：
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]；
如arr数组，最大下标为5，如果 hight > f[k]，则k==4，发f[k]==5，这个下标还不满足最大下标6，不能将数组下标构造成一个斐波拉契数列，所以条件是 while(high > f[k] - 1)；这里求出来的f[k]，如果大于数组的长度，那么数组就自动补齐，补数组的最后一位数，使得数组的长度（下标）能够满足斐波拉契数列。

如果 key < temp[mid]；则mid向左移动一位，k–，将 f[k-1] 分成 f[k-2] + f[k-3] 两段，即只需要将k-1，下次循环时， mid = low + f[k - 1 - 1] - 1;

if(key < temp[mid]) {
	high = mid - 1;
	k--;

如果 key > temp[mid]；则mid向右移动一位，k -= 2;将 f[k-2] 分成 f[k-3] + f[k-4] 两段，即只需要将k-2，下次循环时， mid = low + f[k - 1 - 2] - 1;

if(key > temp[mid]) {
	high = mid + 1;
	k -= 2;

8 哈希表

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

package cn.qiuhao.datasructure.hashtab;

import java.util.Scanner;

/**
 * 
 * @Description: 模拟hash表
 * @author: qiuhao
 * @date: 2021年2月3日
 *
 */
public class HashTabDemo {

	public static void main(String[] args) {

		// 创建哈希表
		HashTab hashTab = new HashTab(7);

		// 写一个简单的菜单
		String key = "";
		Scanner scanner = new Scanner(System.in);
		while (true) {
			System.out.println("add:  添加雇员");
			System.out.println("list: 显示雇员");
			System.out.println("find: 查找雇员");
			System.out.println("exit: 退出系统");

			key = scanner.next();
			switch (key) {
			case "add":
				System.out.println("输入id");
				int id = scanner.nextInt();
				System.out.println("输入名字");
				String name = scanner.next();
				// 创建 雇员
				Emp emp = new Emp(id, name);
				hashTab.add(emp);
				break;
			case "list":
				hashTab.list();
				break;
			case "find":
				System.out.println("请输入要查找的id");
				id = scanner.nextInt();
				hashTab.findEmpById(id);
				break;
			case "exit":
				scanner.close();
				System.exit(0);
			default:
				break;
			}
		}
	}
}

//创建HashTab 管理多条链表
class HashTab {
	private EmpLinkedList[] empLinkedListArray;
	private int size; // 表示有多少条链表

	// 构造器
	public HashTab(int size) {
		this.size = size;
		// 初始化empLinkedListArray
		empLinkedListArray = new EmpLinkedList[size];
		// 这里要分别初始化每个链表
		for (int i = 0; i < size; i++) {
			empLinkedListArray[i] = new EmpLinkedList();
		}
	}

	// 添加雇员
	public void add(Emp emp) {
		// 根据员工的id ,得到该员工应当添加到哪条链表
		int empLinkedListNO = hashFun(emp.id);
		// 将emp 添加到对应的链表中
		empLinkedListArray[empLinkedListNO].add(emp);
	}

	// 遍历所有的链表,遍历hashtab
	public void list() {
		for (int i = 0; i < size; i++) {
			empLinkedListArray[i].list(i);
		}
	}

	// 根据输入的id,查找雇员
	public void findEmpById(int id) {
		// 使用散列函数确定到哪条链表查找
		int empLinkedListNO = hashFun(id);
		Emp emp = empLinkedListArray[empLinkedListNO].findEmpById(id);
		if (emp != null) {// 找到
			System.out.printf("在第%d条链表中找到 雇员 id = %d\n", (empLinkedListNO + 1), id);
		} else {
			System.out.println("在哈希表中，没有找到该雇员~");
		}
	}

	// 编写散列函数, 使用一个简单取模法
	public int hashFun(int id) {
		return id % size;
	}
}

//表示一个雇员
class Emp {
	public int id;
	public String name;
	public Emp next; // next 默认为 null

	public Emp(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
}

//创建EmpLinkedList ,表示链表
class EmpLinkedList {
	// 头指针，执行第一个Emp,因此我们这个链表的head 是直接指向第一个Emp
	private Emp head; // 默认null

	// 添加雇员到链表
	// 说明
	// 1. 假定，当添加雇员时，id 是自增长，即id的分配总是从小到大
	// 因此我们将该雇员直接加入到本链表的最后即可
	public void add(Emp emp) {
		// 如果是添加第一个雇员
		if (head == null) {
			head = emp;
			return;
		}
		// 如果不是第一个雇员，则使用一个辅助的指针，帮助定位到最后
		Emp curEmp = head;
		while (true) {
			if (curEmp.next == null) {// 说明到链表最后
				break;
			}
			curEmp = curEmp.next; // 后移
		}
		// 退出时直接将emp 加入链表
		curEmp.next = emp;
	}

	// 遍历链表的雇员信息
	public void list(int no) {
		if (head == null) { // 说明链表为空
			System.out.println("第 " + (no + 1) + " 链表为空");
			return;
		}
		System.out.print("第 " + (no + 1) + " 链表的信息为");
		Emp curEmp = head; // 辅助指针
		while (true) {
			System.out.printf(" => id=%d name=%s\t", curEmp.id, curEmp.name);
			if (curEmp.next == null) {// 说明curEmp已经是最后结点
				break;
			}
			curEmp = curEmp.next; // 后移，遍历
		}
		System.out.println();
	}

	// 根据id查找雇员
	// 如果查找到，就返回Emp, 如果没有找到，就返回null
	public Emp findEmpById(int id) {
		// 判断链表是否为空
		if (head == null) {
			System.out.println("链表为空");
			return null;
		}
		// 辅助指针
		Emp curEmp = head;
		while (true) {
			if (curEmp.id == id) {// 找到
				break;// 这时curEmp就指向要查找的雇员
			}
			// 退出
			if (curEmp.next == null) {// 说明遍历当前链表没有找到该雇员
				curEmp = null;
				break;
			}
			curEmp = curEmp.next;// 以后
		}

		return curEmp;
	}
}

9 树

为什么需要树这种数据结构？

1、数组存储方式的分析
优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。
缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低
2、链式存储方式的分析
优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)。
缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历)

树存储方式的分析能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。

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

9.1 二叉树

树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
二叉树的子节点分为左节点和右节点。

9.1.1 二叉树遍历

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

	//编写前序遍历的方法
	public void preOrder() {
		System.out.println(this); //先输出父结点
		//递归向左子树前序遍历
		if(this.left != null) {
			this.left.preOrder();
		}
		//递归向右子树前序遍历
		if(this.right != null) {
			this.right.preOrder();
		}
	}
	//中序遍历
	public void infixOrder() {
		//递归向左子树中序遍历
		if(this.left != null) {
			this.left.infixOrder();
		}
		//输出父结点
		System.out.println(this);
		//递归向右子树中序遍历
		if(this.right != null) {
			this.right.infixOrder();
		}
	}
	//后序遍历
	public void postOrder() {
		if(this.left != null) {
			this.left.postOrder();
		}
		if(this.right != null) {
			this.right.postOrder();
		}
		System.out.println(this);
	}

9.1.2 二叉树查找

前序查询、中序查找、后续查找

	//前序遍历查找
	/**
	 * 
	 * @param no 查找no
	 * @return 如果找到就返回该Node ,如果没有找到返回 null
	 */
	public HeroNode preOrderSearch(int no) {
		System.out.println("进入前序遍历");
		//比较当前结点是不是
		if(this.no == no) {
			return this;
		}
		//1.则判断当前结点的左子节点是否为空，如果不为空，则递归前序查找
		//2.如果左递归前序查找，找到结点，则返回
		HeroNode resNode = null;
		if(this.left != null) {
			resNode = this.left.preOrderSearch(no);
		}
		if(resNode != null) {//说明我们左子树找到
			return resNode;
		}
		//1.左递归前序查找，找到结点，则返回，否继续判断，
		//2.当前的结点的右子节点是否为空，如果不空，则继续向右递归前序查找
		if(this.right != null) {
			resNode = this.right.preOrderSearch(no);
		}
		return resNode;
	}
	
	//中序遍历查找
	public HeroNode infixOrderSearch(int no) {
		//判断当前结点的左子节点是否为空，如果不为空，则递归中序查找
		HeroNode resNode = null;
		if(this.left != null) {
			resNode = this.left.infixOrderSearch(no);
		}
		if(resNode != null) {
			return resNode;
		}
		System.out.println("进入中序查找");
		//如果找到，则返回，如果没有找到，就和当前结点比较，如果是则返回当前结点
		if(this.no == no) {
			return this;
		}
		//否则继续进行右递归的中序查找
		if(this.right != null) {
			resNode = this.right.infixOrderSearch(no);
		}
		return resNode;
		
	}
	
	//后序遍历查找
	public HeroNode postOrderSearch(int no) {
		//判断当前结点的左子节点是否为空，如果不为空，则递归后序查找
		HeroNode resNode = null;
		if(this.left != null) {
			resNode = this.left.postOrderSearch(no);
		}
		if(resNode != null) {//说明在左子树找到
			return resNode;
		}
		
		//如果左子树没有找到，则向右子树递归进行后序遍历查找
		if(this.right != null) {
			resNode = this.right.postOrderSearch(no);
		}
		if(resNode != null) {
			return resNode;
		}
		System.out.println("进入后序查找");
		//如果左右子树都没有找到，就比较当前结点是不是
		if(this.no == no) {
			return this;
		}
		return resNode;
	}

在递归查找的时候，如果后面的代码还有递归的操作，那么得判断返回的这个节点，是不是为空，不为空返回，为空则继续执行后面的递归，而不能直接将节点return，直接return就返回了空，而没有继续执行后面的递归

9.1.3 二叉树删除

删除操作，是找到要删除的上一个节点，根据上一个节点来判断，如果找到删除节点，是不能进行超出操作的，因为无法得知上一个节点的信息。

	//递归删除结点
	//1.如果删除的节点是叶子节点，则删除该节点
	//2.如果删除的节点是非叶子节点，则删除该子树
	public void delNode(int no) {
		
		//思路
		/*
		 * 	1. 因为我们的二叉树是单向的，所以我们是判断当前结点的子结点是否需要删除结点，而不能去判断当前这个结点是不是需要删除结点.
			2. 如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null; 并且就返回(结束递归删除)
			3. 如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将this.right= null ;并且就返回(结束递归删除)
			4. 如果第2和第3步没有删除结点，那么我们就需要向左子树进行递归删除
			5.  如果第4步也没有删除结点，则应当向右子树进行递归删除.

		 */
		//2. 如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null; 并且就返回(结束递归删除)
		if(this.left != null && this.left.no == no) {
			this.left = null;
			return;
		}
		//3.如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将this.right= null ;并且就返回(结束递归删除)
		if(this.right != null && this.right.no == no) {
			this.right = null;
			return;
		}
		//4.我们就需要向左子树进行递归删除
		if(this.left != null) {
			this.left.delNode(no);
		}
		//5.则应当向右子树进行递归删除
		if(this.right != null) {
			this.right.delNode(no);
		}
	}

9.2 顺序存储二叉树

从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组。

数组和二叉树可以相互转换，数组也可以用二叉树的前序、中序、后续的遍历方式进行遍历，递归的判断条件，即 2 * n + 1 和 2 * n + 2;

//中序遍历

	public void preOrder(int index) {
		//如果数组为空，或者 arr.length = 0
		if(arr == null || arr.length == 0) {
			System.out.println("数组为空，不能按照二叉树的前序遍历");
		}
		//输出当前这个元素
		System.out.println(arr[index]); 
		//向左递归遍历
		if((index * 2 + 1) < arr.length) {
			preOrder(2 * index + 1 );
		}
		//向右递归遍历
		if((index * 2 + 2) < arr.length) {
			preOrder(2 * index + 2);
		}
	}

9.3 线索化二叉树

利用线索二叉树进行中序遍历时，不必采用堆栈处理，速度较一般二叉树的遍历速度快，且节约存储空间。

n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）

这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种

一个结点的前一个结点，称为前驱结点。
一个结点的后一个结点，称为后继结点。

9.3.1 线索化二叉树

中序线索化二叉树，需要一个辅助节点，指向当前节点的前驱节点；需要定义左右节点的类型，以此来区分是指向是子树还是前驱、后继节点；在线索化左子树的时候，如果遇到节点的左指向为null，那么这个节点就是前驱指针指向的位置，设置类型；在遍历右子树时，需要前驱节点右指针为空的节点，也就是如果没有指向子树，就让这个空的指针指向当前节点；在每次递归后，都要将前驱节点指向当前节点，是为了记录前驱节点的位置。

	public void threadedNodes(HeroNode1 node) {
		//如果node==null, 不能线索化
		if(node == null) {
			return;
		}
		
		//(一)先线索化左子树
		threadedNodes(node.getLeft());
		//(二)线索化当前结点[有难度]
		
		//处理当前结点的前驱结点
		//以8结点来理解
		//8结点的.left = null , 8结点的.leftType = 1
		if(node.getLeft() == null) {
			//让当前结点的左指针指向前驱结点 
			node.setLeft(pre); 
			//修改当前结点的左指针的类型,指向前驱结点
			node.setLeftType(1);
		}
		
		//处理后继结点
		if (pre != null && pre.getRight() == null) {
			//让前驱结点的右指针指向当前结点
			pre.setRight(node);
			//修改前驱结点的右指针类型
			pre.setRightType(1);
		}
		//!!! 每处理一个结点后，让当前结点是下一个结点的前驱结点
		pre = node;
		
		//(三)在线索化右子树
		threadedNodes(node.getRight());
	}

9.3.2 线索化二叉树遍历

二叉树线索化后，就不能再用以前的方式遍历，因为左指针可能指向的子树也可能是前驱节点，会造成无限递归，需要根据前驱、后继节点来遍历。

从根节点开始，用辅助指针，根据类型找到第一个前驱节点，这个节点也就是原来中序遍历的第一个输出节点；然后就继续找后继节点，如果当前结点的右指针指向的是后继结点，就一直输出；如果不是，则让辅助指针往后挪。这种遍历不需要使用递归，直接从根节点往下走开始遍历，遍历更快。

	//遍历线索化二叉树的方法
	public void threadedList() {
		//定义一个变量，存储当前遍历的结点，从root开始
		HeroNode1 node = root;
		while(node != null) {
			//循环的找到leftType == 1的结点，第一个找到就是8结点
			//后面随着遍历而变化,因为当leftType==1时，说明该结点是按照线索化
			//处理后的有效结点
			while(node.getLeftType() == 0) {
				node = node.getLeft();
			}
			
			//打印当前这个结点
			System.out.println(node);
			//如果当前结点的右指针指向的是后继结点,就一直输出
			while(node.getRightType() == 1) {
				//获取到当前结点的后继结点
				node = node.getRight();
				System.out.println(node);
			}
			//替换这个遍历的结点
			node = node.getRight();
		}
	}

9.4 堆排序

1、堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。
2、堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆, 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。
3、每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆

4、大顶堆

5、小顶堆

小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2] // i 对应第几个节点，i从0开始编号。
6、一般升序采用大顶堆，降序采用小顶堆 。

堆排序的基本思想是：
1、将待排序序列构造成一个大顶堆
2、此时，整个序列的最大值就是堆顶的根节点。
3、将其与末尾元素进行交换，此时末尾就为最大值。
4、然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

堆排序是树结构的应用，之前说过二叉树可以以数组的形式进行遍历。首先就是需要构造一个大顶堆，其次就是将最顶端的值与数组元素最后一个值进行交换，这样最大的值就到了数组的最后，依次将n-1个元素再次进行排序。

	public static void heapSort(int arr[]) {
		int temp = 0;
		
		//完成我们最终代码
		//将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
		for(int i = arr.length / 2 -1; i >=0; i--) {
			adjustHeap(arr, i, arr.length);
		}
		
		/*
		 * 2).将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
　　			3).重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
		 */
		for(int j = arr.length-1;j >0; j--) {
			//交换
			temp = arr[j];
			arr[j] = arr[0];
			arr[0] = temp;
			adjustHeap(arr, 0, j); 
		}
		
		//System.out.println("数组=" + Arrays.toString(arr)); 
	}
	
	//将一个数组(二叉树), 调整成一个大顶堆
	/**
	 * 功能： 完成 将 以 i 对应的非叶子结点的树调整成大顶堆
	 * 举例  int arr[] = {4, 6, 8, 5, 9}; => i = 1 => adjustHeap => 得到 {4, 9, 8, 5, 6}
	 * 如果我们再次调用  adjustHeap 传入的是 i = 0 => 得到 {4, 9, 8, 5, 6} => {9,6,8,5, 4}
	 * @param arr 待调整的数组
	 * @param i 表示非叶子结点在数组中索引
	 * @param lenght 表示对多少个元素继续调整， length 是在逐渐的减少
	 */
	public  static void adjustHeap(int arr[], int i, int lenght) {
		
		int temp = arr[i];//先取出当前元素的值，保存在临时变量
		//开始调整
		//说明
		//1. k = i * 2 + 1 k 是 i结点的左子结点
		for(int k = i * 2 + 1; k < lenght; k = k * 2 + 1) {
			if( k + 1 < lenght && arr[k] < arr[k+1]) { //说明左子结点的值小于右子结点的值
				k++; // k 指向右子结点
			}
			if(arr[k] > temp) { //如果子结点大于父结点
				arr[i] = arr[k]; //把较大的值赋给当前结点
				i = k; //!!! i 指向 k,继续循环比较
			} else {
				break;//! 退出循环,进行下一个非叶子节点
			}
		}
		//当for 循环结束后，我们已经将以i 为父结点的树的最大值，放在了 最顶(局部)
		arr[i] = temp;//将temp值放到调整后的位置
	}

因为数组是无序的，不满足堆排序的要求，所以需要先构建一个大顶堆，int i = arr.length / 2 -1，从这个节点开始，也就是最后一个非叶子节点开始构建；这里不是很好理解，因为是从下至上，从右至左进行构建的，所以最后构建出来就满足大顶堆的条件；当遍历到上层节点时，上层节点的左右子节点其实就是来自之前遍历所交换上去的节点，巧妙的是，如果上层节点与子节点进行了交换，那么又会从子节点的位置开始向下去找，来保证大顶堆每个节点的值都大于或等于其左右孩子节点的值。一个for控制的是节点的纵向——节点与左右子节点的比较，一直往下比；一个for控制的是横向，从右到左，从下到上遍历每一个非叶子节点。当构建好了大顶堆，那么最顶端的元素就是最大的数，与数组最后的元素进行交换，这样就将最大的排到后面；然后将最后一个值排除，反复进行比较，最终得到有序的数组。