1.冒泡排序
时间复杂度:O(n^2)
冒泡排序的基本思想是:每次比较两个相邻的元素,如果它们的顺序错误就把它们交换过来,每次排序将一个元素归位。
- 代码如下:实现从小到大的排序
package com.timo.sort;
/**
* @className TestDemo1
* @description 冒泡排序的实现及测试
* @author Timo
*
*/
public class TestDemo1 {
public static void main(String[] args) {
int[] x = {5, 8, 2, 4, 9, 0, 3, 6, 1, 7};
System.out.println("冒泡排序的结果:");
print(bubbleSort(x));
}
/**
* 负责数组输出的方法,用加强型for循环
* @param array 要输出的数组
*/
public static void print(int[] array) {
for (int i : array) {
System.out.print(i + ",");
}
}
/**
* 1.冒泡排序
* @param array 要排序的数组
* @return array 排序后返回的结果
*/
public static int[] bubbleSort(int[] array) {
// 定义中间变量
int temp = 0;
// 控制排序次数
for (int i = 0; i < array.length; i++) {
// 控制每次排序的交换次数,数组长度减一保证数组不会出现越界
for (int j = 0; j < array.length - i - 1; j++) {
// 相邻的数据进行比较,将大的数据往后移
if (array[j] > array[j + 1]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
return array;
}
}
2.简单的桶排序
时间复杂度:O(n)
桶排序的基本思想是:首先找到数组中的最大值,然后新建一个数组,这个数组的长度为最大值+1,新建这个数组的下标就是原始数组的数据,那个下标对应的数据出现,对应的下标储存的值加一(从0开始)。0代表这个下标没有对应的数据,下标对应的数据出现几次,对应下标储存的值就几。
- 代码如下:实现从小到大排序
package com.timo.sort;
/**
* @className TestDemo1
* @description 桶排序的实现及测试
* @author Timo
*/
public class TestDemo1 {
public static void main(String[] args) {
int[] x = {5, 8, 2, 4, 9, 0, 3, 6, 1, 7};
int[] bucket = bucketSort(x, maxValue(x));
System.out.println("桶排序的结果:");
// 输出排序完的数组
for (int i = 0; i < bucket.length; i++) {
for (int j = 0; j < bucket[i]; j++) {
System.out.print(i + ",");
}
}
}
/**
* 2.桶排序的方法
* @param array 要进行排序的数组
* @param maxNum 待排序数组的最大值
* @return bucket 记录每个数据出现次数的数组
*/
public static int[] bucketSort(int[] array, int maxNum) {
// 创建桶数组
int[] bucket = new int[maxNum + 1];
for (int i = 0; i < bucket.length; i++) {
for (int j = 0; j < array.length; j++) {
// 记录每个值出出现的次数,保存在桶数组中
if (i == array[j]) {
bucket[i]++;
}
}
}
return bucket;
}
/**
* 求数组的最大值
* @param array 要求最大值的数组
* @return temp 最大值
*/
public static int maxValue(int[] array) {
// 定义保存最大值的变量,并赋值
int maxNum = array[0];
for (int i = 1; i < array.length; i++) {
// 进行数据比较,将大的值赋给maxNum
if (maxNum < array[i]) {
maxNum = array[i];
}
}
return maxNum;
}
}
3.快速排序
时间复杂度:O(NlogN)
快速排序的基本思想:每次排序的时候设置一个基准值,将小于基准值的数全部放到基准值的左边,将大于基准值的数全部放到基准值的右边,每次将基准值归位。然后以基准值为中心分而制之,进行递归。即每一轮处理其实就是将这一轮的基准值归位。
- 方法一:快速排序的代码实现
package com.timo.sort;
/**
* @className TestDemo1
* @description 快速排序的测试及实现1
* @author Timo
*/
public class TestDemo1 {
public static void main(String[] args) {
int[] x = {5, 8, 2, 4, 9, 0, 3, 6, 1, 7};
quickSort(x, 0, x.length - 1);
System.out.println("快速排序的结果:");
print(x);
}
/**
* 负责数组输出的方法,用加强型for循环
* @param array 要输出的数组
*/
public static void print(int[] array) {
for (int i : array) {
System.out.print(i + ",");
}
}
/**
* 3.快速排序
* @param array 要进行排序的数组
* @param left left = 0;
* @param right right = array.length - 1;
*/
public static void quickSort(int array[], int left, int right) {
// 排序的出口
if (left > right || array.length <= 0) {
return;
}
// 定义i,j,和基准值key
int i = left;
int j = right;
int key = array[left];
while (i != j) {
// j向前走,找到第一个碰到的小于基准值的数
while (array[j] >= key && i < j) {
j--;
}
// i向后走,找到第一个碰到的大于基准值的数
while (array[i] <= key && i < j) {
i++;
}
// 将找到的两个数交换位置
if (i < j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
// 将基准值归位
array[left] = array[i];
array[i] = key;
// 继续排序基准值左边的元素
quickSort(array, left, i - 1);
// 继续排序基准值右边的元素
quickSort(array, i + 1, right);
}
}
- 方法二:快速排序的代码实现
package com.timo.sort;
/**
* @className TestDemo1
* @description 快速排序的测试及实现2
* @author Timo
*/
public class TestDemo1 {
public static void main(String[] args) {
int[] x = {5, 8, 2, 4, 9, 0, 3, 6, 1, 7};
quickSort(x, 0, x.length - 1);
System.out.println("快速排序的结果:");
print(x);
}
/**
* 负责数组输出的方法,用加强型for循环
* @param array 要输出的数组
*/
public static void print(int[] array) {
for (int i : array) {
System.out.print(i + ",");
}
}
/**
* 3.快速排序
* @param array 要进行排序的数组
* @param left left = 0;
* @param right right = array.length - 1;
*/
public static void quickSort(int array[], int left, int right) {
if (left > right || array.length<=0) { // i大于或等于j,直接返回
return;
}
int i = left; // i,左下标
int j = right; // j,右下标
int key = array[left]; // 基准元素,默认取数组的第一个元素
// 让数组中的全部元素都比较,每次轮将基准值归位
while (true) {
// j往前走
while (j > i) {
if (array[j] < key) { // 找到第一个小于key的值A[j],A[i]与A[j]交换
int temp = array[j];
array[j] = array[i];
array[i] = temp;
break;
} else {
j--;
}
}
// i往后走
while (j > i) {
if (array[i] > key) { // 找到第一个大于key的A[i],A[i]与A[j]交换
int temp = array[j];
array[j] = array[i];
array[i] = temp;
break;
} else {
i++;
}
}
// 终结最外层while循环,表示一趟排序结束(全部元素都进行了比较)
if (i == j) {
break;
}
}
// 继续排序基准元素的左边元素
quickSort(array, left, i - 1);
// 继续排序基准元素的右边元素
quickSort(array, i + 1, right);
}
}