常用算法

public static int binSearch(int arr[], int tar) {//二分
	int low = 0;
	int high = arr.length - 1;
	while (low <= high) {
		int mid = (high - low) / 2 + low;
		if (tar < arr[mid]) {
			high = mid - 1;
		} else if (tar > arr[mid]) {
			low = mid + 1;
		} else {
			return mid;
		}
	}
	return -1;
}

public static int binSearch(int arr[], int tar, int low, int high) {//二分递归
	if (low >= high) {
		return -1;
	}
	int mid = (high - low) / 2 + low;
	if (arr[mid] == tar) {
		return mid;
	} else if (tar > arr[mid]) {
		return binSearch(arr, mid + 1, high, tar);
	} else if (tar < arr[mid]) {
		return binSearch(arr, low, mid - 1, tar);
	}
	return -1;
}

public static void quickSort(int[] arr, int low, int high) {//快排
	if (high - low < 1) {//如果指针在同一位置(只有一个数据时)，退出
		return;
	}
	boolean flag = true;//标记，从高指针开始，还是低指针（默认高指针）
	int start = low;
	int end = high;
	//默认中间值为低指针的第一个值
	int midValue = arr[low];
	while (true) {
		if (flag) {//高指针移动
			if (arr[high] > midValue) {//如果列表右方的数据大于中间值，则向左移动
				high--;
				//如果小于，则覆盖最开始的低指针值，并且移动低指针，标志位改成从低指针开始移动
			} else if (arr[high] < midValue) {
				arr[low] = arr[high];
				low++;
				flag = false;
			}
		} else {
			if (arr[low] < midValue) {//如果低指针数据小于中间值，则低指针向右移动
				low++;
			} else if (arr[low] > midValue) {
				//如果低指针的值大于中间值，则覆盖高指针停留时的数据，并向左移动高指针。切换为高指针移动
				arr[high] = arr[low];
				high--;
				flag = true;
			}
		}
		if (low == high) {//当两个指针的位置相同时，则找到了中间值的位置，并退出循环
			arr[low] = midValue;
			break;
		}
	}
	//然后出现有，中间值左边的小于中间值。右边的大于中间值。
	//然后在对左右两边的列表在进行快速排序
	quickSort(arr, start, low - 1);
	quickSort(arr, low + 1, end);
}

public static void preOrderTraverse(Node node) {//树的前中后遍历
	if (node == null)
		return;
	System.out.print(node.data + " ");
	preOrderTraverse(node.leftChild);
	preOrderTraverse(node.rightChild);
}

public static void preorder(Node node) {//树的前中后遍历-栈
	if (node == null)
		return;
	Stack<Node> stack = new Stack<>();
	Node cur = root;
	while (cur != null || !stack.isEmpty()) {
		while (cur != null) {
			System.out.print(cur.val);//前序
			stack.push(cur);//进栈
			cur = cur.lchild;//遍历左子树
		}
		cur = stack.pop();
		System.out.println(cur.val);//中序
		cur = cur.rchild;
	}
}

public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {//树的层序遍历
	ArrayList<Integer> result = new ArrayList<Integer>();
	if (root == null) return result;
	Queue<TreeNode> queue = new LinkedList<TreeNode>();
	queue.offer(root);
	while (!queue.isEmpty()) {
		TreeNode temp = queue.poll();
		result.add(temp.val);
		if (temp.left != null) queue.offer(temp.left);
		if (temp.right != null) queue.offer(temp.right);
	}
	return result;
}