数列的组合及排列方式java_常用排序算法及Java实现

概述

在计算器科学与数学中，一个排序算法(英语：sorting algorithm)是一种能将一串数据依照特定排序方式进行排列的一种算法。本文将总结几类常用的排序算法，包括冒泡排序、选择排序、插入排序、快速排序和归并排序。

算法原理及实现

1、冒泡排序

原理图

理解

通过重复地遍历要排序的列表，比较每对相邻的项目，并在顺序错误的情况下交换它们。

java code

public class bubblesort {

// logic to sort the elements

public static void bubble_srt(int array[]) {

int n = array.length;

int k;

for (int m = n; m >= 0; m--) {

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

k = i + 1;

if (array[i] > array[k]) {

swapnumbers(i, k, array);

}

}

printnumbers(array);

}

}

private static void swapnumbers(int i, int j, int[] array) {

int temp;

temp = array[i];

array[i] = array[j];

array[j] = temp;

}

private static void printnumbers(int[] input) {

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

system.out.print(input[i] + ", ");

}

system.out.println("\n");

}

public static void main(string[] args) {

int[] input = { 4, 2, 9, 6, 23, 12, 34, 0, 1 };

bubble_srt(input);

}

}

2、选择排序

原理图

理解

内部循环查找下一个最小(或最大)值，外部循环将该值放入其适当的位置。

java code

public class selectionsort {

public static int[] doselectionsort(int[] arr){

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

{

int index = i;

for (int j = i + 1; j < arr.length; j++)

if (arr[j] < arr[index])

index = j;

int smallernumber = arr[index];

arr[index] = arr[i];

arr[i] = smallernumber;

}

return arr;

}

public static void main(string a[]){

int[] arr1 = {10,34,2,56,7,67,88,42};

int[] arr2 = doselectionsort(arr1);

for(int i:arr2){

system.out.print(i);

system.out.print(", ");

}

}

}

3、插入排序

原理图

理解

每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。

java code

public class insertionsort {

public static void main(string a[]){

int[] arr1 = {10,34,2,56,7,67,88,42};

int[] arr2 = doinsertionsort(arr1);

for(int i:arr2){

system.out.print(i);

system.out.print(", ");

}

}

public static int[] doinsertionsort(int[] input){

int temp;

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

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

if(input[j] < input[j-1]){

temp = input[j];

input[j] = input[j-1];

input[j-1] = temp;

}

}

}

return input;

}

}

4、快速排序

原理图

理解

将原问题分解为若干个规模更小，但结构与原问题相似的子问题，递归地解这些子问题，然后将这些子问题的解组合为原问题的解。

java code

public class quicksort {

private int array[];

private int length;

public void sort(int[] inputarr) {

if (inputarr == null || inputarr.length == 0) {

return;

}

this.array = inputarr;

length = inputarr.length;

quicksort(0, length - 1);

}

private void quicksort(int lowerindex, int higherindex) {

int i = lowerindex;

int j = higherindex;

// calculate pivot number, i am taking pivot as middle index number

int pivot = array[lowerindex+(higherindex-lowerindex)/2];

// divide into two arrays

while (i <= j) {

/**

* in each iteration, we will identify a number from left side which

* is greater then the pivot value, and also we will identify a number

* from right side which is less then the pivot value. once the search

* is done, then we exchange both numbers.

*/

while (array[i] < pivot) {

i++;

}

while (array[j] > pivot) {

j--;

}

if (i <= j) {

exchangenumbers(i, j);

//move index to next position on both sides

i++;

j--;

}

}

// call quicksort() method recursively

if (lowerindex < j)

quicksort(lowerindex, j);

if (i < higherindex)

quicksort(i, higherindex);

}

private void exchangenumbers(int i, int j) {

int temp = array[i];

array[i] = array[j];

array[j] = temp;

}

public static void main(string a[]){

myquicksort sorter = new myquicksort();

int[] input = {24,2,45,20,56,75,2,56,99,53,12};

sorter.sort(input);

for(int i:input){

system.out.print(i);

system.out.print(" ");

}

}

}

5、归并排序

原理图

理解

将待排序的数列分成若干个长度为1的子数列，然后将这些数列两两合并；得到若干个长度为2的有序数列，再将这些数列两两合并；得到若干个长度为4的有序数列，再将它们两两合并；直接合并成一个数列为止。

java code

public class mergesort {

private int[] array;

private int[] tempmergarr;

private int length;

public static void main(string a[]){

int[] inputarr = {45,23,11,89,77,98,4,28,65,43};

mymergesort mms = new mymergesort();

mms.sort(inputarr);

for(int i:inputarr){

system.out.print(i);

system.out.print(" ");

}

}

public void sort(int inputarr[]) {

this.array = inputarr;

this.length = inputarr.length;

this.tempmergarr = new int[length];

domergesort(0, length - 1);

}

private void domergesort(int lowerindex, int higherindex) {

if (lowerindex < higherindex) {

int middle = lowerindex + (higherindex - lowerindex) / 2;

// below step sorts the left side of the array

domergesort(lowerindex, middle);

// below step sorts the right side of the array

domergesort(middle + 1, higherindex);

// now merge both sides

mergeparts(lowerindex, middle, higherindex);

}

}

private void mergeparts(int lowerindex, int middle, int higherindex) {

for (int i = lowerindex; i <= higherindex; i++) {

tempmergarr[i] = array[i];

}

int i = lowerindex;

int j = middle + 1;

int k = lowerindex;

while (i <= middle && j <= higherindex) {

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

array[k] = tempmergarr[i];

i++;

} else {

array[k] = tempmergarr[j];

j++;

}

k++;

}

while (i <= middle) {

array[k] = tempmergarr[i];

k++;

i++;

}

}

}

参考链接

希望与广大网友互动？？

点此进行留言吧！