一,排序的概念及常见的排序
1.1排序的概念
排序:所谓排序,就是将一段数据以大小或者不同的方式排起来,以递增递减的方式排列起来的操作。
稳定性:就是在排序中有一样的数据,比如两个5,一个在前面,一个在后面,排序完之后,还能保持一个在前面的,一个在后面,这样的就是稳定的。
内部元素:将元素全部放在内部的元素,也是大多数的排序基准。
外部元素:数据元素太多不能同时放在内部,然后排序的要求也不能在内外之间移动数据的排序。
1.2常见的排序算法
二,几种排序算法的基本实现
2.1直接插入排序
名字就是排序方法,也就是将数据直接插入排序到一个已经排好序的序列中,将自己的数据跟序列中的数据一个一个进行比较,找到插入位置插入即可,然后把原来位置的数据按序往后移动。
直接插入排序特点:
1.如果数据接近有序,这种排序的效率就越高
2.时间复杂度:O(N^2)
3.空间复杂度:O(1)
4.稳定性:稳定
代码实现:
public static void insertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
int tmp = array[i];
int j = i-1;
for (; j >= 0 ; j--) {
//加不加等号 能取决于这个排序的稳定性
if(array[j] > tmp) {
array[j+1] = array[j];
}else {
break;
}
}
array[j+1] = tmp;
}
2.2希尔排序
希尔排序是直接插入排序的升级版,它会先进行几次预排序,将序列变的更接近有序,最后进行一次总排序,也就是直接插入排序,可以在数量很大的时候,更加快速的排序出来。
希尔排序总结:
1.是对直接插入排序的优化
2.当gap>1时,都是预排序
3.希尔排序的时间复杂度很难计算,一般记成o(n^1.25)
4.是不稳定的
代码实现:
public static void shellSort(int[] array) {
int gap = array.length;
while (gap > 1) {
gap = gap / 2;
shell(array,gap);
}
}
private static void shell(int[] array,int gap) {
//每组的数据也在变化
// 1+2+3+4+....+n/gap
for (int i = gap; i < array.length; i++) {
int tmp = array[i];
int j = i-gap;
for (; j >= 0 ; j-=gap) {
if(array[j] > tmp) {
array[j+gap] = array[j];
}else {
break;
}
}
array[j+gap] = tmp;
}
}
2.3堆排序
堆排序是利用推积树这种数据结构实现的一种排序,它是根据堆来选择数据,需要注意的是创建升序(由小到大)用大根堆,反之则小根堆
如上图就是堆排序的过程,先调换最后一个和堆顶元素,然后根据小跟堆特点来调换,最后达到目的。
代码实现:
public static void heapSort(int[] array){
//创建大根堆
createHeap(array);
int end = array.length-1;
while (end > 0) {
swap(array,0,end);
siftDown(array,0,end);
end--;
}
}
private static void createHeap(int[] array) {
for (int parent = (array.length-1-1)/2; parent >= 0 ; parent--) {
siftDown(array,parent,array.length);
}
}
private static void siftDown(int[] array,int parent,int len) {
int child = (2*parent)+1;
while (child < len) {
if(child + 1 < len && array[child] < array[child+1]) {
child = child+1;
}
if(array[child] > array[parent]) {
swap(array,child,parent);
parent = child;
child = 2*parent+1;
}else {
break;
}
}
}
堆排序总结:
1.效率较高,堆是二叉树的形式速度会快很多。
2.时间复杂度:O(N*logN)
3.空间复杂度:O(1)
4.不稳定
2.4冒泡排序
比较相邻的元素。如果第一个比第二个大(升序),就交换他们两个。
对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
针对所有的元素重复以上的步骤,除了最后一个。
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
冒泡排序容易理解,就不放图了。
冒泡排序代码:
public static void bubbleSort(int[] array) {
//i代表趟数 10 -》 9趟
for (int i = 0; i < array.length-1; i++) {
boolean flg = false;//初始化为false,后面交换就变1.
for(int j = 0;j < array.length-1-i;j++) {
if(array[j] > array[j+1]) {//如果前一个比后一个大就交换
swap(array,j,j+1);
flg = true;
}
}
//没有交换证明有序了
if(flg == false) {
return;
}
}
}
冒泡排序特点:
1.时间复杂度:O(N^2)
2.空间复杂度:O(1)
3.稳定
2.5快速排序*
快排主要分三步:
1.选基准:在序列中选一个元素作为基准。
2.分割:将序列中小于基准的放在左边,大于基准的放在右边。
3.递归排序:对基准左右两边的子序列重复上述步骤,直到子序列有序。
快速排序递归实现的框架和二叉树前序遍历很像,基本是一样的,代码如下:
void QuickSort(int[] array, int left, int right)
{
if(right - left <= 1){
return;
}
// 按照基准值对array数组的 [left, right)区间中的元素进行划分
int div = partion(array, left, right);
// 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)
// 递归排[left, div)在进行一次划分
QuickSort(array, left, div);
// 递归排[div+1, right)同理操作
QuickSort(array, div+1, right);
}
2.5.1挖坑法
快速排序有三种方法,我在这里说一下我喜欢的挖坑法:就是先将序列的第一个数据放在临时变量key中,然后从两边开始往中间走,在后面的right往前走找到了比基准小的,就放到前面基准挖的坑里面,然后后面就会形成一个坑,前面left找到比基准大的,就放的后面那个坑里,也就是挪开的坑里,一直重复,最后相遇,将基准放到最后相遇的地方。这就是挖坑法。
挖坑法的代码:
private static int partition(int[] array, int left, int right) {
int i = left;
int j = right;
int pivot = array[left];//挖坑,将第一个数拿出来
while (i < j) {
while (i < j && array[j] >= pivot) {
j--;//先走right找到比基准小的往前挪到基准挖的坑,空出自己的坑位
}
array[i] = array[j];
while (i < j && array[i] <= pivot) {
i++;//再走left找到比基准大的挪到它挪开的地方
}
array[j] = array[i];
}
array[i] = pivot;//最后把基准放到对应的相遇坑位。
return i;
}
快速排序总结:
1.快排性能非常好,使用场景也很多,实力出众。
2.时间复杂度:O(N*logN)
3.空间复杂度:O(logN)
4.不稳定
2.6归并排序
归并的操作就是将一个乱序数据先拆分成若干两两对比的小份数据,然后在慢慢归并,最后合在一起形成一个有序的序列表。还有要注意的就是对比时要保证两边都有数据才能进行比较,其操作如下:
即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。
归并排序代码:
//分解操作,跟建立二叉树时一样的
private static void mergeFunc(int[] array,int left,int right) {
if(left >= right) {
return;
}
int mid = left + ((right-left) >> 1);
mergeFunc(array,left,mid);//分解左树
mergeFunc(array,mid+1,right);
merge(array,left,mid,right);//递归合并
}
//归并过程
private static void merge(int[] array,int left,int mid,int right) {
//为了方便写代码,赋值简单的字
int s1 = left;
int e1 = mid;
int s2 = mid+1;
int e2 = right;
int[] tmpArr = new int[right-left+1];//表的长度
int k = 0;//表头位置
//1.保证两个表 都有数据
while (s1 <= e1 && s2 <= e2) {
if(array[s1] <= array[s2]) {
tmpArr[k++] = array[s1++];//将s1的东西放到k上,然后将他俩一起往后移动一个
}else {
tmpArr[k++] = array[s2++];
}
}
//2. 看哪个数组 还有数据 拷贝回去
while (s1 <= e1) {
tmpArr[k++] = array[s1++];
}
while (s2 <= e2) {
tmpArr[k++] = array[s2++];
}
//3.拷贝到源数组
for (int i = 0; i < k; i++) {
array[i+left] = tmpArr[i];//加left是因为右边合并时会将前面覆盖,防止这种操作产生而做的
}
}
归并排序总结:
1.牺牲空间换取时间
2.时间复杂度:O(N*logN)
3.空间复杂度:O(N)
4.稳定