Java回炉之排序算法

Java回炉之排序算法
- 冒泡排序
- 插入排序
- 归并排序
- 快速排序
- 希尔排序
- 选择排序
- 堆排序

冒泡排序

一次次遍历数组，每次比较相邻两个。
两重循环，内层比较index和index+1，index+1；外层让index归零。

/** 冒泡排序基本概念是：* 依次比较相邻的两个数，将小数放在前面，大数放在后面。* 即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。* 然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，* 直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，* 将最大的数放到了最后。在第二趟：仍从第一对数开始比较* （因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），* 将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），* 第二趟结束，在倒数第二的位置上得到一个新的最大数* （其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。 */
public class BubbleSort {public static void sort(int[] data) {for (int i = 0; i < data.length - 1; i++) {for (int j = 0; j < data.length - 1 - i; j++) {if (data[j] > data[j + 1]) {SortTest.swap(data, j, j + 1);}}}}
}

插入排序

遍历数组，每次把一个元素放到头。
两重循环，内层从大到小把index与index小的值比较；外层让index+1.

/** 插入排序基本思想* 将n个元素的数列分为已有序和无序两个部分，如插入排序过程示例下所示： 　　* {{a1}，{a2，a3，a4，…，an}} 　　* {{a1⑴，a2⑴}，{a3⑴，a4⑴ …，an⑴}} 　* {{a1(n-1），a2(n-1) ，…},{an(n-1)}} 　　* 每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较，* 找出插入位置，将该元素插入到有序数列的合适位置中。*/
public class InsertSort {public static void sort(int[] data) {for (int i = 1; i < data.length; i++) {for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {SortTest.swap(data, j, j - 1);}}}
}

归并排序

把要比较的分两组，先比较第一组，再比较第二组。
递归自身，如果改组count大于2则分组，否则比较改组元素。

/** 归并操作(merge)，也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。 　　* 如设有数列{6，202，100，301，38，8，1} 　　* 初始状态： [6] [202] [100] [301] [38] [8] [1] 比较次数 　　* i=1 [6 202 ] [ 100 301] [ 8 38] [ 1 ]　3 　　* i=2 [ 6 100 202 301 ] [ 1 8 38 ]　4 　　* i=3　[ 1 6 8 38 100 202 301 ] 4 */
public class MergeSort {public static void sort(int[] data) {int[] temp = new int[data.length];mergeSort(data, temp, 0, data.length - 1);}private static void mergeSort(int[] data, int[] temp, int l, int r) {int mid = (l + r) / 2;if (l == r)return;mergeSort(data, temp, l, mid);mergeSort(data, temp, mid + 1, r);for (int i = l; i <= r; i++) {temp[i] = data[i];}int i1 = l;int i2 = mid + 1;for (int cur = l; cur <= r; cur++) {if (i1 == mid + 1)data[cur] = temp[i2++];else if (i2 > r)data[cur] = temp[i1++];else if (temp[i1] < temp[i2])data[cur] = temp[i1++];elsedata[cur] = temp[i2++];}}
}

快速排序

整体为一组，让第一个元素找到自己位置，以钙元素为界分为两组
递归上一句，先比较第一组，再比较第二组。
让第一个元素作为核心元素找到自己位置：核心元素一次与队尾各元素相比，直至遇到比核心元素小的元素，此时量元素交换位置。
以核心元素为队首，被交换元素为队尾，递归上一句。

