Java之常见排序算法（上）

最新推荐文章于 2023-06-30 19:45:37 发布

置顶码农你好

最新推荐文章于 2023-06-30 19:45:37 发布

阅读量125

点赞数 1

分类专栏：算法文章标签：排序算法算法

本文链接：https://blog.csdn.net/qq_41706370/article/details/118078966

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Java实现的排序算法

排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。

一般排序算法分为两大类：

比较类排序和非比较类排序，如图：
在这里插入图片描述

注：本文只介绍比较类排序算法

以下算法基于该数组排序分析

public static void main(String []args){
	int arr[]  = {5,6,8,7,2,9,1,3,4};
}

1.冒泡排序

① 相邻的两个值比较大小，互换位置。
② 记忆口诀：N个数字来排列，两两比较小靠前，外层循环n-1,内层循环n-i-1

代码实现：

public static void sort(int arr[]){
	//外层循环n-1次
	for(int i = 0; i<arr.length-1;i++){
		//内层循环n-i-1次
		for(int j = 0; j<arr.length-i-1;j++){
			//如果前一个比后面的大，交换
			if(arr[j]>arr[j+1]){
				int temp = arr[j+1];
				arr[j+1] = arr[j];
				arr[j] = temp;
			}
		}
	}
}

2.选择排序

① 选择一个元素，让选择依次和后面的元素进行比较，小的向前，大的向后
② 记忆：外层 length - 1 ；同时外层i作为固定值，内层的j = i+1作为其他值的起始

代码实现：

public static void sort(int arr[]){
	//数组长度
	int size = arr.length;
	//外层循环n次
	for(int i = 0; i<size; i++){
		//记录当前i的值
		int k = i;
		for(int j = size-1; j>i; j--){
			if(arr[k]>arr[j]){
				k = j;
			}
		}
		int temp = arr[i];
		arr[i] = arr[k];
		arr[k] = temp;
	}
}

3.插入排序

从第二元素开始，向前找到插入的位置，保证前面的元素都有顺序。

代码实现：

public static void sort(int arr[]){
	//从第二个元素开始遍历
	for(int i=1;i<arr.length;i++){
		//临时存储当前的元素
		int temp = arr[i];
		//定义一个pos指针，指向第i-1个元素
		int pos = i-1;
		while(pos>=0 && arr[pos]>temp){
			arr[pos+1] = arr[pos];
			pos--;
		}
		arr[pos+1] = temp;
	}
}

4.希尔排序

希尔排序，又称“缩小增量排序“，该算法由希尔1959年公布。是直接插入排序算法的一种更高效的改进版本。
效率高：

间隔大，比较次数少，但数据距离长
间隔小，数据距离短，但比较次数多
间隔越小，越接近排序的结果

代码实现：

public static  void shellSort(int arr[]){
        int gap = arr.length;
        while (true){
            gap/=2;
            for (int i = 0; i < gap; i++) {
                for (int j = i+gap; j <arr.length ; j+=gap) {
                    int temp = arr[j];
                    int pos = j-gap;
                    while (pos >= 0 && arr[pos] > temp) {
                        arr[pos + gap] = arr[pos];
                        pos-=gap;
                    }
                    arr[pos+gap] = temp;
                }
            }
            if (gap==1){
                break;
            }
        }
    }

5.归并排序

归并操作的工作原理如下：
第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针超出序列尾
将另一序列剩下的所有元素直接复制到合并序列尾

代码实现：

    public static void main(String[] args) {
        int [] a= {5,6,8,7,2,9,1,3,4};
        aux=new int [a.length];
        sort(a,0,a.length-1);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]+" ");
        }
    }
    //临时数组，借用空间
    private static int [] aux;
    //排序的算法
    private static void sort(int [] a,int lo,int hi) {
        if(hi<=lo) {
            return ;
        }
        int mid=lo+(hi-lo)/2;
        //对左边排序
        sort(a,lo,mid);
        //对右边排序
        sort(a,mid+1,hi);
        //合并两个部分
        merge(a,lo,mid,hi);
    }
    
    //把mid左边和右边归并成一个数组。
    private static void merge(int[] a,int lo,int mid,int hi) {
        int i=lo;
        int j=mid+1;
        for (int k = lo; k <= hi; k++) {
            aux[k]=a[k];
        }
        for (int k=lo;k<=hi;k++) {
            if(i>mid) {
                //如果左边没有元素了，剩下的就全是右边的。
                a[k]=aux[j++];
            }else if(j>hi) {
                //如果右边没有元素了，剩下的就全是左边的。
                a[k]=aux[i++];
            }else if(aux[j]<aux[i]) {
                //如果两边都有元素，且右边的小于左边的
                //我们认为下一个元素应该是用右边的元素
                a[k]=aux[j++];
            }else {
                //如果两边都有元素，且右边的不小于左边的
                //我们认为下一个元素应该是用左边的元素
                a[k]=aux[i++];
            }
        }
    }

