Java 语言实现的八大排序算法

Java 语言实现的八大排序算法

1、直接插入排序

基本思想：

基本思想：在要排序的一组数中，假设前面

(n-1)[n>=2]

个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。

/**
* <h2>方法名称：直接插入排序 </h2>
* <p>
* 基本思想：
* </p>
* <p>
* 在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，
* 现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。
* 如此反复循环，直到全部排好顺序。
* </p>
*
*/
public void insertSort() {
int a[] = {
49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64, 5, 4, 62, 99, 98, 54, 56, 17, 18, 23, 34, 15, 35, 25, 53, 51
};
System.out.print("原始数据：");
for (int i = 0; i < a.length; i++)
System.out.print(String.format("%d;", a[i]));
System.out.println();

int temp = 0;
for (int i = 1; i < a.length; i++) {
int j = i - 1;
temp = a[i];
for (; j >= 0 && temp < a[j]; j--) {
//将大于temp的值整体后移一个单位
a[j + 1] = a[j];
}
a[j + 1] = temp;
}

System.out.print("排序结果：");
for (int i = 0; i < a.length; i++)
System.out.print(String.format("%d;", a[i]));
}

2、希尔排序（最小增量排序）

基本思想：

算法先将要排序的一组数按某个增量

d（n/2,n为要排序数的个数）

分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量

（d/2）

对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

/**
* <h2>
*     希尔排序（最小增量排序）
* </h2>
* <p>
*     基本思想：
* </p>
* <p>
*     算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，
*     每组中记录的下标相差d.对每组中全部元素进行直接插入排序，
*     然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。
*     当增量减到1时，进行直接插入排序后，排序完成。
* </p>
*
*/
public void shellSort() {
int a[] = {1, 54, 6, 3, 78, 34, 12, 45, 56, 100};

System.out.print("原始数据：");
for (int i = 0; i < a.length; i++)
System.out.print(String.format("%d;", a[i]));
System.out.println();

double d1 = a.length;
int temp = 0;
while (true) {
d1 = Math.ceil(d1 / 2);
int d = (int) d1;
for (int x = 0; x < d; x++) {
for (int i = x + d; i < a.length; i += d) {
int j = i - d;
temp = a[i];
for (; j >= 0 && temp < a[j]; j -= d) {
a[j + d] = a[j];
}
a[j + d] = temp;
}
}
if (d == 1)
break;
}

System.out.print("排序结果：");
for (int i = 0; i < a.length; i++)
System.out.print(String.format("%d;", a[i]));
}

3、简单选择排序

基本思想：

在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

/**
* <h2>
* 简单选择排序
* </h2>
* <p>
* 基本思想
* </p>
* <p>
* 在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
* 然后在剩下的数当中再找最小的与第二个位置的数交换，
* 如此循环到倒数第二个数和最后一个数比较为止。
* </p>
*/
public static void selectSort() {
System.out.println(ClassName + "#" + Thread.currentThread().getStackTrace()[1].getMethodName());
int a[] = {1, 54, 6, 3, 78, 34, 12, 45};
System.out.print("原始数据：");
for (int i = 0; i < a.length; i++)
System.out.print(String.format("%d;", a[i]));
System.out.println();

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

int j = i + 1;
position = i;
int temp = a[i];
for (; j < a.length; j++) {
if (a[j] < temp) {
temp = a[j];
position = j;
}
}
a[position] = a[i];
a[i] = temp;
}

System.out.print("排序结果：");
for (int i = 0; i < a.length; i++)
System.out.print(String.format("%d;", a[i]));
System.out.println();
}

4、堆排序

基本思想：

堆排序是一种树形选择排序，是对直接选择排序的有效改进。 堆的定义如下：具有n个元素的序列

（h1,h2,…,hn)

,当且仅当满足

（hi>=h2i,hi>=2i+1）

或

（hi<=h2i,hi<=2i+1）(i=1,2,…,n/2)

时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

例如：

初始序列：46,79,56,38,40,84

建堆： 交换，从堆中踢出最大数

依次类推：最后堆中剩余的最后两个结点交换，踢出一个，排序完成。

////////////////////////堆排序//////////////////////////////////

