主要的排序算法——Java实现

最新推荐文章于 2025-01-16 13:37:12 发布
原创 最新推荐文章于 2025-01-16 13:37:12 发布 · 303 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #代码 #算法 #java #排序算法 

package cn.leilei.algorithm;

public class Sort {
	
	/**
	 * 内部排序算法
	 * 插入排序类：直接插入排序，希尔排序
	 * 选择排序类：选择排序，堆排序
	 * 交换排序类：冒泡排序，快速排序
	 * 归并排序
	 */
	
	
	
	/**
	 * 交换数组中的两个元素
	 * 方法名：swap<BR>
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a
	 * @param i
	 * @param j
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void swap(int[] a,int i,int j){
		int t;
		
		t=a[i];
		a[i]=a[j];
		a[j]=t;
	}
	
	
	
	/****************稳定的*****************/
	
	
	
	/**
	 * 基本冒泡排序 
	 * 方法名：bubbleSort<BR>
	 * 时间复杂度： O(n^2）
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void bubbleSort(int[] a){
		
		for(int i=a.length-1; i > 0 ; i--){
			
			for(int j=0; j < i ;j++){
				
				if(a[j] > a[j+1])
					swap(a,j,j+1);
				
			}
		}
	}
	
	
	
	/**
	 * 改进冒泡排序 （不做无用功）
	 * 方法名：bubbleSortII<BR>
	 * 时间复杂度： O(n^2）
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void bubbleSortII(int[] a){
		
		boolean flag=false;
		
		for(int i=0; i < a.length-1&&!flag ; i++){//只有在没有排序的情况下，才继续循环
			
			flag=true;//设定排序标志
			
			for(int j=0; j < a.length-1-i ;j++){
				
				if(a[j] > a[j+1]){
					
					flag=false;//如果是没有排序，就重新设定标志
					
					swap(a,j,j+1);
				}
			}
		}
		
	}
	
	
	
	/**
	 * 改进冒泡排序 （记录犯罪现场）
	 * 方法名：bubbleSortIII<BR>
	 * 时间复杂度： O(n^2）
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void bubbleSortIII(int[] a){
		
		int m=a.length-1;
		
		int k,j;
		
		while(m>0){
			
			for(k=0,j=0;j < m;j++){
				
				if(a[j] > a[j+1]){
					swap(a,j,j+1);
					k = j;//记录交换位置
				}
				
			}
			m = k;//记录最后一个交换的位置
		}
		
	}
	
	
	
	/**
	 * 鸡尾酒排序  (双向的冒泡排序)
	 * 方法名：cocktailSort<BR>
	 * 时间复杂度： O(n^2）
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void cocktailSort(int[] a){
	    
	    for(int i = 0 ; i < a.length/2 ; i++){
	    	//将最小值排到队头
	        for(int j = i ; j < a.length-i-1 ; j++){
	        	
	            if(a[j] > a[j+1])
	            	swap(a,j,j+1);
	            
	        }
	        //将最大值排到队尾
	        for(int j = a.length-1-(i+1); j > i ; j--){
	        	
	            if(a[j] < a[j-1])
	            	swap(a,j,j+1);
	            
	        }
	    }
	    
	}
	
	
	
	
	/**
	 * 直接插入排序
	 * 方法名：insertSort<BR>
	 * 时间复杂度： O(n^2）
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void insertSort(int[] a){
		
		int i,j;
		
		for (i = 1; i < a.length; i++) {
			
			if(a[i] < a[i-1]){
				
				int temp=a[i];//待插入元素
				
				for (j = i-1; j>=0 && a[j]>temp; j--) {
					
					a[j+1]=a[j];//将大于temp的往后挪一位
					
				}
				
				a[j+1]=temp;
			}
		}
	}
	
	
	
	/**
	 * 归并排序(递归型)
	 * 方法名：mergeSort<BR>
	 * 时间复杂度： O(nlogn）
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a:待排序数组
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void mergeSort(int[] a){
		
		int[] temp=new int[200];   //临时数组存放排序结果
		
		merge_Sort(a,temp,0,a.length-1);
		
	} 
	
	public static void merge_Sort(int[] a,int[] temp, int first, int last){
		
		if(first == last) //递归结束条件：当分组后只有一个数据时，表示有序，递归结束
			
			temp[first]=a[first];
		
		else{
			
			int mid=(first+last)/2;//分组
			
			merge_Sort(a,temp,first,mid);//递归将左边归并为有序
			merge_Sort(a,temp,mid+1,last);//递归将右边归并为有序
			mergeDo(a,temp,first,mid,last);//合并有序序列
		}
		
	}
	
	public static void mergeDo(int[] a, int[] temp,int first, int mid, int last){
		
		int i=first,j=mid+1;
		int m=mid,n=last;
		int k=0;
		
		while(i<=m && j<=n){
			
			if(a[i] <= a[j])//依次比较两个序列的数，谁小取谁，将a中数据从小到大并入temp中
				temp[k++] = a[i++];
			else
				temp[k++] = a[j++];
			
		}
		
		while(i <= m) //将剩余的a[i..m]并入到temp中
			temp[k++] = a[i++];
		
		while(j <= n) //将剩余的a[j..n]并入到temp中
			temp[k++] = a[j++];
		
		for(i=0;i<k;i++) //最后将合并后数组temp复制给a
			a[first+i] = temp[i];
		
	}
	
	
	
	/**
	 * 归并排序(非递归型)
	 * 方法名：mergeSortII<BR>
	 * 时间复杂度： O(nlogn）
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a:待排序数组
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void mergeSortII(int[] a){
		
		int[] temp=new int[200];   //临时数组存放排序结果
		
		for(int k=1;k < a.length;k = 2*k)
			merge_SortII(a,temp,k,a.length);//将a中相邻长度为k的子序列两两归并
		
	}
	
	public static void merge_SortII(int[] a, int[] temp,int s,int n){
		//s:子序列长度,n:数组大小
		int i;
		
		for(i=0;i <= n-2*s;i+=2*s)
			mergeDo(a,temp,i,i+s-1,i+2*s-1);//两两归并
		
		if(i<n-s)//归并剩下的最后两个序列（数组可能不会正好被平分）
			mergeDo(a,temp,i,i+s-1,n-1);
		
	}
	
	
	
	/**
	 * 基数排序
	 * 方法名：radixSort<BR>
	 * 时间复杂度： O(n^k）
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void radixSort(int[] a, int d){ //d表示最大的数有多少位

        int k = 0;
        int n = 1;
        int m = 1; //控制键值排序依据在哪一位
        
        int[][] temp = new int[10][a.length]; //数组的第一维表示可能的余数0-9
        int[] order = new int[10]; //数组orderp[i]用来表示该位是i的数的个数
        while(m <= d)
        {
            for(int i = 0; i < a.length; i++)
            {
                int lsd = ((a[i] / n) % 10);
                temp[lsd][order[lsd]] = a[i];
                order[lsd]++;
            }
            for(int i = 0; i < 10; i++)
            {
                if(order[i] != 0)
                    for(int j = 0; j < order[i]; j++)
                    {
                        a[k] = temp[i][j];
                        k++;
                    }
                order[i] = 0;
            }
            n *= 10;
            k = 0;
            m++;
        }
    }
	
	
	
	
	/****************不稳定的*****************/
	
	

