七种基于比较的排序算法基本原理及实现
七种基于比较的排序算法基本原理及实现
- 排序：
-
- 1.直接插入排序
- 2.希尔排序
- 3.选择排序
- 4.堆排序
- 5.冒泡排序
- 6.快速排序
- 7.归并排序
最近刚学习完七种比较常见的基于比较的排序算法，感觉比较重要，所以写个博客记录一下，不多说，开冲。
排序：
排序就是使一串无序的数字经过处理之后变得有序，可以是升序，也可以是降序，算法中的排序主要是排升序。
排序需要考虑的因素：
时间复杂度：算法中的基本执行次数。
空间复杂度：临时占据存储空间大小的量度。衡量一个算法所需要的额外空间。
稳定性：两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。
1.直接插入排序
思想：每一步取一个待排序元素，将这个待排序元素与前面的元素进行比较，插入到合适的位置上，下标后移，直至插入所有的元素。
从下标1开始取是为了确保前面有可以比较的元素。
代码如下：
public void inserSort(int[] array) {
int tmp = 0;//tmp是用来记录每次取的元素的值
for (int i = 1; i < array.length; i++) {
int j;//j用来表示i下标前面的元素的下标，j的初始值为j=i-1。
tmp = array[i];
for (j = i - 1; j >= 0; j--) {
if (array[j] > tmp) {//当j下标的元素值大于tmp时，把j下标的值赋给j+1下标
array[j + 1] = array[j];
} else {
break;
}
}
array[j + 1] = tmp;//一趟比较完之后，将tmp赋值给j+1下标
}
}
时间复杂度：
最优情况：待排序数组已经有序了，O(n)。
最坏情况：代码中使用了两个循环嵌套，O(n^2)。
空间复杂度：
申请了一个tmp用于保存每次用于比较的元素，所以为O(1)。
稳定性：是一个稳定的排序方式。
在排序时，数组越趋于有序，直接插入排序的时间复杂度越小。
2.希尔排序
思想：希尔排序的思想与直接插入排序的思想相同，只不过在排序的过程中对数据进行了分组，每一次排完，下一次进行排序时数据更趋近于有序，时间复杂度大大降低。
先分为五组，每组进行直接插入排序。
再分为三组，每组进行直接插入排序。
最后进行一次直接插入排序。
代码如下：
public void shell(int[] array, int gap) {
int tmp;
for (int i = gap; i < array.length; i++) {
int j;
tmp = array[i];
for (j = i - gap; i < array.length; i -= gap) {
if (array[j] > tmp) {
array[j + gap] = array[j];
} else {
break;
}
}
array[j + gap] = tmp;
}
}
public void shellSort(int[] array) {
int[] drr = {5, 3, 1};//增量序列
for (int i = 0; i < drr.length; i++) {//每组进行直接插入排序
shell(array, drr[i]);
}
}
对于分组的规则：应使增量序列中的值没有除1之外的公因子，并且最后一个增量值必须为1。(分组所采取的组数从大到小，都为素数，最后一个数为1，例如上述情况选择531分组，也可以是521分组)。
时间复杂度：
最坏情况：O(n^2)。
最优情况：O(n)。
空间复杂度：O(1)。
稳定性：不稳定的排序。
3.选择排序
思想：每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元 素排完。
代码如下：
public void selectSort(int[] array) {
for (int i = 0; i < array.length; i++) {
for (int j = i + 1; j < array.length; j++) {
if (array[i] > array[j]) {
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
}
}
}
时间复杂度：最好最坏都为O(n^2)。
空间复杂度：O(1)。
稳定性：不稳定的排序。
4.堆排序
基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。
注意:排升序要建大根堆，排降序要建小根堆。
代码如下：
public void heapSort(int[] array) {
creatHeap(array);
int end = array.length - 1;
while (end > 0) {
if (array[0] > array[end]) {
int tmp = array[0];
array[0] = array[end];
array[end] = tmp;
adjustDown(array, 0, end);
end--;
}
}
}
public void creatHeap(int[] array) {//创建堆
for (int i = (array.length - 1 - 1) / 2; i >= 0; i--) {
adjustDown(array, i, array.length);
}
}
public void adjustDown(int[] array, int root, int len) {//向下调整
int parent = root;//父亲节点
int child = 2 * parent + 1;//孩子节点
while (child < len) {//有孩子节点时，进入循环
if (child + 1 < len && array[child] < array[child + 1]) {
child++;
}
if (array[parent] < array[child]) {//当孩子节点的值大于父亲节点的值时，进行交换
int tmp = array[parent];
array[parent] = array[child];
array[child] = tmp;
parent = child;//孩子节点为父节点的下一层是否满足？
child = 2 * parent + 1;
} else {
break;
}
}
}
时间复杂度：最好最坏都为O(nlog2n)。
空间复杂度：O(1)。
稳定性：不稳定的排序。
5.冒泡排序
在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序。
代码如下：
public void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
boolean flg = false;
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j + 1] < array[j]) {
int tmp = array[j + 1];
array[j + 1] = array[j];
array[j] = tmp;
flg = true;
}
}
if (!flg) {//这一步是对冒泡排序进行了优化，如果某一趟比较完之后没有需要进行交换的元素
//那么就说明已经是有序的序列了
break;
}
}
}
时间复杂度：
最坏情况：O(n^2)。
最好情况：O(n)。
空间复杂度：O(1)。
稳定性：稳定的排序。
6.快速排序
- 从待排序区间选择一个数，作为基准值(pivot)；
- Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值 的左边，将比基准值大的 （可以包含相等的）放到基准值的右边；
- 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区 间的长度 == 0，代表没有数据。
递归做法的代码：
public void partition(int[] array,int low,int high){
int tmp=array[low];//pivot放入tmp中
while(low<high){
while(low<high&&array[high]>tmp){
high--;
}
array[low]=array[high];
while(low<high&&array[low]>tmp){
low++;
}
array[high]=array[low];
}
array[low]=tmp;
return low;
}
public void quick(int[] array,int left,int right){
if(left>=right){
return;
int par=partition(array,left,right);
quick(array,left,par-1);//par左边
quick(array,par+1,right);//par右边
}
}
public void quickSort(int[] array){
quick(array,0,array.length-1);
}
使用栈不使用递归的做法：
代码如下：
public void quickSort(int[] array){
Stack stack=new Stack();
int left=0;
int right=array.length-1;
int par=partition(array,left,right);
if(par>left+1){//左边至少有两个元素
stack.push(left);
stack.push(par-1);
}
if(par<right-1){//右边至少有两个元素
stack.push(par+1);
stack.push(right);
}
while(!stack.isEmpty()){
right=stack.pop();//因为放的时候顺序为先左后右，所以取的时候为先右后左
left=stack.pop();
par=partition(array,left,right);
if(par>left+1){
stack.push(left);
stack.push(par-1);
}
if(par<right-1){
stack.push(par+1);
stack.push(right);
}
}
}
时间复杂度：
最好情况：O(n*log2n)
最坏情况：O(n^2) 8 7 6 5 4 3 2 1
空间复杂度：
O(log2n)
最坏O(n)
稳定性：不稳定的排序。
快排每次划分序列的时候，如果可以均匀的划分，效率最好。
7.归并排序
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使 子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
代码如下：
public void merge(int[] array, int left, int mid, int right) {//用于归并
int s1 = left;
int s2 = mid + 1;
int[] ret = new int[right - left + 1];
int i = 0;
while (s1 <= mid && s2 <= right) {//比较
if (array[s1] <= array[s2]) {
ret[i++] = array[s1++];
} else {
ret[i++] = array[s2++];
}
}
while (s1 <= mid) {//比较完s1还有剩余元素时，全部放入ret中
ret[i++] = array[s1++];
}
while (s2 <= right) {//比较完s2还有剩余元素时，全部放入ret中
ret[i++] = array[s2++];
}
for (int j = 0; j < ret.length; j++) {
array[j + left] = ret[j];
}
}
public void mergeSortInternal(int[] array, int left, int right) {//分解
if (left == right) {
return;
}
int mid = (left + right) / 2;
//分解
mergeSortInternal(array, left, mid);
mergeSortInternal(array, mid + 1, right);
//归并
merge(array, left, mid, right);
}
public void mergeSort(int[] array) {
mergeSortInternal(array, 0, array.length - 1);
}
非递归实现归并排序：
代码如下：
public void mergeNor(int[] array, int gap) {
int[] ret = new int[array.length];
int k = 0;//ret的下标
int s1 = 0;
int e1 = s1 + gap - 1;
int s2 = e1 + 1;
int e2 = s2 + gap - 1 < array.length ? s2 + gap - 1 : array.length - 1;
//e2位置：如果s2+gap-1大于数组长度说明越界了，这时取array.length-1。
//如果没有，则还是取s2+gap-1。
while (s2 < array.length) {//如果s2大于数组长度，则第二段数据只有一个归并段
//1.满足循环条件则表示肯定有两个归并段
//2.对应的s1位置和s2位置进行比较
while (s1 <= e1 && s2 <= e2) {
if (array[s1] > array[s2]) {
ret[k++] = array[s2++];
} else {
ret[k++] = array[s1++];
}
}
//3.在2步骤的比较过程中，肯定会有一个归并段先走完
//4.判断哪个归并段没走完，把剩下的数据拷贝到目标数组中
while (s1 <= e1) {
ret[k++] = array[s1++];
}
while (s2 <= e2) {
ret[k++] = array[s2++];
}
//5.接着确定新的s1，e1，s2，e2。
s1 = e2 + 1;
e1 = s1 + gap - 1;
s2 = e1 + 1;
e2 = e2 + gap - 1 > array.length ? array.length : e2 + gap - 1;
}
//6.还需要判断是否有另外的归并段。
//只有s1一个归并段时，直接将s1~~~array.length-1段的数据拷贝到ret中
while (s1 < array.length - 1) {
ret[k++] = array[s1++];
}
for (int i = 0; i < array.length; i++) {
array[i] = ret[i];
}
}
public static void mergeSort1(int[] array) {
for (int gap = 1; gap < array.length; gap = gap * 2) {
mergeNor(array, gap);
}
}
时间复杂度：O(n*log2n)
空间复杂度：O(n)
稳定性：是一个稳定的排序。