下面逐个给你：冒泡、选择、插入、希尔、快排、归并、堆排、二分查找、双指针、滑动窗口、DFS、BFS、动态规划 全套可运行代码。

1. 冒泡排序
   public class SortDemo {
   // 冒泡排序
   public static void bubbleSort(int[] arr) {
   if (arr == null || arr.length <= 1) return;
   int n = arr.length;
   for (int i = 0; i < n - 1; i++) {
   for (int j = 0; j < n - 1 - i; j++) {
   if (arr[j] > arr[j + 1]) {
   // 交换
   int temp = arr[j];
   arr[j] = arr[j + 1];
   arr[j + 1] = temp;
   }
   }
   }
   }

   public static void main(String[] args) {
   int[] arr = {3, 1, 4, 2, 5};
   bubbleSort(arr);
   for (int num : arr) {
   System.out.print(num + " ");
   }
   }
   }

2. 选择排序
   // 选择排序
   public static void selectSort(int[] arr) {
   if (arr == null || arr.length <= 1) return;
   int n = arr.length;
   for (int i = 0; i < n - 1; i++) {
   int minIndex = i;
   for (int j = i + 1; j < n; j++) {
   if (arr[j] < arr[minIndex]) {
   minIndex = j;
   }
   }
   // 交换
   int temp = arr[i];
   arr[i] = arr[minIndex];
   arr[minIndex] = temp;
   }
   }

3. 插入排序
   // 插入排序
   public static void insertSort(int[] arr) {
   if (arr == null || arr.length <= 1) return;
   for (int i = 1; i < arr.length; i++) {
   int temp = arr[i];
   int j = i - 1;
   while (j >= 0 && arr[j] > temp) {
   arr[j + 1] = arr[j];
   j–;
   }
   arr[j + 1] = temp;
   }
   }

4. 希尔排序
   // 希尔排序
   public static void shellSort(int[] arr) {
   int n = arr.length;
   // 增量
   for (int gap = n / 2; gap > 0; gap /= 2) {
   for (int i = gap; i < n; i++) {
   int temp = arr[i];
   int j;
   for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) {
   arr[j] = arr[j - gap];
   }
   arr[j] = temp;
   }
   }
   }

5. 快速排序（面试必考）
   // 快速排序
   public static void quickSort(int[] arr, int left, int right) {
   if (left >= right) return;
   int pivot = arr[left];
   int l = left, r = right;

   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;
   quickSort(arr, left, l - 1);
   quickSort(arr, l + 1, right);
   }

// 调用：quickSort(arr, 0, arr.length - 1);
6. 归并排序
// 归并排序
public static void mergeSort(int[] arr, int left, int right) {
if (left >= right) return;
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}

// 合并两个有序区间
private static void merge(int[] arr, int left, int mid, int right) {
int[] temp = new int[right - left + 1];
int i = left, j = mid + 1, k = 0;
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
while (i <= mid) temp[k++] = arr[i++];
while (j <= right) temp[k++] = arr[j++];
// 拷贝回原数组
for (int p = 0; p < temp.length; p++) {
arr[left + p] = temp[p];
}
}
7. 堆排序
// 堆排序
public static void heapSort(int[] arr) {
int n = arr.length;
// 构建大顶堆
for (int i = n / 2 - 1; i >= 0; i–) {
adjustHeap(arr, i, n);
}
// 逐个交换堆顶和末尾
for (int i = n - 1; i > 0; i–) {
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
adjustHeap(arr, 0, i);
}
}

private static void adjustHeap(int[] arr, int i, int len) {
int temp = arr[i];
for (int k = 2 * i + 1; k < len; k = 2 * k + 1) {
if (k + 1 < len && arr[k] < arr[k + 1]) {
k++;
}
if (arr[k] > temp) {
arr[i] = arr[k];
i = k;
} else {
break;
}
}
arr[i] = temp;
}
8. 二分查找（有序数组）
// 二分查找 迭代版
public static int binarySearch(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] == target) {
return mid;
} else if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1; // 没找到
}
9. 双指针示例（两数之和）
// 有序数组两数之和
public static int[] twoSum(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left < right) {
int sum = arr[left] + arr[right];
if (sum == target) {
return new int[]{left, right};
} else if (sum < target) {
left++;
} else {
right–;
}
}
return new int[]{-1, -1};
}
10. 二叉树 DFS 前序遍历
class TreeNode {
int val;
TreeNode left, right;
TreeNode(int x) { val = x; }
}

// DFS 前序：根 左 右
public static void dfsPre(TreeNode root) {
if (root == null) return;
System.out.print(root.val + " ");
dfsPre(root.left);
dfsPre(root.right);
}
11. 二叉树 BFS 层序遍历
import java.util.LinkedList;
import java.util.Queue;

public static void bfs(TreeNode root) {
if (root == null) return;
Queue queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode node = queue.poll();
System.out.print(node.val + " ");
if (node.left != null) queue.offer(node.left);
if (node.right != null) queue.offer(node.right);
}
}
12. 动态规划：爬楼梯
// 爬楼梯：每次1或2阶，求多少种走法
public static int climbStairs(int n) {
if (n <= 2) return n;
int[] dp = new int[n + 1];
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i <= n; i++) {
dp[i] = dp[i - 1] + dp[i - 2];
}
return dp[n];
}