线形排序 java_java实现排序算法，比较时间复杂度

插入排序、冒泡排序、选择排序、快速排序、归并排序

以下所有排序都是实现升序

1.插入排序

【定义】

第一个元素自成一个有序数组A，从第二个元素开始，把每一个元素插入到有序数组A中合适的位置，满足有序的条件。直到最后元素，至此构建成一个有序数组。

【时间复杂度】

O(n2)

【代码】

public void method(int [] array) {

int length = array.length;

int i,j;

for (i = 1; i < length; i++) {

int temp = array[i];

for (j = i-1; j >= 0 && array[j] > temp; j --) {

array[j+1] = array[j];

}

array[j+1] = temp;

}

}

补充：

在第二个for循环中，判断条件需要加上比较大小关系，

不能在for循环里面进行if判断，因为这样会导致最后一个元素的判断存在问题

2.冒泡排序

【定义】

从第一个元素开始，进行两两比较，如果前一个大于后一个，则进行交换，经过一轮交换之后，也就是一次冒泡，最大的元素就会在最后一个位置，在从第一个元素进行排序，两两比较，经过一轮交换之后，第二大的元素就在倒数第二个位置，以此类推

【时间复杂度】

O(n2)

【代码】

public void method(int [] a) {

int i,j;

for (i = a.length; i > 0; i --) {

for (j = 0; j < i-1; j ++) {

if (a[j] > a[j+1]) {

int temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

}

}

}

改进：

可以通过加标志位，当一次冒泡没有发生交换的时候，

也就意味着此时是排好序的

public void BetterMethod(int [] a) {

int i,j;

boolean flag = false;

for (i = a.length; i > 0; i --) {

flag = false;

for (j = 0; j < i-1; j ++) {

if (a[j] > a[j+1]) {

flag = true;

int temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

}

if (!flag) {

break;

}

}

}

3.选择排序

【定义】

在第一个元素到最后一个元素之间寻找一个最小的元素放在第一位，在从第二个元素到最后一个元素选择一个最小的放在第二位，依次类推

【时间复杂度】

O(n2)

【代码】

public void method(int [] a) {

int i,j;

for (i = 0; i < a.length-1; i++) {

int index = i;

for (j = i+1; j < a.length; j++) {

if (a[j] < a[index]) {

index = j;

}

}

if (i != index) {

int temp = a[i];

a[i] = a[index];

a[index] = temp;

}

}

}

4.快速排序

【定义】

快速排序需要通过递归的方法来实现，首先需要选择一个支点，这个支点理论是可以任意选择，但通常都选择中间的元素，然后从在头和尾放置索引开始同时向中间遍历，当头索引遇到大于支点的元素停止，当尾索引遇到小于支点的元素停止，然后交换头尾索引的元素，之后头尾索引交叉停止，递归的遍历，直到首尾相等

【时间复杂度】

O(nlogn)

【代码】

public class QuickSort {

public static void quickSort(int[] arr,int low,int high){

int i,j,temp,t;

if(low>high){

return;

}

i=low;

j=high;

//temp就是基准位

temp = arr[low];

while (i

//先看右边，依次往左递减

while (temp<=arr[j]&&i

j--;

}

//再看左边，依次往右递增

while (temp>=arr[i]&&i

i++;

}

//如果满足条件则交换

if (i

t = arr[j];

arr[j] = arr[i];

arr[i] = t;

}

}

//最后将基准为与i和j相等位置的数字交换

arr[low] = arr[i];

arr[i] = temp;

//递归调用左半数组

quickSort(arr, low, j-1);

//递归调用右半数组

quickSort(arr, j+1, high);

}

【注意】

选准基准点之后，首尾设置索引，需要先从右向左遍历，在从左向右遍历，这里顺序不能颠倒，颠倒顺序算法就错误，因为一次快排要达到左边元素都小于基准点，右边元素都大于基准点，如果先从左边开始，会在大于基准点的位置停止，这个时候在交换，会在这个大于的元素跟基准点交换。在内层的索引while循环的条件：temp<=arr[j]&&i

5.归并排序

【定义】

二路归并排序需要通过递归实现，运用的是分而治之的思想，先分再合，先是不断的分元素，直到每组元素只能一个，然后是合并，合并的时候，以中间为区分，分别在两组的首元素上设置索引，构建一个临时数组，比较索引所在的元素并把较小的放入临时数组，直到其中一组元素为空，这个时候再把另一组的元素全部放入临时数组。最后把临时数组元素拷贝到目标数组

【时间复杂度】

O(nlogn)

【代码】

/**

* 排序

* */

public void sort(int [] a,int s, int e) {

// 当只剩一个元素返回

if (s < e) {

// 获取中间下标

int mid = (s + e)/2;

sort(a, s, mid);

sort(a, mid+1, e);

// 合并两个组的元素

merge(a, s, mid, e);

}

}

/**

* 合并元素

* */

public void merge(int [] a,int s, int mid, int e) {

// 临时数组

int [] temp = new int[e-s+1];

int i = s;

int j = mid + 1;

int index = 0;

// 把两组元素比较，并以此放入临时数组，直到其中一组元素为空

while (i<=mid && j<=e) {

if (a[i] < a[j]) {

temp[index ++] = a[i ++];

} else {

temp[index ++] = a[j ++];

}

}

// 把剩下的不为空的一组元素放入临时数组

while (i <= mid) {

temp[index ++] = a[i ++];

}

while (j <= e) {

temp[index ++] = a[j ++];

}

// 把临时数组复制到目标数组

index = 0;

while (s <= e) {

a[s ++] = temp[index ++];

}

}

稳定性

插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的。选择排序、希尔排序(插入排序的一种改进)、快速排序、堆排序是不稳定的。

关于快排和归并排序

快排的最坏时间复杂度是n2,归并的最好最坏都是nlogn

归并的速度开始超过快速排序了，因为归并排序比快排要稳定，所以在数据量大的时候，快排容易达到 O (n^2) 的时间复杂度，所以大量数据二路归并排序是更好的选择