数据结构相关的内容在这里。
package sort;
import java.util.Arrays;
public class ArraySorter {
/**
* int数组的排序工具 复习五种排序方法： 交换排序 插入排序 选择排序 归并排序 分配排序
* 相应方法都是用来复习面试的,不讨论数据量和数据大小等问题
* 菜鸟收集整理之作
* @author Peter Zhang
*/
//private static int[] arr = { 5, 9, 8, 7, 2, 4, 1, 3, 0, 6 };//待测数组
private static int[] arr = {1234,5425,38,35,46,13,89,356,123,78963,51,62};
public static void main(String[] args) {
System.out.println("待测数组");
print(arr);
//Arrays.sort(arr);
bubbleSort(arr);
//bubbleSort2(arr);
// quickSort(arr);
// insertSort(arr);
// shellSort(arr);
// shellSort2(arr);
// selectSort(arr);
// heapSort(arr);
// mergeSort(arr);
//radixSort(arr);
//radixSort2(arr);
print(arr);
}
// 显示打印的方法
private static void print(int[] arr) {
for (int i : arr) {
System.out.print(i + " ");
}
System.out.println();
}
// 交换元素的方法
private static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
// 交换排序
/**
* 冒泡排序 数组中相邻左右两个元素相互比较,大的向后
*
* @param arr
*/
public static void bubbleSort2(int[] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length - 1; j++) {
if (arr[i] > arr[j]) {
swap(arr, i, j);
}
}
}
}
public static void bubbleSort(int[] arr){
for(int i=0;ii;j--){
if(arr[j] i) {
while (j > i && arr[j] > key) {// 右边递减寻找比关键字小的元素
j--;
}
if (j > i) {// 找到比关键字小的元素 下标为j
arr[i++] = arr[j]; // 和左边的元素交换 左边元素递增
}
while (j > i && arr[i] < key) {// 左边递增寻找比关键字大的元素
i++;
}
if (j > i) {// 找到比关键字大的元素 下标为i
arr[j--] = arr[i]; // 再右边递减寻找比关键字小的元素
}
}
arr[i] = key;
quick(arr, begin, j - 1);// 递归key左边
quick(arr, j + 1, end);// 递归key右边
}
}
// 外部方法
public static void quickSort(int[] arr) {
quick(arr, 0, arr.length - 1);
}
// 插入排序
/**
* 直接插入排序 左右分成两个部分,右边第一个元素和左边所有元素比较,小就交换,大就不变
*
* @param arr
*/
public static void insertSort(int[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = 0; j < i; j++) {
if (arr[j] > arr[i]) {
swap(arr, i, j);
}
}
}
}
/**
* 希尔排序 先设定一个增量(间隔),再根据增量分组,每个分组排序；再分组,再排序
*
* @param arr
*/
public static void shellSort(int[] arr) {
int len = arr.length;
for (int increment = len / 2; increment > 0; increment /= 2) {// 分组
for (int i = increment; i < len; i++) {
if (arr[i] < arr[i - increment]) {// 增量间隔的两个数,大的放后,小的放前
for (int j = 0; j < i; j += increment) {
if (arr[j] > arr[i]) {
swap(arr, i, j);
}
}
}
}
}
}
public static void shellSort2(int[] arr) {
int len = arr.length;
int j;
for (int increment = len / 2; increment > 0; increment /= 2) {
for (int i = increment; i < len; i++) {
int temp = arr[i];
for (j = i - increment; j >= 0 && arr[j] > temp; j -= increment) {
arr[j + increment] = arr[j];
}
arr[j + increment] = temp;
}
}
}
// 选择排序
/**
* 直接选择排序 每次选择一个最小的
*
* @param arr
*/
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[min] > arr[j]) {
min = j;
}
}
if (min != i) {
swap(arr, i, min);
}
}
}
/**
* 堆排序 大顶堆排序 k0 k1 k2 k3 ……kn 利用大顶堆父节点比子节点大的原理,
* 先构造一个大顶堆,调整它保证根节点的元素是最大的
* 交换根节点和最后一个元素,移除最后一个元素,调整length-1个元素的堆,保持结构；
* 再交换此时的根节点和此时的最后一个元素,再移除此时的最后一个元素,调整剩下的堆；
* 以此类推,直到就剩根节点
*
* @param arr
*/
public static void heapSort(int[] arr) {
// 创建大顶堆堆 从最后一个父节点开始向根递减
int n = arr.length - 1; // 最后一个元素的index
for (int i = (n - 1) / 2; i > 0; i--) {
heapify(arr, i, n);// 从最后一个根节点开始调整堆
}
for (int i = n; i > 0; i--) {
swap(arr, i, 0);// 交换根和最后一个元素,n-1
heapify(arr, (i - 1 - 1) / 2, i - 1);// 从最后一个根节点开始调整
}
}
/**
* 调整堆 顶为0 左子节点为2i+1 从最后一个根节点开始调整堆的结构
*
* @param arr
* @param index 最后一个父节点
* @param n 最后一个元素的下标
*/
private static void heapify(int[] arr, int index, int n) {// n lastIndex
if (n == 0) {// 根节点 不调整
return;
}
for (int i = index; i >= 0; i--) {
int left = 2 * i + 1;// 左子节点
if (left < n) {// 有右子节点
if (arr[left] < arr[left + 1]) {
left++; // 方便在有右子节点的时候用left下标表示
}
}
if (arr[left] > arr[i]) {// 子节点比父节点大,交换
swap(arr, i, left);
}
}
}
// 归并排序
/**
* 归并排序 把待排序序列分为若干个子序列,每个子序列是有序的,
* 再把有序子序列合并为整体有序序列
*
* @param arr
*/
public static void mergeSort(int[] arr) {
merge(arr, 0, arr.length - 1);
}
// 分治法 自顶向下 递归分割数组并归并
private static void merge(int[] arr, int begin, int end) {
if (begin < end) {
int middle = (begin + end) / 2;
merge(arr, begin, middle);// 分割左边部分
merge(arr, middle + 1, end);// 分割右边部分
doMerge(arr, begin, middle, end);// 归并成一个有序的区间
}
}
// 归并
private static void doMerge(int[] arr, int begin, int middle, int end) {
int[] tmp = new int[arr.length];// 临时数组
int temp = begin;// 临时数组下标
int copy = begin;// 数组复制下标
int right = middle + 1;
while (begin <= middle && right <= end) {// 两部分从左边开始互相比较
if (arr[begin] <= arr[right]) {// 小的元素放入临时数组
tmp[temp++] = arr[begin++];
} else {
tmp[temp++] = arr[right++];
}
}
// 剩下的元素接着复制到临时数组中
while (begin <= middle) {
tmp[temp++] = arr[begin++];
}
while (right <= end) {
tmp[temp++] = arr[right++];
}
// 复制数组
while (copy <= end) {
arr[copy] = tmp[copy++];
}
}
// 分配排序
// 基数排序
/**
* int[] 单关键字十进制 基数就是10 循环装箱的次数就是数组中最大数的位数
* 用一个容量为 10*待测数组长度 的二维数组存放数据 new int[radix][arr.length]
* 即 10行 arr.length列的规则矩阵,每一行分别是序号为0-9的箱子
* 第一次循环装入个位数字与箱子序号数字对应的元素
* 再从0号箱子开始到9号箱子结束把依次所有元素装进数组中
* 第二次为十位
* 再从0号箱子开始到9号箱子结束把依次所有元素装进数组中
* 以此类推直到数组中最大数的最高位
* @param arr
*/
public static void radixSort(int[] arr) {
int len = arr.length;
int radix = 10;
int d = getMax(arr);// 最大数的位数
int[][] temp = new int[radix][len];//序号为0-9的箱子
int[] count = new int[radix];//箱子中元素的计数器
for (int m=0,n=1;m= 0; j--) {
int tempKey = (temp[j] / divide) % radix;
count[tempKey]--;
array[count[tempKey]] = temp[j];
}
divide = divide * radix;
}
}
private static int getMax(int[] arr) {
int max = 0;
for (int i : arr) {
if (i > max) {
max = i;
}
}
return (max+"").length();
}
}