排序算法(Java语言)
以下排序都是从小到大
1、如何不使用其它变量交换两个整数的值
//如何不使用第三个变量,交换两个数字
public static void swap(int a,int b){
System.out.println("a = "+a+" ,b = "+b);
//1、方法一
a = a+b;
b = a - b;
a = a -b;
//2、方法二
/*
a = a^b;
b = a^b;
a = a^b;
*/
System.out.println("a = "+a+" ,b = "+b);
}
2、冒泡排序
2.1、算法
例如:从小到大排序
//冒泡排序
//每次相邻的元素进行比较,然后交换,每次把最大的元素放到最后。
public class SortDemo1 {
public static void main(String[] args) {
int[] array = {4,2,6,7,3,9};
System.out.println(Arrays.toString(array));
int len = array.length;
boolean sorted;
for(int i=0;i<len-1;i++){
sorted = true;
for(int j=0;j<len-1-i;j++){
if(array[j]>array[j+1]){
int t = array[j];
array[j] = array[j+1];
array[j+1] = t;
sorted = false;
}
}
if(sorted){
break;
}
}
System.out.println(Arrays.toString(array));
}
}
2.2、算法分析
冒泡排序是稳定的,平均时间复杂度为O(n2),最坏时间复杂度为O(n2),最好时间复杂度为O(n)
1、什么时候最快
当输入的数据已经是正序时
2、什么时候最慢
当输入的数据是反序时
3、选择排序
3.1、算法
从长度为n的数组中,选出最小的放在下标为0的位置,然后再从剩下的数中选出第二小的数放在下标为1的位置。依次类推。
//选择排序
public class SortDemo2 {
public static void main(String[] args) {
int[] array = {4,2,6,7,3,9};
System.out.println(Arrays.toString(array));
int len = array.length;
// 总共要经过 N-1 轮比较
for(int i=0;i<len-1;i++){
int min = i;
// 每轮需要比较的次数 len-i
for(int j=i+1;j<len;j++){
if(array[min]>array[j]){
// 记录目前能找到的最小值元素的下标
min = j;
}
}
// 将找到的最小值和i位置所在的值进行交换
if (i != min) {
int tmp = array[i];
array[i] = array[min];
array[min] = tmp;
}
}
System.out.println(Arrays.toString(array));
}
}
3.2、算法分析
选择排序是不稳定的,平均、最好、最坏时间复杂度都为O(n2)
4、插入排序
4.1、算法
插入排序是一种最简单直观的排序算法,它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
插入排序和冒泡排序一样,也有一种优化算法,叫做拆半插入。
将第一待排序序列第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。)
//插入排序
public class SortDemo3 {
public static void main(String[] args) {
int[] arr = {4,2,6,7,3,9};
System.out.println(Arrays.toString(arr));
// 从下标为1的元素开始选择合适的位置插入,因为下标为0的只有一个元素,默认是有序的
for (int i = 1; i < arr.length; i++) {
// 记录要插入的数据
int tmp = arr[i];
// 从已经排序的序列最右边的开始比较,找到比其小的数
int j = i;
while (j > 0 && tmp < arr[j - 1]) {
arr[j] = arr[j - 1];
j--;
}
// 存在比其小的数,插入
if (j != i) {
arr[j] = tmp;
}
}
System.out.println(Arrays.toString(arr));
}
}
4.2、算法分析
插入排序是稳定的,平均时间复杂度为O(n2),最坏时间复杂度为O(n2),最好时间复杂度O(n)
5、希尔排序
5.1、算法
//希尔排序
public class SortDemo4 {
public static void main(String[] args) {
int[] arr = {4,2,6,7,3,9};
int length = arr.length;
System.out.println(Arrays.toString(arr));
int temp;
for (int step = length / 2; step >= 1; step /= 2) {
for (int i = step; i < length; i++) {
temp = arr[i];
int j = i - step;
while (j >= 0 && arr[j] > temp) {
arr[j + step] = arr[j];
j -= step;
}
arr[j + step] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
}
5.2、算法分析
希尔排序是不稳定的,平均时间复杂度为O(n1.3),最坏时间复杂度为O(n2),最好时间复杂度O(n)
6、归并排序
6.1、算法
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。
把长度为n的输入序列分成两个长度为n/2的子序列;
对这两个子序列分别采用归并排序;
将两个排序好的子序列合并成一个最终的排序序列。
public int[] sort(int[] sourceArray) throws Exception {
// 对 arr 进行拷贝,不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
if (arr.length < 2) {
return arr;
}
int middle = (int) Math.floor(arr.length / 2);
int[] left = Arrays.copyOfRange(arr, 0, middle);
int[] right = Arrays.copyOfRange(arr, middle, arr.length);
return merge(sort(left), sort(right));
}
protected int[] merge(int[] left, int[] right) {
int[] result = new int[left.length + right.length];
int i = 0;
while (left.length > 0 && right.length > 0) {
if (left[0] <= right[0]) {
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
} else {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
}
while (left.length > 0) {
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
}
while (right.length > 0) {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
return result;
}
6.2算法分析
归并排序是不稳定的,最好、最坏、平均时间复杂度都为O(nlog2n)。空间复杂度为O(n)
7、快速排序
7.1、算法
-
从数列中挑出一个元素,称为 “基准”(pivot);
-
重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。 在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;
-
递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序;
public int[] sort(int[] sourceArray) {
// 对 arr 进行拷贝,不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
return quickSort(arr, 0, arr.length - 1);
}
private int[] quickSort(int[] arr, int left, int right) {
if (left < right) {
int partitionIndex = partition(arr, left, right);
quickSort(arr, left, partitionIndex - 1);
quickSort(arr, partitionIndex + 1, right);
}
return arr;
}
private int partition(int[] arr, int left, int right) {
// 设定基准值(pivot)
int pivot = left;
int index = pivot + 1;
for (int i = index; i <= right; i++) {
if (arr[i] < arr[pivot]) {
swap(arr, i, index);
index++;
}
}
swap(arr, pivot, index - 1);
return index - 1;
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
7.2算法分析
快速排序是不稳定的,最好和平均时间复杂度为O(nlog2),最坏时间复杂度为O(n2)。 空间复杂度为O(nlog2)。
8、堆排序
8.1、算法
-
创建一个堆 H[0……n-1];
-
把堆首(最大值)和堆尾互换;
-
把堆的尺寸缩小 1,并调用 shift_down(0),目的是把新的数组顶端数据调整到相应位置;
-
重复步骤 2,直到堆的尺寸为 1。
public int[] sort(int[] sourceArray) {
// 对 arr 进行拷贝,不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int len = arr.length;
buildMaxHeap(arr, len);
for (int i = len - 1; i > 0; i--) {
swap(arr, 0, i);
len--;
heapify(arr, 0, len);
}
return arr;
}
private void buildMaxHeap(int[] arr, int len) {
for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
heapify(arr, i, len);
}
}
private void heapify(int[] arr, int i, int len) {
int left = 2 * i + 1;
int right = 2 * i + 2;
int largest = i;
if (left < len && arr[left] > arr[largest]) {
largest = left;
}
if (right < len && arr[right] > arr[largest]) {
largest = right;
}
if (largest != i) {
swap(arr, i, largest);
heapify(arr, largest, len);
}
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
8.2算法分析
堆排序是不稳定的,时间复杂度为O(nlog2n)。