常见的排序算法：
算法的时间，空间复杂度以及稳定性：
1.插入排序：整个区间分为：
（1）有序空间
（2）无序空间
每次在无序区间中选择第一个元素，在有序区间内选择一个合适的位置插入
实现
package PreviweSort;
import java.util.Arrays;
public class InsertSort {
public static void main(String[] args) {
int[] arr = {4, 1, 7, 6, 5, 2, 3, 9, 8};
/*
1.将[0,i]看做有序区间
2.将(i,arr.length)看做无序区间
3.每次从无序空间中找第一个元素往有序空间中插
*/
for (int i = 1; i < arr.length; i++) {
//定义待插入元素，从初始列表第二个元素开始，因为第一个有序
int insertValue = arr[i];
//定义有序区间的边界，就是带插入元素的前一个位置
int insertIndex = i - 1;
//内层循环arr[insertIndex]>insertValue不写成>=是为了确保算法的稳定性
for (; insertIndex >= 0 && arr[insertIndex] > insertValue; insertIndex--) {
arr[insertIndex + 1] = arr[insertIndex];
}
//退出内层循环说明找到带插入元素的前一个位置
arr[insertIndex + 1] = insertValue;
}
System.out.println(Arrays.toString(arr));
}
}
性能分析
稳定性： 稳定
插入排序初始数据有序性越高，时间效率越高
2.折半插入排序
package PreviweSort;
import java.util.Arrays;
public class BSInsertSort {
public static void main(String[] args) {
int[] arr = {4, 1, 7, 6, 5, 2, 3, 9, 8};
for (int i = 1; i < arr.length; i++) {
int left = 0;
int right = i;
int insertVal = arr[i];
//利用折半思想找到带插入元素的位置
while (left < right) {
int m = (left + right) / 2;
if (insertVal >= arr[m]) {
left = m + 1;
} else {
right = m;
}
}
//退出while循环说明找到了插入位置
//搬移元素
for (int j = i; j > left; j--) {
arr[j] = arr[j - 1];
}
//退出for循环说明到了带插入元素的位置
arr[left] = insertVal;
}
System.out.println(Arrays.toString(arr));
}
}
3.希尔排序
思想： 先选定一个整数，将待排序数列分组，所有距离为选定整数的元素分为一组，并对每组元素进行排序
实现：
package PreviweSort;
import java.util.Arrays;
public class ShellSort {
public static void main(String[] args) {
int[] arr = {4, 1, 7, 6, 5, 2, 3, 9, 8};
int temp=0;
//grap为分组情况
for (int grap = arr.length/2; grap >0 ; grap=grap/2) {
for (int i = grap; i <arr.length ; i++) {
for (int j = i-grap; j >=0 ; j-=grap) {
if (arr[j]>arr[j+grap]){
temp=arr[j];
arr[j]=arr[j+grap];
arr[j+grap]=temp;
}
}
}
}
System.out.println(Arrays.toString(arr));
}
}
性能分析：
稳定性： 不稳定
4. 选择排序
思想： 每次从无序空间中选择一个最大（最小）的，放在无序空间的最前面（最后面），知道全部待排数据元素全部排列完毕
实现：
package Sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
//选择排序
public class SelectSort {
public static void main(String[] args) {
int[] array={9,4,2,7,1,3,5,8,6};
System.out.println("排序前的数组");
System.out.println(Arrays.toString(array));
//测试时间
Date date1=new Date();
SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
String date1Str=simpleDateFormat.format(date1);
System.out.println("排序前的时间："+date1Str);
selectSort(array);
System.out.println("排序后的数组");
System.out.println(Arrays.toString(array));
Date date2=new Date();
String date2Str=simpleDateFormat.format(date2);
System.out.println("排序后的时间："+date2Str);
}
//选择排序
public static void selectSort(int[] array){
for (int i = 0; i <array.length-1 ; i++) {
/*
* 在排序之前首先假定待排序列的最小值为待排序列的第一个元素
* 说明：选择排序的思想是每一趟找出一个最小的数放在待排序列的第一个位置
* 所以下一次排序是要从最小元素的下一个元素开始选择排序
* 举例：一轮选择排序后的待排序列情况为{}里面的序列 1{4,2,7,9,3,5,8,6}
* */
int minIndex=i;//假定最小元素的索引为待排序列的第一个元素索引
int min=array[i];//假定最小值为待排序列的第一个元素
for (int j = i+1; j <array.length ; j++) {//内层循环一趟找出一个最小的数放在待排序列的第一个位置
if (min>array[j]){//如果待排序列中有比假定最小元素还小的值
min=array[j];//让假定最小元素的值等于小于它的值
minIndex=j;//让假定最小元素的下标等于小于假定最小元素值的下标
}
}
//内层循环结束后后找到待排序列中最小的元素
if (minIndex!=i){//做有意义的交换,如果minIndex!=i说明待排序列中还存在比假定元素还小的值
//进行交换
array[minIndex]=array[i];
array[i]=min;
}
}
//最外层循环结束后就完成了选择排序
}
}
性能分析：
稳定性： 不稳定
5.冒泡排序
思想： 在无序空间中，通过相邻数的比较每次将最大数放到无序空间的最后，直至整数数列有序
实现：
package Sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
//冒泡排序算法时间复杂度：O(n^2),两个for循环;
/*
* 基本思想：通过对待排序序列从前向后（从下标较小的开始），
* 依次比较相邻元素的值，如果发现逆序则交换，使较大的值逐渐向后移动，
* 如果在一趟排序过程没有进行交换过，那么代表序列有序，可以对冒泡排序进行优化，减少不必要的比较
* */
public class BubbleSorting {
public static void main(String[] args) {
int[] array=new int[]{1,5,2,3,9,7,4,8,6,10};
//测试排序时间
Date date1=new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1Str=simpleDateFormat.format(date1);
System.out.println("排序前的时间："+date1Str);
bubbleSort(array);
Date date2=new Date();
String date2Str=simpleDateFormat.format(date2);
System.out.println("排序后的时间："+date2Str);
}
public static void bubbleSort(int[] array){
int count=0;
System.out.println("排序前的数组情况：");
System.out.println(Arrays.toString(array));
for (int i = 0; i <array.length-1; i++) {//外层循环排序趟数,最多进行array.length-1趟排序
//进入排序前先记录待排数组
String str1=Arrays.toString(array);
for (int j = 0; j <array.length-1-i; j++) {//内层循环两两交换
/*
* for (int j = 0; j <array.length-1-i; j++)说明：
* 每趟冒泡排序都能确定一个较大数的位置
* 所以进入下一次排序只需要排上次排序后较大数前所有的元素，所以内层循环每次减一
* */
if (array[j]>array[j+1]){//如果前一个元素大于后一个元素，交换两个元素位置
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
String str2=Arrays.toString(array);//记录排序一趟后的数组情况
if (str2.equals(str1)){//如果一趟排序先后和排序之前数组相等那么就退出循环
break;
}else {//如果不相等，排序次数加一
count++;
}
}
System.out.println("排序后的数组：");
System.out.println(Arrays.toString(array));
System.out.println("排序趟数："+count);
}
}
性能分析：
稳定性： 稳定
6.快速排序
思想：
- 从待排序区间选择一个数，作为基准值(pivot)；
- Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
- 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。
实现：
package search;
import java.util.Arrays;
public class QuickSort {
public static void main(String[] args) {
int[] arr={4,3,4,1,5,9,8,7,6};
arr=quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
public static int[] quickSort(int[] arr,int left,int right){
//取中间值为基准值
int l=left;
int r=right;
int flag=arr[(left+right)/2];
//定义中转值用于交换
int temp=0;
while (l<r){
//在基准值左边找大于基准值的
while (arr[l]<flag){
l++;
}
//在基准值右边找小于基准值的
while (arr[r]>flag){
r--;
}
//寻找完之后要判断l和r的关系
//如果l>r就退出
if (l>=r){
break;
}
//左右交换
temp=arr[r];
arr[r]=arr[l];
arr[l]=temp;
if (arr[l]==flag){
r--;
}
if (arr[r]==flag){
l++;
}
}
//退出最外层while循环说明一次快排结束
if (l==r){
l++;
r--;
}
if (left<r){
quickSort(arr,left,r);
}
if (right>l){
quickSort(arr,l,right);
}
return arr;
}
}
性能分析：
稳定性： 不稳定
7. 归并排序
思想：
实现：
归并排序动画演示转自B站
package Sort;
/*归并*/
import java.util.Arrays;
public class MergeSort {
public static void main(String[] args) {
int[] arr={8,4,5,7,1,3,6,2};
int[] temp=new int[arr.length];
mergeSort(arr,0,arr.length-1,temp);
System.out.println("归并排序后："+Arrays.toString(arr));
}
//分+和
public static void mergeSort(int[] arr,int left,int right,int[] temp){
if (left<right){
int mid=(left+right)/2;//中间索引
//向左递归进行分解
mergeSort(arr, left, mid, temp);
//向右递归进行分解
mergeSort(arr, mid+1, right, temp);
//到合并时
merge(arr, left,mid ,right, temp);
}
}
//合并的方法
/*
* arr排序原始数组
* left左边有序序列的索引
* mid中间索引
* right右边有序序列索引
* temp中转数组
* */
public static void merge(int[] arr,int left,int mid,int right,int[] temp){
int i=left;//初始化i左边有序序列的索引
int j=mid+1;//初始化j右边有序序列索引
int t=0;//指向当前temp数组的当前索引
//以下填充方法就是两个有序数组的合并
//1.先把左右两边数据按规则填充到temp数组中，直到左右两边序列有一边处理完毕
while (i<=mid&&j<=right){//继续
if (arr[i]<=arr[j]){//如果左边序列元素小于右边序列元素，就把左边元素填充到temp中
temp[t]=arr[i];
t++;
i++;
}else {//arr[i]>arr[j]
temp[t]=arr[j];
t++;
j++;
}
}
//2.把有剩余的一边的数据一次全部填充到temp
while (i<=mid){//说明左边的有序序列还有剩余的元素，就全部填充到temp
temp[t]=arr[i];
t++;
i++;
}
while (j<=right){//说明右边的有序序列还有剩余的元素，就全部填充到temp
temp[t]=arr[j];
t++;
j++;
}
//3.将temp数组中的元素拷贝到arr
//并不是每次都拷贝所有的
t=0;
int tempLeft=left;
while (tempLeft<=right){
arr[tempLeft]=temp[t];
t++;
tempLeft++;
}
}
}
性能分析：
稳定性： 稳定
8.堆排序
堆排序总结
1945
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
