java 快速排序时间复杂度怎么算 java排序的时间复杂度

一、插入排序
1.1 直接插入排序

基本思想

将一个记录插入到已排好序的序列中，从而得到一个新的有序序列（将序列的第一个数据看成是一个有序的子序列，然后从第二个记录逐个向该有序的子序列进行有序的插入，直至整个序列有序）

重点：使用哨兵，用于临时存储和判断数组边界。

        空间复杂度：O(1)。

        时间复杂度：O(n^2)。在最好情况下，表中元素已经有序，此时每插入一个元素，都只需要比较一次而不用移动元素，因此时间复杂度为O(n^2)。

        稳定性：每次插入元素时总是从后向前先比较再移动，所以不会出现相同元素相对位置发生变化的情况。即直接插入排序是一个稳定的排序方法。

流程图

算法实现

public class Sort {

    public static void main(String[] args) {

        int arr[] = {2,1,5,3,6,4,9,8,7};

        int temp;

        for (int i=1;i<arr.length;i++){

            //待排元素小于有序序列的最后一个元素时，向前插入
            if (arr[i]<arr[i-1]){
// 假设某时序列 {4,5,6,7} ,下个待插入元素1
                temp = arr[i];
                for (int j=i;j>=0;j--){
                    if (j>0 && arr[j-1]>temp) {
                        arr[j]=arr[j-1];
                    }else {
                        arr[j]=temp;
                        break;
                    }
                }
            }
        }

        System.out.println(Arrays.toString(arr));

    }


}

 

1.2 希尔排序

直接插入排序存在的问题：
当后面插入的数较小的话，前面排好序的元素后移的次数会明显的增多，对效率有影响。

希尔排序：

在直接插入排序的基础上进行改进，也称为缩小增量排序。

基本思想：

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减少至1时，整个元素集合被分成一组，算法便终止。
 

    空间复杂度：O(1)。

   时间复杂度：当n在某个特定范围时，希尔排序的时间复杂度约为O(n^1.3)。在最坏情况下希尔排序排序的时间复杂度为O(n^2)。

   稳定性：当相同关键字的记录被划分到不同的子表时，可能会改变他们之间的相对次序，因此希尔排序是一个不稳定的排序方法。

动态图解：

算法实现

import java.util.Scanner;

public class Shell_sort {

//希尔排序是非稳定的排序算法

//基本思想：
//先取一个小于n的整数d1作为第一个增量，把所有数据分组。所有距离为d1的倍数的记录放在同一个分组中。先在各组内进行直接插入排序；
//然后，取第二个增量d2<d1重复上述的分组和排序。直至所取的增量d=1，即所有记录放在同一组中进行直接插入排序为止
//一般的初次取序列的一半为增量，以后每次减半，直到增量为1

public static void main(String[] args) {
	// TODO Auto-generated method stub
	System.out.println("请输入数组的大小：");
	Scanner input = new Scanner(System.in);
	int a = input.nextInt();
	int [] arr = new int[a];
	for(int i = 0;i<arr.length;i++) {
		System.out.println("请输入数组的第"+i+"个值：");
		int s = input.nextInt();
		arr[i] = s;
	}
	arr = HillSort(arr);
	for(int i = 0;i<arr.length;i++)
	System.out.print(" "+arr[i]+" ");
}
public static int[] HillSort(int[] arr) {
	//单独将数组的长度拿出来，提高效率
	int length = arr.length;
	//截取的长度不为1则一直计算
	while(length!=0) {
		//取整,相当于每组的元素个数
		length = length/2;
		//每组有多少个元素，就循环几次
		for(int i =0;i<length;i++) {
			int tem = arr[i];
			//对元素进行分组
			for(int j = i+length;j<arr.length;j+=length) {
				//k的值为每组最后一个数值的数组下标。
				int k = j-length;
				//将每个要插入进来的数赋给中间变量
				int temp = arr[j];
				//将这个数进行比较，如果小于已排好序的这个数组，那么数组的位置就往后移
				while(k>=0&&temp<arr[k]) {
					//对应元素后移
					arr[k+length] = arr[k];
					//对应下标前移
					k-= length;
				}
				//找到不小于已排好序的数组中的元素的位置，将其插入
				arr[k+length] = temp;
			}
		}
	}
	return arr;
	
	}
}