闲暇之余有必要再回顾一下经典排序，理一理哈。

最新推荐文章于 2024-11-11 23:45:00 发布

阿狸卡

最新推荐文章于 2024-11-11 23:45:00 发布

阅读量627

点赞数

分类专栏：数据结构与算法文章标签：排序算法数据结构

本文链接：https://blog.csdn.net/kakingka/article/details/45131987

版权

数据结构与算法专栏收录该内容

0 篇文章 0 订阅

订阅专栏

冒泡排序：它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。代码中（flag标志是为了当遍历一遍没有比较就结束冒泡标志，而last则是为了第i趟中从前面n-i个元素进行冒泡）当然还有更好的冒泡排序-鸡尾酒排序，大家可以百度一下哈吐舌头

package 排序方法;

import java.util.Scanner;

public class SelectBubble {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			int count = sc.nextInt();
			int num[] = new int[count];
			for (int i = 0; i < count; i++) {
				num[i] = sc.nextInt();
			}
			sort(num);
			for (int i : num) {
				System.out.print(i + ",");
			}
		}
	}

	public static int[] sort(int[] num) {

		int temp;
		boolean flag;
		int last = num.length-1;
		for (int i = 0; i < num.length; i++) {
			flag=true;
			for (int j = 0; j <last ; j++) {
				if (num[j] > num[j+1]) {
					// 交换
					temp = num[j];
					num[j] = num[j + 1];
					num[j + 1] = temp;
					flag = false;
				}
			}
			if (flag)break;
			last--;
		}
		return num;

	}

}

=================================================================================================================================
插入排序：第i趟排序将序列中第i+1个元素K_i+1插入到一个已经按值有序的子序列（K₁，K₂...K_i）中的合适的位置，使得插入后的序列仍然保持按值有序。（注意标志位从已排好的序列最后往前寻找）

package 排序方法;
import java.util.Scanner;
public class SelectInsert {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
       	 int count = sc.nextInt();
       	 int num[] = new int[count];
       	 for(int i=0;i<count;i++){
       		 num[i]=sc.nextInt();
       	 }
         sort(num);
         for(int i:num){
       	  System.out.print(i+",");
         }
        }

	}
	public static int[] sort(int[] num){
		int i,j,temp;
		for(i =1;i<num.length;i++){
			 temp =num[i];
			//j>=0&&temp<num[j]若为假则跳出循环语句 连j--都不执行！
			for(j=i-1;j>=0&&temp<num[j];j--){
					num[j+1]=num[j];
			}
			//最后j指针停留在比他小的数据
			num[j+1]=temp;
		}
		return num;
	}
}

=====================================================================================================================================
选择排序：第i趟排序从序列的后n-i+1(i=1,2...n-1)个元素中选择一个最小或最大的元素，与该n-i+1个元素的最前面那个元素进行位置交换，直到i=n-1（每一趟的选择排序就是从序列中未排序的元素中选择一个最小或最大的元素，将该元素与未排序元素的第一个元素交换位置）说白了就是每次从剩余数组中选择一个最小的。

package 排序方法;
import java.util.Scanner;
public class SelectSort {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
         while(sc.hasNext()){
        	 int count = sc.nextInt();
        	 int num[] = new int[count];
        	 for(int i=0;i<count;i++){
        		 num[i]=sc.nextInt();
        	 }
          sort(num);
          for(int i:num){
        	  System.out.print(i+",");
          }
         }
	}
	public static int[] sort(int[] num){
		for(int i=0;i<num.length;i++){
			int min=num[i];
			int temp =i;
			//找出最小值
			for(int j =i+1;j<num.length;j++){
				 if(min>num[j]){
					 min=num[j];
					 temp=j;
				 }
			}
			//交换
			num[temp]=num[i];
			num[i]=min;
		}
		return num;
	}
}

======================================================================================================================================

快速排序：在当前的排序序列(K₁，K_2......K_n)中任意选取一个元素，把该元素称为基准元素或支点，把小于等于基准元素的所有元素都移动到基准元素的前面，把大于基准元素的所有元素都移动到基准元素的后面，这样使得基准元素的位置正好处于排序后的最终位置，并且把当前参加排序的序列分为前后两个子序列，接下来分别对这两个子序列重复上述操作，直至子序列长度为1。（是冒泡排序的改进，此方法采用分治思想。当然基准元素也可以选择middle元素），当然重复操作我们采用递归方法，这样代码更加简洁。最后注意一下j和i的位置

