常用排序算法

最新推荐文章于 2024-10-22 17:17:53 发布

原创最新推荐文章于 2024-10-22 17:17:53 发布 · 113 阅读

0 ·

CC 4.0 BY-SA版权

Java基础专栏收录该内容

6 篇文章

订阅专栏

博客围绕排序算法的稳定性展开，以数组｛ 6，2，4，6，1｝为例，说明若排序后相同元素原有顺序不变，该排序算法稳定，如冒泡排序；若不能保证原有顺序，则不稳定，如选择排序等。还列举了稳定和不稳定的排序算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

* 排序算法的稳定性：

*拿int[] a=｛ 6，2，4，6，1｝举例。
*如果排序结束后，a[0]可以保证一定在a[3]前头，也就是他们原有的顺序不变，那这种排序算法就是稳定的。（比如常见的冒泡排序 * 排序算法的稳定性：
*如果不能保证原有顺序，这种算法就是不稳定的。（比如常见的选择排序，希尔排序，堆排序，快速排序等都是不稳定的排序算法）、基数排序、插入排序、归并排序、桶排序、二叉树排序等都是稳定的排序算法

	/**
	* 冒泡排序
	* 比较相邻的元素。如果第一个比第二个大，就交换他们两个。  
	* 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。      
	* 针对所有的元素重复以上的步骤，除了最后一个。
	* 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 
	* @param numbers 需要排序的整型数组
    * 低效 简单
	*/
    public static void bubbleSort(int[] numbers){
    	int length=numbers.length;
    	int tempNum=0;
    	for (int i = 0; i < length-1; i++) {
			for (int j = 0; j < length-1-i; j++) {
				if(numbers[j]<numbers[j+1]){
					tempNum=numbers[j];
					numbers[j]=numbers[j+1];
					numbers[j+1]=tempNum;
				}
			}
		}
    }

	/*
	*
	*二分查找
	*
	*/		
	public static int bubbleSort(int a[], int tag) {

		int first = 0;

		int end = a.length;

		for (int i = 0; i < a.length; i++) {

			int middle = (first + end) / 2;

			if (tag == a[middle]) {

				return middle;

			}

			if (tag > a[middle]) {

				first = middle + 1;

			}

			if (tag < a[middle]) {

				end = middle - 1;

			}

		}

		return 0;

	}

	/*
	*
	*快速排序（http://developer.51cto.com/art/201403/430986.htm）
	*
	*/		
	static void quick_sort(int s[], int l, int r) {
		if (l < r) {
			// Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
			int i = l, j = r, x = s[l];
			while (i < j) {
				while (i < j && s[j] >= x) {
					j--;
				} // 从右向左找第一个小于x的数

				if (i < j) {
					s[i++] = s[j];
				}
				while (i < j && s[i] < x) {
					i++;
				} // 从左向右找第一个大于等于x的数
				if (i < j) {
					s[j--] = s[i];
				}
			}
			s[i] = x;
			quick_sort(s, l, i - 1); // 递归调用
			quick_sort(s, i + 1, r);
		}

	}

	/*
	*
	*选择排序
	*选择排序也是一种简单直观的排序算法。它的工作原理很容易理解：初始时在序列中找到最小（大）元素，放到序列的起始位置作为已排序序列；
	*		然后，再从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
	*
	*注意选择排序与冒泡排序的区别：
	*		冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；而选择排序每遍历一次都记住了当前
	*		最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。
	*/			
	static void SelectionSort(int[] arr) {
		    int len = arr.length;
		    int minIndex, temp;
		    for (int i = 0; i < len - 1; i++) {
		        minIndex = i;                         //每次都从已排序序列的末尾后一位开始
		        for (int j = i + 1; j < len; j++) {
		            if (arr[j] < arr[minIndex]) {     //寻找最小的数
		                minIndex = j;                 //将最小数的索引保存
		            }
		        }
		        
		       //放到已排序序列的末尾(即交换)，该操作很有可能把稳定性打乱，所以选择排序是不稳定的排序算法
		        temp = arr[i];  
		        arr[i] = arr[minIndex];
		        arr[minIndex] = temp;
		    }
	}