6. 快速排序

代码实现：

public static void quickSort(int arr[], int start, int end){
	//当起点大于终点时，直接返回结束
	if(start>end){
		return;
	}
	int i = start;
	int j = end;
	// base中存放基准数
	int base = arr[start];
	//当i和j不相等时
	while(i!=j){
		//顺序很重要，先从后边开始往前找，直到找到比base值小的数
		while(arr[j]>=base && i<j){
			j--;
		}
		//再从左往右边找，直到找到比base值大的数
		while(arr[i]<=base && i<j){
			i++;
		}
		//上面的循环结束表示找到了位置或者(i>=j)了，交换两个数在数组中的位置
		if(i < j){
			int tmp = arr[i];	
			arr[i] = arr[j];
			arr[j] = tmp;
		}
	}
	//将基准数放到中间的位置（基准数归位）
	arr[start] = arr[i];
	arr[i] = base;
	// 递归，继续向基准的左右两边执行和上面同样的操作
    // i的索引处为上面已确定好的基准值的位置，无需再处理
	sort(arr,start,i-1);
	sort(arr,i+1,end);
}

7.堆排序

堆排序，是基于优先队列的，在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。

代码实现：

class MaxPQ<Key extends Comparable<Key>>{
    private Key [] pq;
    private int N=0;
    @SuppressWarnings("unchecked")
    public MaxPQ(int maxN) 
    {
        pq=(Key[])new Comparable[maxN+1];
    }
    public boolean isEmpty() {
        return N==0;
    }
    public int size() {
        return N;
    }
    public void insert(Key v) {
        pq[++N]=v;
        //下沉
        swim(N);
    }
    public Key delMax() {
        Key max=pq[1];
        //和最后一个元素交换位置
        exch(1,N--);
        //删掉这个元素
        pq[N+1]=null;
        //上浮，直到叶子节点
        sink(1);
        //返回删掉的那个最大值
        return max;
    }
    
    //打印
    public void show() {
        for (int i = 1; i < pq.length; i++) {
            System.out.print(pq[i]);
        }
    }
    
    //上浮
    private  void sink (int k) {
        while(2*k<=N) {
            int j=2*k;
            if(j<N&&less(j,j+1)) j++;
            if(!less(k,j))break;
            exch(k,j);
            k=j;
        }
    }
    //下沉
    private  void swim(int k) {
        while(k>1&&less(k/2,k)) {
            exch(k/2,k);
            k=k/2;
        }
    }
    //比较
    private  boolean less(int i,int j) {
        return pq[i].compareTo(pq[j])<0;
    }
    //交换
    private  void exch(int i,int j) {
        Key temp=pq[i];
        pq[i]=pq[j];
        pq[j]=temp;
    }
}

做好优先队列后，就可以把元素都放入队列中，然后再取出即可。

 public static void main(String[] args) {
       int [] a= {5,6,8,7,2,9,1,3,4};
       MaxPQ<Integer> maxPQ=new MaxPQ<Integer>(a.length);
       for (int i = 0; i < a.length; i++) {
           maxPQ.insert(a[i]);
       }
       for (int i = 0; i < a.length; i++) {
           System.out.print(maxPQ.delMax());
       }
 }

下面是以上排序算法的时间和空间复杂度

排序算法	时间复杂度（平均）	时间复杂度（最坏）	时间复杂度（最好）	空间复杂度	稳定性
冒泡排序	$O(n^2)$	$O(n^2)$	$O (n)$	$O (1)$	稳定
选择排序	$O(n^2)$	$O(n^2)$	$O(n^2)$	$O (1)$	不稳定
插入排序	$O(n^2)$	$O(n^2)$	$O (n)$	$O (1)$	稳定
希尔排序	$O(n^2)$	$O(n^2)$	$O (n)$	$O (1)$	不稳定
归并排序	$O(nlog_2n)$	$O(nlog_2n)$	$O(nlog_2n)$	$O (n)$	稳定
快速排序	$O(nlog_2n)$	$O(n^2)$	$O(nlog_2n)$	$O(nlog_2n)$	不稳定
堆排序	$O(nlog_2n)$	$O(nlog_2n)$	$O(nlog_2n)$	$O (1)$	不稳定