数据结构中的几种排序

自己以前学的是C++版的数据结构后来学java对于数据结构中的排序虽然熟悉但是都已经忘了

所以今天就重新用java写了，如有不足之处，还望不吝赐教！

先从简单的开始吧

直接插入排序

主要思想：每次与前一个关键字比较大的值向后移一位。

package com.iss.demo;

public class InsertSort {

/**

* 直接插入比较的基本原理每次与前一个比较大的向后移

* @param args

*/

// 直接插入排序

public static void main(String[] args) {

int[] a = { 2, 1, 4, 2, 7, 8, 6 };

System.out.println("排序前：");

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

System.out.print(a[i] + " ");

}

// 每次与前一个进行比较，若前面一个比较若比自己大就像后移一位

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

int j;

int temp = a[i];

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

if (a[j] > temp) {

a[j + 1] = a[j];// 如果a[j]>temp向后移一位

} else {

break;

}

}

a[j + 1] = temp;//不是a[j] 原因是循环后j--

}

System.out.println();

System.out.println("排序后:");

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

System.out.print(a[i] + " ");

}

}

}

选择排序

主要思想：一趟排序中选出最小的赋给数组的第一个值。

public class SelectionSort {

// 选择排序每次比较取出最小值给一个下标

public static void selectionSort(int[] a) {

int min = 0;

int temp;

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

min = i;

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

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

min = j;

}

}

temp = a[min];

a[min] = a[i];

a[i] = temp;

}

}

public static void main(String[] args) {

int[] a = { 2, 1, 4, 5, 9, 8, 7 };

selectionSort(a);

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

System.out.print(a[i] + " ");

}

}

}

最经典冒泡排序

主要思想：每一趟两两比较取最大值一共比较n-1-i次。

public class BubbleSort {

public void bubbleSort(int[] arr) {

// 冒泡排序基本原理比较取最大值 每一趟需要比较n-1-i次

int temp;

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

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

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

temp = arr[j];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

}

}

}

}

public static void main(String[] args) {

int[] arr = { 2, 1, 3, 4, 6, 5 };

// new BubbleSort().bubbleSort(arr);

// new BubbleSort().SelectionSort(arr);

new BubbleSort().bubbleSort1(arr);

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

System.out.println(arr[i]);

}

}

}

最不容易的理解的快速排序

主要思想：

通过一趟排序将排序记录分割成独立的两部分，其中一部分记录的关键字比另一部分的关键字小，

然后对这两部分再进行排序直到，整个序列有序。

算法思想：把整个序列看做一个数组，把第零个位置和最后一个比较，如果比它小交换，否则不

做处理；交换以后再和小的那端比。比他小不交换，比他大交换。这样循环往复，一趟排序完成，

左边就是比中轴小的，右边就是比中轴大的，然后再用分治法，分别对独立的数组进行排序。

package com.iss.sort;

public class QuickSort {

public int getMiddle(int[] a, int low, int high) {

int temp = a[low];

while (low < high) {

while (low < high && temp <= a[high]) {

high--;

}// 若不加等于会死循环

a[low] = a[high];

while (low < high && temp >= a[low]) {

low++;

}

a[high] = a[low];

}

a[low] = temp;// 中轴记录到尾

return low;

}

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

if (low < high) {

int middle = this.getMiddle(a, low, high);

quickSort(a, low, middle - 1);

quickSort(a, middle + 1, high);

}

}

// public void quick_sort(int[] a) {

// if (a.length > 0) {

// this.quickSort(a, 0, a.length - 1);

// }

// }

public static void main(String[] args) {

int[] a = { 2, 1, 4, 2, 6, 8, 90, 4, 5 };

new QuickSort().quickSort(a, 0, a.length - 1);

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

System.out.print(a[i] + " ");

}

}

}

附赠另一种方式的快速排序

package com.iss.sort;

public class QuickSort1 {

public void quickSort(int[] a, int left, int right) {

int i, j, middle, temp;

i = left;

j = right;

middle = (i + j) / 2;

while (i < j) {

while (a[i] < a[middle] && i < right) {

i++;

}// 不能是等于是等于中间的值不变了就无法成功排序

while (a[j] > a[middle] && j > left) {

j--;

}

if (i <= j) {

temp = a[i];

a[i] = a[j];

a[j] = temp;

i++;

j--;

}

}

if (i < right) {

this.quickSort(a, i, right);

}

if (j > left) {

this.quickSort(a, left, j);

}

}

public static void main(String[] args) {

int[] a = { 2, 2, 1, 4, 67, 3, 7, 8, 9 };

new QuickSort1().quickSort(a, 0, a.length - 1);

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

System.out.print(a[i] + " ");

}

}

}

几种排序的时间复杂度

选择排序算法时间复杂度是O(n^2)

插入排序算法时间复杂度是O(n^2)

冒泡排序算法时间复杂度是O(n^2)

快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n)，最坏O(n^2)。

另有几种排序原谅笔者还不精通！后续有时间再更！