经典算法

一、手写二分查找

public class BinarySearch {

	public static void main(String[] args) {
		int[] arr = {1,3,5,7,9,11};
		int key = 4;
		
		//递归实现
		int position = recursionBinarySearch(arr,key,0,arr.length - 1);
		//循环实现
		//int position = commonBinarySearch(arr, key);
 
        if(position == -1){
			System.out.println("查找的是"+key+",序列中没有该数！");
		}else{
			System.out.println("查找的是"+key+",找到位置为："+position);
		}
	}

	//递归实现
	private static int recursionBinarySearch(int[] arr, int key, int left, int right) {
		if(key<arr[left]||key>arr[right]||left>right)
			return -1;
		int middle=left+(right-left)/2;
		if(arr[middle]<key) {
			recursionBinarySearch(arr,key,middle+1,right);
		}else if(arr[middle]>key) {
			recursionBinarySearch(arr,key,left,middle-1);
		}else {
			return middle;
		}
		return -1;
	}

	//循环实现
	private static int commonBinarySearch(int[] arr, int key) {
		int left=0;
		int right=arr.length-1;
		int middle=0;
		
		if(key<arr[left]||key>arr[right]||left>right)
			return -1;
		while(left<=right) {
			middle=left+(right-left)/2;
			if(key<arr[middle]) {
				right=middle-1;
			}else if(key>arr[middle]) {
				left=middle+1;
			}else {
				return middle;
			}
		}
		return -1;	
	}
}

二、手写快速排序
时间复杂度:　O(nlogn)
快速排序原理:

1. 定义一个基准元素base(这里定义的是最左面的元素定位基准元素)
2. 定义两个变量i和j
3. j先从右向左遍历,找到第一个比base小的数就停止
4. i再从左向右便利找到第一个比base大的数停止
5. 交换i和j指向的元素
6. 直到i和j指向同一个元素,将这个元素与基准元素交换
7. 递归求解即可

public class QuickSort {

	public static void main(String[] args) {
		int[] arr = { 3, 4, 1, 2, 6, 9, 8, 5, 7 };
		quickSort(arr, 0, arr.length - 1);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}

	public static void quickSort(int[] arr, int low, int high) {
		int i, j, base;
		if (low > high) {
			return;
		}
		i = low;
		j = high;
		// base就是基准位
		base = arr[low];

		while (i < j) {
			// 先看右边，依次往左递减
			while (base <= arr[j] && i < j) {
				j--;
			}
			// 再看左边，依次往右递增
			while (base >= arr[i] && i < j) {
				i++;
			}
			// 如果满足条件则交换
			if (i < j) {
				int temp=arr[i];
				arr[i]=arr[j];
				arr[j]=temp;
			}
		}

		// 最后将基准为与i和j相等位置的数字交换
		arr[low] = arr[i];
		arr[i] = base;

		// 递归调用左半数组
		quickSort(arr, low, j - 1);
		// 递归调用右半数组
		quickSort(arr, j + 1, high);
	}
}

三、手写堆排

public class HeapSort {

	public static void main(String[] args) {
		int[] arr = { 2, 6, 1, 4, 9, 3, 7, 5, 8 };
		heapSort(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "  ");
		}
	}

	public static void heapSort(int[] array) {
		if (array.length == 0)
			return;

		// 建堆，从最后一个非叶子节点开始，而最后一个非叶子节点的下标为array.length/2-1
		int length = array.length;
		for (int i = length / 2 - 1; i >= 0; i--)
			heapify(array, length, i);

		for (int i = length - 1; i >= 0; i--) {
			int temp = array[0];
			array[0] = array[i];
			array[i] = temp;
			heapify(array, i, 0);
		}
	}

	static void heapify(int[] array, int length, int i) {
		int left = 2 * i + 1, right = 2 * i + 2;
		int largest = i;

		if (left < length && array[left] > array[largest]) {
			largest = left;
		}
		if (right < length && array[right] > array[largest]) {
			largest = right;
		}

		if (largest != i) {
			int temp = array[i];
			array[i] = array[largest];
			array[largest] = temp;
			heapify(array, length, largest);
		}
	}
}

四、手写冒泡

public class BubbleSort {

	public static void main(String[] args) {
		int[] arr = { 2, 6, 1, 4, 9, 3, 7, 5, 8 };
		bubbleSort(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "  ");
		}
	}

	private static void bubbleSort(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			boolean flag = false;
			for (int j = arr.length - 1; j > i; j--) {
				if (arr[j - 1] > arr[j]) {
					int temp = arr[j - 1];
					arr[j - 1] = arr[j];
					arr[j] = temp;
					flag = true;
				}
			}
			if (flag == false)
				break;
		}
	}
}

五、手写BFS

//使用Queue实现BFS
public void BFSWithQueue(TreeNode root) {
    Queue<TreeNode> queue = new LinkedList<>();
    if (root != null)
        queue.add(root);
    while (!queue.isEmpty()) {
        TreeNode treeNode = queue.poll();
        if (treeNode.left != null)
            queue.add(treeNode.left);
        if (treeNode.right != null)
            queue.add(treeNode.right);
    }
}

六、手写DFS

//DFS递归实现
public void DFSWithRecursion(TreeNode root) {
    if (root == null)
        return;
    if (root.left != null)
        DFSWithRecursion(root.left);
    if (root.right != null)
        DFSWithRecursion(root.right);
}

//DFS的迭代实现版本（Stack）
public void DFSWithStack(TreeNode root) {
     if (root != null)
         return;
     Stack<TreeNode> stack = new Stack<>();
     stack.push(root);
 
     while (!stack.isEmpty()) {
         TreeNode treeNode = stack.pop();
         if (treeNode.right != null)
             stack.push(treeNode.right);
         if (treeNode.left != null)
             stack.push(treeNode.left);
     }
}