	/**
	 * 选择排序
	 * 方法名：selectSort<BR>
	 * 时间复杂度： O(n^2）
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void selectSort(int[] a){
		
		for (int i = 0; i < a.length-1; i++) {
			
			int min=i;//将当前下标定义为最小值下标
			
			for (int j = i+1; j < a.length; j++) {
				
				if(a[j] < a[min])//如果有小于当前最小值的数据
					min = j;//将此下标赋给min
				
			}
			
			if(min != i)
				swap(a,i,min);//若找到最小值则交换数据
			
		}
	}
	
	
	
	/**
	 * 希尔排序 
	 * 方法名：shellSort<BR>
	 * 时间复杂度： O(n^2）
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void shellSort(int[] a){
		
		int i,j;
		int gap=a.length;
		
		do{
			gap=gap/3 + 1;//增量
			
			for (i = gap; i < a.length; i++) {//分组进行直接插入排序
				
				if(a[i] < a[i-gap]){
					
					int temp=a[i];
					
					for (j = i-gap;  j>=0 && a[j] > temp; j-=gap) {
						a[j+gap]=a[j];
					}
					
					a[j+gap]=temp;
				}
			}
			
		}while(gap > 1);//直到增量为1结束
		
	}
	
	
		
	/**
	 * 堆排序
	 * 方法名：heapSort<BR>
	 * 时间复杂度： O(nlogn）
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void heapSort(int[] a){  
		
		int n=a.length;
		
		for(int i=n/2-1;i >= 0;i--){//将数组a构建成大顶堆
			
			sift_down(a,i,n-1);
			
		}   
		
		for(int i=n-1 ;i > 0;i--){

			swap(a,0,i);//将堆顶数据与当前未排序子序列的最后一个数据交换
			sift_down(a,0,i-1);//将a[0..i-1]调整为大顶堆
		}
		
	}
	
	public static void sift_down(int a[],int x,int y){  
		
		int temp=a[x];
		
		for(int j=2*x+1;j<=y ;j=2*j+1){//从上向下，从左到右，将每个非叶结点及其子树调整为大顶堆
		
			if(j < y && a[j] < a[j+1])
				j++; 			//用j标记左右子树中的较大值
			if(temp >= a[j]) 	//若根节点大于左右子树，则跳出
				break;
			
			a[x]=a[j];		//若根节点小于左右子树，则跟较大值交换
			x=j;
		}
		
		a[x]=temp;	// 交换数据
		
	}
	
	
	
	
	/**
	 * 快速排序(优化枢轴值)
	 * 方法名：quickSort<BR>
	 * 时间复杂度： O(n^2）
	 * 创建人：潭州学院-liuchao <BR>
	 * 时间：2015年8月22日-下午10:03:19 <BR>
	 * @param a:待排序数组
	 * @return void<BR>
	 * @exception <BR>
	 * @since  1.0.0
	 */
	public static void quickSort(int[] a){
		
		quick_Sort(a,0,a.length-1);
	}
	