package 排序方法;
import java.util.Scanner;
public class SelectQuick {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			int count = sc.nextInt();
			int num[] = new int[count];
			for (int i = 0; i < count; i++) {
				num[i] = sc.nextInt();
			}
			sort(num,0,count);
			for (int i : num) {
				System.out.print(i + ",");
			}
		}
	}
	public static void sort(int[] num,int left,int right) {
		int k;
		if(left<right)
		{
			k=Part(num,left,right);
			sort(num,left,k-1);
			sort(num,k+1,right);
		}
		
	}
	public static int Part(int [] num,int left,int right){
		
		int i=left,j=right;
		int zhou= num[left];
		int temp;
		do{
			do i++;while(i<j&&num[i]<zhou);//找到>=zhou的数
			do j--;while(num[j]>zhou);//找到<=zhou的数
			//交换 i,j
			if(i<j){
				temp =num[i];
				num[i]=num[j];
				num[j]=temp;
			}
		}while(i<j);
			//将轴与j兑换
	    num[left]=num[j];
		num[j]=zhou;
		return j;//返回中轴位置
	}
}

===================================================================================================================

归并排序：是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。我们用递归将数组逐步二分成单个数据的数组，然后不断合并数组，这里牵涉到两个有序数组合合并成有序数组问题，可以分别用两个指针指向两个数组，比较a[i]和b[j] ，谁小谁指针++，并将小的放入临时数组。如此往下。

package 排序方法;
import java.util.Scanner;
public class SelectMerge {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
       	 int count = sc.nextInt();
       	 int num[] = new int[count];
       	 for(int i=0;i<count;i++){
       		 num[i]=sc.nextInt();
       	 }
       	 sort(num,0,count-1);
         for(int i:num){
       	  System.out.print(i+",");
          }
        }
	}
	public static void sort(int[] num,int left,int right){
		if(left<right){
		int mid = (left+right)/2;
		sort(num,left,mid);
		sort(num,mid+1,right);
		//将left和right合并
		Merge(num,left,mid,right);
		}
		  
	}
	//将两个排好序的子串 合并成一个整串
	public static void Merge(int[] num,int left,int mid,int right){
		int i=left,j=mid+1;
		int m=0;
		int temp[] =new int[right-left+1];
		//等长度部分处理
		while((i<=mid)&&(j<=right)){
			if(num[i]<num[j]){
			   temp[m]=num[i];
			   i++;
		     }
			else{
				temp[m]=num[j];
				j++;
			}
			m++;
		}
		//余长处理
		while(i<=mid){
				temp[m++]=num[i++];
		}
		while(j<=right){
			    temp[m++]=num[j++];
		}
		//将temp排序好的复制到num中区
		int n=0;
		for(int x=left;x<=right;x++){
			num[x]=temp[n++];
		}
	}
}

============================================================================================================================

堆排序：堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。（堆排序分为两个操作：（1）初始序列建堆（大根堆或者小根堆）操作（2）剔除到最小或者最大元素然后堆调整）

建堆过程_小顶堆（[49,38,65,97,76,13,27,49]也就是 i节点和2i+1和2i+2 比较，进行不断调整。如果有次不用调整了，则建堆完成，一般是从n/2个节点往前面调整，因为这个节点的孩子就是整个数组的最后一个）

调整堆的过程_小顶堆（根元素（最小）与最后一个元素交换，输出最后一个元素，然后对前面n-1个元素进行堆调整。重复（n-1）次操作）

package 排序方法;
import java.util.Scanner;
public class SelectDui {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while (sc.hasNext()) {
			int count = sc.nextInt();
			int num[] = new int[count];
			for (int i = 0; i < count; i++) {
				num[i] = sc.nextInt();
			}
			JianDui(num, 0, count - 1);
		}
	}

	// 建最小堆语句 {16 4 10 14 7 9 3 2 8 1}
	public static void JianDui(int num[], int left, int right) {
		int l = right + 1;
		int i = left;
		int temp;
		boolean flag = true;
		//这个循环最坏时间为logn
		while (i <= (left + right) / 2) {
			// 将最小的数字放到根节点
			if ((2 * i + 1 < l) && (num[i] > num[2 * i + 1])) {
				temp = num[i];
				num[i] = num[2 * i + 1];
				num[2 * i + 1] = temp;
				flag = false;
			}
			if ((2 * i + 2 < l) && (num[i] > num[2 * i + 2])) {
				temp = num[i];
				num[i] = num[2 * i + 2];
				num[2 * i + 2] = temp;
				flag = false;
			}
			i++;
		}
		// 没有排好继续排	//这个递归至多n次 故建堆操作最坏时间复杂度为（nlogn）
		if (!flag)JianDui(num, left, right);
		//正规方法 不需要多余辅助空间
	    // 正规方法：输出堆顶元素，然后将堆顶元素与最后一个元素兑换，减掉最后一个元素，对前一段进行从上等到下调整
		// 没输出一个元素又要调整堆，故复杂度仍然nlogn;
		else{
			System.out.print(num[left]+",");
			//交换到末尾
			if(right>=1){
			int temp1= num[left];
			num[left]=num[right];
			num[right]=temp1;
			JianDui(num, 0,--right);
			}
		}
	}
}

=====================================================================================================================

好啦，还有一些排序方法时间问题就不罗列了，最后我们来看下算法的复杂度比较。