/**
* <a href="http://mushiqianmeng.blog.51cto.com/3970029/738164/">
* http://mushiqianmeng.blog.51cto.com/3970029/738164/ * </a>
* <p>
* <h2>堆排序</h2>
* <p>基本思想：</p>
* <p>
* 堆排序是一种树形选择排序,是对直接选择排序的有效改进。
* </p>
* <p>
* 堆的定义如下：</p>
* <p>
* 具有n个元素的序列（h1,h2,…,hn),
* 当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,…,n/2)时称之为堆。
* 在这里只讨论满足前者条件的堆。
* 由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。
* 完全二叉树可以很直观地表示堆的结构。
* 堆顶为根，其它为左子树、右子树。
* 初始时把要排序的数的序列看作是一棵顺序存储的二叉树，
* 调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。
* 然后将根节点与堆的最后一个节点交换。
* 然后对前面(n-1)个数重新调整使之成为堆。
* 依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。
* </p>
* <p>
* <p>
* 从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。
* 所以堆排序有两个函数组成。
* 一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
* </p>
* <p>
* <p>实例：</p>
* <p>
* 初始序列：46,79,56,38,40,84
* 建堆： 交换，从堆中踢出最大数
* 依次类推：最后堆中剩余的最后两个结点交换，踢出一个，排序完成。
* </p>
* <p>
* <p>“堆排序”，《算法导论》6.4章节</p>
* 利用之前实现的构建MaxHeap和MaxHeapify算法完成排序。
* <p>伪代码：</p>
* <ul>
* HEAPSORT(A)
* <li>1 BUILD-MAX-HEAP(A)                     </li>
* <li>2 for i ← length[A] downto 2           </li>
* <li>3 do exchange A[1] ↔ A[i]              </li>
* <li>4 heap-size[A] ← heap-size[A] - 1      </li>
* <li>5 MAX-HEAPIFY(A, 1)                     </li>
* <p>
* </ul>
* <p>
* <p>堆排序，《算法导论》</p>
* <p>
* 原文摘要：
* The heapsort algorithm starts by using BUILD-MAX-HEAP to build a max-heap on the input
* array A[1  n], where n = length[A]. Since the maximum element of the array is stored at the
* root A[1], it can be put into its correct final position by exchanging it with A
.
* If we now "discard" node n from the heap (by decrementing heap-size[A]), we observe that
* A[1  (n -1)] can easily be made into a max-heap. The children of the root remain max-heaps,
* but the new root element may violate the max-heap property. All that is needed to restore
* the maxheap property, however, is one call to MAX-HEAPIFY(A, 1), which leaves a max-heap
* in A[1 (n - 1)]. The heapsort algorithm then repeats this process for the max-heap of size
* n - 1 down to a heap of size 2.
* </p>
* <p>
* 复杂度：
* </p>
* <p>
* 由之前分析可知，buildMaxHeap复杂度为O(n lg n)，运行一次。
* maxHeapify的复杂度为O(lg n)，运行n-1次。
* 综上，复杂度为O(n lg n)。
* </p>
*/
private static void heapSort() {
System.out.println(ClassName + "#" + Thread.currentThread().getStackTrace()[1].getMethodName());
int[] input = new int[]{16, 14, 10, 8, 7, 9, 3, 2, 4, 1};
System.out.print("原始数据：");
for (int i = 0; i < input.length; i++)
System.out.print(String.format("%d;", input[i]));
System.out.println();

int length = input.length;
//构造max-heap
buildMaxHeap(input, length);//交换位置
for (int i = length - 1; i > 0; i--) {
int temp = input[i];
input[i] = input[0];
input[0] = temp;
maxHeapify(input, 1, i);
}

System.out.print("排序结果：");
for (int i = 0; i < input.length; i++)
System.out.print(String.format("%d;", input[i]));
System.out.println();
}

private static void buildMaxHeap(int[] array, int heapSize) {
for (int i = heapSize / 2; i > 0; i--) {
maxHeapify(array, i, heapSize);
}
}

private static void maxHeapify(int[] array, int index, int heapSize) {
int l = index * 2;
int r = l + 1;
int largest;
//如果左叶子节点索引小于堆大小，比较当前值和左叶子节点的值，取值大的索引值
if (l <= heapSize && array[l - 1] > array[index - 1]) {
largest = l;
} else {
largest = index;
}
//如果右叶子节点索引小于堆大小，比较右叶子节点和之前比较得出的较大值，取大的索引值
if (r <= heapSize && array[r - 1] > array[largest - 1]) {
largest = r;
}
//交换位置，并继续递归调用该方法调整位置。
if (largest != index) {
int temp = array[index - 1];
array[index - 1] = array[largest - 1];
array[largest - 1] = temp;
maxHeapify(array, largest, heapSize);
}
}
////////////////////////堆排序//////////////////////////////////

5、冒泡排序

基本思想：

>

6、快速排序

基本思想：

>

7、归并排序

基本思想：

>

8、基数排序

基本思想：

>