	public static void quick_Sort(int[] a, int low, int high){
		
		if(low < high){
			
			int point = partition(a,low,high);// 找到枢轴记录的下标
			quick_Sort(a,low,point-1);// 对低子表进行递归排序
			quick_Sort(a,point+1,high);// 对高子表进行递归排序
			
		}
	}
	
	public static int partition(int[] a,int low,int high){
		
		if (low < high){
	
			int mid = (low + high)/2;
			
			if(a[low] > a[high])	swap(a,low,high);//交换左端与右端的记录，保证左端较小
			if(a[mid] > a[high])	swap(a,mid,high);//交换中间与右端的记录，保证中间较小
			if(a[mid] > a[low])		swap(a,mid,low);//交换左端与中间的记录，保证左端较小 
		}
		
		int temp=a[low];// 将三取一后的中间值作为枢轴记录
		
		while(low < high){
			
			while(low<high && a[high]>=temp)	high--;
			
			swap(a,low,high);// 把比枢轴记录小的值交换到低端 
			
			while(low<high && a[low]<=temp)	low++;
			
			swap(a,low,high);// 把比枢轴记录大的值交换到高端 
			
		}
		return low;// 返回枢轴记录的下标
	}
	

	
	
	
}

经典排序算法——堆排序——Java实现及算法解析
weixin_48610702的博客
04-04 450
堆排序——Java代码实现及算法解析一、前言1. 什么是堆？2. 堆排序的概念二、堆排序的Java代码实现1. 算法思想2. Java代码解析2. 完整代码总结 一、前言 1. 什么是堆？ 堆是一种重要的数据结构，它是一种完全二叉树。堆分为最大堆和最小堆，最大堆任意子树根节点不小于任意子结点，即每一个父节点一定大于其两个左右子节点；最小堆则与之相反，最小堆的根节点不大于任意子结点。底层如果用数组存储数据的话，假设某个元素为序号为 i (Java数组从0开始，i为0到n-1)，如果它有左子树，那么左子树的位
约瑟夫环问题(顺序表)——C++实现
liurry爱是不是不开口才珍贵
10-12 5722
#include #include #define MAXSIZE 100//人数上限 using namespace std; typedef int DataType; typedef struct{ DataType data[MAXSIZE];//存放编号的数组 int length; //人数 }SeqList,* PSeqList; int main(){ /*函数声明*/
十大经典排序算法——java语言
weixin_56781779的博客
11-11 6869
一、冒泡排序 二、选择排序 三、插入排序 四、希尔排序 五、归并排序 六、快速排序 七、堆排序 八、计数排序 九、桶排序 十、基数排序
java实现10种排序算法
热门推荐
weixin_622464的博客
05-06 7万+
1.冒泡排序(Bubble Sort) import java.util.Arrays; //冒泡排序 public class BubbleSort_01 { public static void main(String[] args) { int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48}; //记录比较次数 int count=0; //i=0,第一轮比较 for (int i = 0; i < a.length-1; i
快速排序算法——Java实现
PlanetWalker的博客
01-09 638
快速排序算法——Java实现 某公司第三轮面试，被要求手撕快速排序算法，当时因为没有准备，对算法这块忘记的比较多，所以当场蒙圈，回去后仔细研究了各种排序算法，以下是快排的代码。在这里插入代码片 package com.jin.controller; import java.util.Scanner; public class QuickSort { public static void...
十大排序算法之——快速排序算法（Java实现）及思路讲解
一叶浮萍归大海的博客
04-24 1591
快速排序是一种非常高效的排序算法，其平均时间复杂度为O(n log n)，并且由于原地排序的特性，它不需要额外的存储空间。快速排序的基本思想是：通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。另外，快速排序的空间复杂度是O(log n)，这是因为递归调用需要使用栈空间，栈的深度在最坏情况下是O(n)，但平均情况下是O(log n)。
选择排序——Java排序算法
qq_45263520的博客
03-12 605
选择排序 选择排序（SelectSort）选择排序是所有排序中最简单的排序算法之一，同时也是要求我们必须掌握的排序算法之一。 时间复杂度 选择排序的时间复杂度为(n2) 算法步骤 1.在未排序的序列中找到最小或者最大的元素，存放到排序序列的起始位置 2.再从余下的元素中继续找到最小或者最大的元素，放到以及排序好的序列末尾 3.重复第二步，知道所有的元素排序完成 算法图解 实现代码 package com.qf.pra; import java.util.Arrays; /** * @author:
Java排序算法——插入排序
LeeCM0715的博客
08-09 1178
Java排序算法——插入排序（Insertion Sort） 传送门 冒泡排序 选择排序 简述 插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 算法描述（设有n个元素） 构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 第一轮排序时，第二个元素和第一个元素进行排序。 第二轮排序时，第三个元素从第二个元素开始比较，往前走，找到自己的位置，并插入。 … 一共进
十大排序算法（Java实现）
ji_meng的博客
06-27 4423
1.冒泡排序 2.快速排序
Java排序算法——选择排序
LeeCM0715的博客
08-09 1155
Java排序算法——选择排序（Selection sort） 传送门 冒泡排序 插入排序 简述 选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 算法描述（设有n个元素） 从第一个元素开始，比较所有未排序的元素，并标记最小（大）元素，将最小（大）元素与未排序的第一个元素进行交换。 第一轮排序时
算法——归并排序（基本思想、java实现、实现图解）
最新发布
weixin_64451672的博客
01-16 2231
归并排序介绍、思想、步骤、java实现和实现图解算法分析
七大排序算法——快速排序，通俗易懂的思路讲解与图解(完整Java代码)
The_emperoor_man的博客
07-14 4850
本文介绍的是七大算法排序中的快速排序，用大白话讲解，配有图解与完整代码(内含注释)，还实现了对快速排序代码的优化。快进来轻松学会快速排序。
10大排序算法——01冒泡排序（Java实现）
12-21
冒泡排序（Bubble Sort） 冒泡排序也叫起泡排序 冒泡排序的执行流程 1.从头开始比较每一对相邻元素，如果第一个比第二个大，就交换他们的位置。（执行完第一轮，最后的那个元素就是最大的元素） 2.忽略从步骤1中找到...
选择排序——Java实现
01-20
算法实现原理 1、选取出 n 条记录中最小的记录与第一条记录进行交换 —— 循环的第一趟 2、选取出除第一条记录以外的 n-1 条记录中最小的记录与第二条记录进行交换 —— 循环的第二趟 3、以此类推直到整个数组全部...
最快的排序算法 图解八大排序算法——我见过的最详细的讲解（转），排序算法数据结构
04-07
排序算法综述 排列算法是计算机科学中的一种基本算法，用于对数据进行排序。常见的排序算法有八种，即选择排序、冒泡排序、插入排序、归并排序、快速排序、堆排序、.radix 排序和基数排序。 一、分类 内部排序和...
单链表的复制——C++实现
liurry爱是不是不开口才珍贵
10-12 4455
#include #include using namespace std; typedef int DataType; /*定义链表数据结构*/ typedef struct node{ DataType data; struct node * next; }LNode,* LinkList; int main(){ /*函数声明*/ LinkList Tail_Create_Li
农夫过河问题（图的邻接矩阵）
liurry爱是不是不开口才珍贵
11-12 2941
/******************************************************************************* *农夫过河问题(图的邻接矩阵存储，深度优先遍历)： * *一个农夫带着一只羊、一只狼、和一颗白菜过河（左岸->右岸）； * *河边只有一条船，由于船太小，只能装下农夫和他的一样东西； * *
哈密尔顿回路问题
liurry爱是不是不开口才珍贵
10-13 2090
/*******************************************************/ /* 哈密尔顿回路问题 */ /*从一个顶点出发，经过每个顶点恰好一次，然后回到出发点 */ /*******************************************************/ #
顺序表求集合交并——C++实现
liurry爱是不是不开口才珍贵
10-12 2044
#include #include #define MAXSIZE 100//顺序表长度上限 using namespace std; typedef int DataType; typedef struct{ DataType data[MAXSIZE];//顺序表存储结构 int length;//顺序表长度 }SeqList,* PSeqList; int main(){ /*函数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值