/** 快速排序：* 一趟快速排序的算法是： 　　* 1）设置两个变量i、j，排序开始的时候：i=0，j=N-1； 　　* 2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]； 　　* 3）从j开始向前搜索，即由后开始向前搜索（j=j-1即j--），* 找到第一个小于key的值A[j]，A[i]与A[j]交换； 　　* 4）从i开始向后搜索，即由前开始向后搜索（i=i+1即i++），* 找到第一个大于key的A[i]，A[i]与A[j]交换； 　　* 5）重复第3、4、5步，直到 I=J； * (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。* 找到并交换的时候i， j指针位置不变。* 另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。） */
public class QuickSort {public static void sort(int[] data) {quickSort(data, 0, data.length - 1);}private static void quickSort(int[] data, int i, int j) {int pivotIndex = (i + j) / 2;// swapSortTest.swap(data, pivotIndex, j);int k = partition(data, i - 1, j, data[j]);SortTest.swap(data, k, j);if ((k - i) > 1)quickSort(data, i, k - 1);if ((j - k) > 1)quickSort(data, k + 1, j);}/*** @param data* @param i* @param j* @return*/private static int partition(int[] data, int l, int r, int pivot) {do {while (data[++l] < pivot);while ((r != 0) && data[--r] > pivot);SortTest.swap(data, l, r);} while (l < r);SortTest.swap(data, l, r);return l;}
}

希尔排序

定义一个差值为length的一半，index从差值开始与其减差值的元素相比较，如果不交换则index自增，如果交换则继续与其减index相比。
index到顶之后，差值变为其自身的一半，重复上述内容。

/** 希尔排序：先取一个小于n的整数d1作为第一个增量，* 把文件的全部记录分成（n除以d1）个组。所有距离为d1的倍数的记录放在同一个组中。* 先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，* 直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。 */
public class ShellSort {public static void sort(int[] data) {for (int i = data.length / 2; i > 2; i /= 2) {for (int j = 0; j < i; j++) {insertSort(data, j, i);}}insertSort(data, 0, 1);}/*** @param data* @param j* @param i*/private static void insertSort(int[] data, int start, int inc) {for (int i = start + inc; i < data.length; i += inc) {for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {SortTest.swap(data, j, j - inc);}}}
}
/** 属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序 　　 * 排序过程：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，* 组内进行直接插入排序；然后取d2<d1，重复上述分组和排序操作；直至di=1， 即所有记录放进一个组中排序为止 　　 * 初始：d=5 　　49 38 65 97 76 13 27 49 55 04 　　 * 49 13 　　|-------------------| 　　 * 38 27     |-------------------| 　　 * 65 49 　　|-------------------| 　　 * 97 55     |-------------------| 　　 * 76 04 　　|-------------------| 　　 * 一趟结果 　　13 27 49 55 04 49 38 65 97 76 　　 * d=3 　　 13 27 49  55 04 49 38 65 97 76 　　 * 13 55 38 76 |------------|------------|------------| 　　 * 27 04 65 |------------|------------| 　　 * 49 49 97 |------------|------------| 　　* 二趟结果  13 04 49* 38 27 49 55 65 97 76 　　 * d=1 　　13 04 49 38 27 49 55 65 97 76* 　　 |----|----|----|----|----|----|----|----|----| 　　 三趟结果 　　* 04 13 27 38 49 49 55 65 76 97*/

选择排序

index初始为0
index处元素依次与比index大的元素相比，小值放到index处。比过一边后index+1。
重复上一句。

/** 选择排序基本思路：* 把第一个元素依次和后面的所有元素进行比较。* 第一次结束后，就会有最小值出现在最前面。* 依次类推*/
public class SelectionSort {public static void sort(int[] data) {for (int x = 0; x < data.length - 1; x++) {for (int y = x + 1; y < data.length; y++) {if (data[y] < data[x]) {SortTest.swap(data, x, y);}}}}
}

堆排序

/** 堆排序利用了大根堆（或小根堆）堆顶记录的关键字最大（或最小）这一特征， 使得在当前无序区中选取最大（或最小）关键字的记录变得简单。 　　* （1）用大根堆排序的基本思想 　　 ① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区 　　 ②* 再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个 记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，* 且满足R[1..n-1].keys≤R[n].key 　　 ③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。* 然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，* 由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，* 且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。 　 直到无序区只有一个元素为止。 　　* （2）大根堆排序算法的基本操作： 　　 ① 初始化操作：将R[1..n]构造为初始堆； 　　 ②* 每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换， 然后将新的无序区调整为堆（亦称重建堆）。*/public class HeapSort {public static void sort(int[] data) {MaxHeap h = new MaxHeap();h.init(data);for (int i = 0; i < data.length; i++)h.remove();System.arraycopy(h.queue, 1, data, 0, data.length);}private static class MaxHeap {void init(int[] data) {this.queue = new int[data.length + 1];for (int i = 0; i < data.length; i++) {queue[++size] = data[i];fixUp(size);}}private int size = 0;private int[] queue;public int get() {return queue[1];}public void remove() {SortTest.swap(queue, 1, size--);fixDown(1);}// fixdownprivate void fixDown(int k) {int j;while ((j = k << 1) <= size) {if (j < size && queue[j] < queue[j + 1])j++;if (queue[k] > queue[j]) // 不用交换break;SortTest.swap(queue, j, k);k = j;}}private void fixUp(int k) {while (k > 1) {int j = k >> 1;if (queue[j] > queue[k])break;SortTest.swap(queue, j, k);k = j;}}}
}

Java回炉之排序算法相关推荐

android studio插入数据表中没有_学Java能拿高薪吗 Java中常见排序算法有哪些
学Java能拿高薪吗?Java中常见排序算法有哪些?作为老牌编程语言,Java拥有广阔的市场占有率,几乎90%以上的大中型互联网应用系统在服务端开发都会首选Java.为了加入到Java这一高薪行业,很 ...
Java 实现常见排序算法
Java 实现常见排序算法 1. 综述复习常见排序算法,用Java实现. 2. 代码 1 package cn.edu.tju.scs; 2 3 public class Sort { 4 publ ...
Java折半二叉树,成都汇智动力-Java实现常用排序算法
原标题:成都汇智动力-Java实现常用排序算法排序算法介绍 1. 基本概念稳定性: 待排序的数列中,若两个元素的值相等 R1 = R2 ,在排序结束之后,元素之间的相对位置没有发生变化,则称排序算 ...
Java默认的排序算法
Java基础-08 [08:11] Java默认的排序算法: 需要区分: 是 Arrays.sort() 还是 Collections.sort() (底层是调用 Arrays.sort()): 什么 ...
【黑马程序员】学习笔记 - Java数组及排序算法
----------------------android培训.java培训.期待与您交流!---------------------- JAVA数组及排序算法一数组 1.定义定义:有联系的一 ...
java常用的排序算法的思想以及实现
一些常见的排序算法的事项以及java实现由于时间上的原因没有计算时间复杂度,以后有时间补上,或者大家有兴趣的可以自己算算 package com.sgcc.cn;import java.util.A ...
java八种排序算法---直接插入排序
在学习算法的过程中,我们难免会接触很多和排序相关的算法.总而言之,对于任何编程人员来说,基本的排序算法是必须要掌握的. 从今天开始,我们将要进行基本的排序算法的讲解.Are you ready?Let ...
Java十大排序算法总结,Java排序算法总结之冒泡排序
本文实例讲述了Java排序算法总结之冒泡排序.分享给大家供大家参考.具体分析如下: 前言:冒泡排序(BubbleSort)就是依次比较相邻的两个数,将小数放在前面,大数放在后面. 下面让我们一起 ...
java 实现常见排序算法（一）冒泡排序
大家好,我是烤鸭: 今天分享一下基础排序算法之冒泡排序. 1. 冒泡排序: 原理:比较两个相邻的元素,将较大的元素交换至右端. 思路:依次比较相邻的两个数,将小数放在前面,大数放在后面.即在第 ...

Java回炉之排序算法

Java回炉之排序算法

冒泡排序

插入排序

归并排序

快速排序

希尔排序

选择排序

堆排序

Java回炉之排序算法相关推荐

最新文章

热门文章