文章标题

排序算法汇总(一)(Java实现)

一、冒泡排序(最容易理解也是一种比较常用的排序算法)

思想：依次比较相邻的两个数,如果发现前一个数比后一个数大,就交换两个数的位置,这样每一组比较下来,就能将该组中最大的一个数放在最后.该算法的时间复杂度为O(n2)

代码实现:

public static void main(String[] args) {

int[] array = new int[]{1,45,7,4,68,1,4,5};

bubbleSort(array);

print(array);

}

public static void bubbleSort(int[] array){

for(int i = array.length - 1;i >= 0;i–){

for(int j = 0;j < i;j++){

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

int temp = array[j];

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

array[j+1] = temp;

}

}

}

}

public static void print(int[] array){

for(int i = 0;i < array.length;i++){

System.out.print(array[i]+” “);

}

}

二、直接插入排序：

思想：从待排序列的第二个元素开始,依次与前面排列好的元素比较,发现比该元素小的一个元素,就插入到这个元素的后面.该算法的时间复杂度为O(n2)

代码实现：

public static void main(String[] args) {

int[] array = new int[]{1,45,7,4,68,1,4,5};

insrtSort(array);

print(array);

}

public static void insrtSort(int[] array){

for(int i = 1;i < array.length;i++){

if(array[i] > array[i-1]){//如果发现刚开始排序的第一个数比前一个数大,直接继续下一组排序

continue;

}

for(int j = i-1;j >= 0;j–){

if(array[i] >= array[j]){

int temp = array[i];

for(int k = i - 1;k >= j+1;k–){

array[k+1] = array[k];

}

array[j+1] = temp;

break;

}

}

}

}

public static void print(int[] array){

for(int i = 0;i < array.length;i++){

System.out.print(array[i]+” “);

}

}

三、直接选择排序:

思想：从待排序列的第一个元素开始,依次查找出该序列中最小的元素,并将该元素与待排序列的第一个元素交换.时间复杂度为O(n2)

代码实现:

public static void main(String[] args) {

int[] array = new int[]{1,45,7,4,68,1,4,5};

selectSort(array);

print(array);

}

public static void selectSort(int[] array){

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

int index = i;

for(int j = i;j < array.length-1;j++){

if(array[index] > array[j+1]){

index = j+1;

}

}

int temp = array[i];

array[i] = array[index];

array[index] = temp;

}

}

public static void print(int[] array){

for(int i = 0;i < array.length;i++){

System.out.print(array[i]+” “);

}

}

四、快速排序：

思想：第一步是在待排序列中找一个基数(一般是该序列的第一个元素),通过一次比较将小于该基数的元素放在该基数的左边,大于该基数的元素放在该基数的右边,这样一次快速排序就完成了,一般要通过递归调用快速排序才能将该序列变成有序.时间复杂度为O(nlogn).

代码实现:

public static void main(String[] args) {

int[] array = new int[]{1,45,7,4,68,1,4,5};

quickSort(array,0,array.length-1);

print(array);

}

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

int l = low;

int h = high;

int sign = array[low];//待排序列的基数,一般取该序列的第一个值

while(l < h){

while(l < h && array[h] >= sign){

h–;

}

if(l < h){

int temp = array[h];

array[h] = array[l];

array[l] = temp;

l++;

}

while(l < h && array[l] <= sign){

l++;

}

if(l < h){

int temp = array[l];

array[l] = array[h];

array[h] = temp;

h–;

}

}

if(l > low){

quickSort(array,low,l-1);

}

if(h < high){

quickSort(array, l+1, high);

}

}

public static void print(int[] array){

for(int i = 0;i < array.length;i++){

System.out.print(array[i]+” “);

}

}

五、归并排序：

思想：归并排序算法采用的是一种分治思想,将容量比较大的序列划分成两个子序列进行排序,最后将每个子序列合并。时间复杂度是O(nlogn).

代码实现：

public static void main(String[] args) {

int[] array = new int[]{1,5,1,4,7,3,6};

mergeSort(array, 0, array.length - 1);

printArray(array);

}

private static void printArray(int[] array) {

for(int i = 0;i < array.length;i++){

System.out.print(array[i]+” “);

}

}

public static int[] mergeSort(int[] array,int low,int high){

int mid = (low+high)/2;

if(low < high){

mergeSort(array, low, mid);

mergeSort(array, mid + 1, high);

merge(array,low,mid,high);

}

return array;

}

private static void merge(int[] array, int low, int mid, int high) {

int[] temp = new int[high - low + 1];

int i = low;

int j = mid + 1;

int k = 0;

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

if(array[i] <= array[j]){

temp[k++] = array[i++];

}else{

temp[k++] = array[j++];

}

}

while(i <= mid){

temp[k++] = array[i++];

}

while(j <= high){

temp[k++] = array[j++];

}

for(int m = 0;m < temp.length;m++){

array[m+low] = temp[m];

}

}