各种排序

最新推荐文章于 2024-05-05 13:57:09 发布
最新推荐文章于 2024-05-05 13:57:09 发布
阅读量1.1k 收藏
点赞数
文章标签： 数据结构和算法 排序 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jackwang_378/article/details/8823318
版权

在看算法导论，把学习过程中的一些东西记录下来吧！


1）选择排序

/**
 *Apr 18, 2013
 *Copyright(c)JackWang
 *All rights reserve
 *@Author <a href="mailto:wangchengjack@163.com">JackWang</a>
 */
package com.example.sort;

/**
 * 选择排序 
 * 每次选择数组中最小的元素放在排序的位置，遍历之后即排好了序
 * 
 * @author Administrator
 * 
 */

public class Selection_Sort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] a = { 41, 4, 78, 5, 14, 56, 4, 74, 120, 103, 51 };
		a = Select_Sort(a);
		for (int i : a) {
			System.out.print(i + " ");
		}

	}

	public static int[] Select_Sort(int[] a) {
		for (int i = 0; i < a.length; i++) {
			int k = i;   //记录最小元素脚标，每趟找出最小脚标后交换位置
			for (int j = i + 1; j < a.length; j++) {
				if (a[k] > a[j]) {
					k = j;
				}

			}
			if (k != i) {
				int temp = a[i];
				a[i] = a[k];
				a[k] = temp;
			}
		}
		return a;
	}

}

2）插入排序

/**
 *Apr 18, 2013
 *Copyright(c)JackWang
 *All rights reserve
 *@Author <a href="mailto:wangchengjack@163.com">JackWang</a>
*/
package com.example.sort;
/**
 * 插入排序
 * 遍历要排序的数组，每一次把一个元素插入到已经排
 * 好序的子数组中，遍历到最后一个元素时即把整个数
 * 组排好了序
 * 时间开销 O(n^2)
 * 空间开销O(n)
 * 稳定的
 * @author Administrator
 *
 */

public class Insertion_Sort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] a = {41,4,78,5,14,56,4,74,120,103,51};
		a = Insert_Sort(a);
		for (int i : a) {
			System.out.print(i+" ");
		}

	}

	public static int[] Insert_Sort(int[] a) {
		/*
		 *每次要排序的元素为key[i]
		 *a[0] 默认情况下已经排好序 
		 */
		for(int i = 1;i<a.length;i++){
			for(int j = 0;j<i;j++){
				if (a[i]<a[j]) {
					int temp = a[j];
					a[j] = a[i];
					a[i] = temp;
				}
			}
		}
		return a;
	}

}


3)合并排序

/**
 *Apr 18, 2013
 *Copyright(c)JackWang
 *All rights reserve
 *@Author <a href="mailto:wangchengjack@163.com">JackWang</a>
 */
package com.example.sort;

/**
 * 合并排序 
 * 分治思想
 * Merge_Sort 可以对数组的任意部分进行合并排序
 * Merge_Sort1 只能对整个数组进行排序
 * 时间开销 O(nlgn)
 * 空间开销 O(n)
 * @author Administrator
 * 
 */

public class Mergtion_Sort {
	private static int[] a = { 41, 4, 78, 5, 14,45,6,12,56,13,85,68 };
	/**
	 * @param args
	 */
	public static void main(String[] args) {
//		Merge_Sort(a, 0, a.length-1);
		Merge_Sort1(a);
		for (int i : a) {
			System.out.print(i + " ");
		}
	}

	public static int[] Merge_Sort1(int[] a2) {
		if (a2.length > 1) {
			int mid = a2.length / 2;
			int[] leftArr = new int[mid];
			int[] rightArr = new int[a2.length - mid];
			for (int i = 0; i < leftArr.length; i++)
				leftArr[i] = a2[i];
			for (int j = 0; j < rightArr.length; j++)
				rightArr[j] = a2[mid + j];
			leftArr = Merge_Sort1(leftArr);
			rightArr = Merge_Sort1(rightArr);

			// 合并，考虑到脚标、数组的共享问题，最好把合并写到里面
			int i = 0;
			int j = 0;
			for (int k = 0; k < a2.length; k++) {
				if (i < leftArr.length && j < rightArr.length) {
					if (leftArr[i] < rightArr[j]) {
						a2[k] = leftArr[i];
						i++;
					} else {
						a2[k] = rightArr[j];
						j++;
					}
				} else if (i == leftArr.length && j < rightArr.length) {
					a2[k] = rightArr[j];
					j++;
				} else if (j == rightArr.length && i < leftArr.length) {
					a2[k] = leftArr[i];
					i++;
				}
			}

		}
		return a2;
	}

	public static void Merge_Sort(int[] a, int start, int end) {
		if ((end-start+1)> 1) {
			int mid = (end+start)/2;
			Merge_Sort(a, start, mid);
			Merge_Sort(a, mid+1, end);
			Merge(a,start,mid,end);
		} else {
			return;
		}
	}

	public static void Merge(int[] a, int start, int mid, int end) {
		int[] LeftArr = new int[mid-start+2];
		int[] RightArr = new int[end-mid+1];
		for (int i = 0; i < mid-start+1; i++)
			LeftArr[i] = a[start+i];
		LeftArr[mid-start+1] = Integer.MAX_VALUE;
		for (int j = 0; j < end-mid; j++)
			RightArr[j] = a[mid+1+j];
		RightArr[end-mid] = Integer.MAX_VALUE;
		int i = 0;
		int j = 0;
		int k = start;
		while (k < end+1) {
			if (LeftArr[i] < RightArr[j]) {
				a[k++] = LeftArr[i++];
			} else {
				a[k++] = RightArr[j++];
			}
		}
	}
}

本排序参考了该文章，在此表示感谢！

4)堆排序

/**
 *Apr 21, 2013
 *Copyright(c)JackWang
 *All rights reserve
 *@Author <a href="mailto:wangchengjack@163.com">JackWang</a>
*/
package com.example.sort;



public class HeapSort {
	private static int[] arr = {13, 27, 17, 3, 16, 13, 10, 1, 5, 7, 12, 4, 8, 9, 0 };
	public static void main(String[] args) {
		arr = heapSort(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
	}
	public static int[] heapSort(int[] arr2) {
		arr2 = BuildHeap(arr2);
		int length = arr2.length;
		for(int i = arr2.length - 1; i>0;i--){
			int temp = arr2[i];
			arr2[i] = arr2[0];
			arr2[0] = temp;
			length--;
			MaxHeap(arr2, 0,length);
		}
		return arr2;
	}
	public static int[] BuildHeap(int[] arr2) {
		int i = arr2.length/2;
		while(i>=0){
			MaxHeap(arr2,i,arr2.length);
			i--;
		}
		return arr2;
	}
	public static void MaxHeap(int[] arr2, int i ,int length) {
		int left = i == 0 ?1 :2*i;
		int right = left+1;
		int largest = i;
		if (left < length && arr2[left] > arr2[i]) {
			largest = left;
		}
		if (right < length && arr2[right] > arr2[largest]) {
			largest = right;
		}
		if (largest != i) {
			int temp = arr2[largest];
			arr[largest] = arr2[i];
			arr2[i] = temp;
			MaxHeap(arr2,largest,length);
		}
		
	}

}


5）快速排序

/**
 *Apr 22, 2013
 *Copyright(c)JackWang
 *All rights reserve
 *@Author <a href="mailto:wangchengjack@163.com">JackWang</a>
 */
package com.example.sort;

import java.util.Random;

public class QuickSortDemo {
	private static int[] arr = { 13, 27, 17, 3, 16, 10, 1,13, 5, 7, 12, 4, 8, 9, 0 };

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		arr = QuickSort(arr, 0, arr.length - 1);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}

	}

	public static int[] QuickSort(int[] arr2, int start, int end) {
		if (start < end) {
			// int CenterAixIndex = Partion(arr2,start,end);
			// int CenterAixIndex = RandomPartion1(arr2, start, end);
			int CenterAixIndex = RandomPartion2(arr2, start, end);
			QuickSort(arr2, start, CenterAixIndex - 1);
			QuickSort(arr2, CenterAixIndex + 1, end);
		}
		return arr2;
	}

	public static int RandomPartion2(int[] arr2, int start, int end) {
		int i = start - 1; // 表示比中轴小的部分的最后一个元素的脚标
		int random = new Random().nextInt(50) % (end - start + 1) + start;
		swap(arr2, random, end);    //将随机产生的脚标与最后一个元素互换，其他操作同Partion
		int p = arr2[end]; // 中轴
		for (int j = start; j < end; j++) {
			if (arr2[j] <= p) {
				i++;
				swap(arr2, i, j);
			}
		}
		swap(arr2, i + 1, end); // 把中轴作为大小部分数组的分界点
		return i + 1; // 返回分界点
	}

	/*
	 * 不能含有相同的元素的中轴，否则会陷入死循环 比如恰好中轴元素等于13，而数组总还有另外一个也等于13 则会陷入死循环
	 */
	public static int RandomPartion1(int[] arr2, int start, int end) {
		int i = start; // 从头开始
		int j = end; // 从尾开始
		int random = new Random().nextInt(50) % (end - start + 1) + start;
		int p = arr2[random]; // 中轴随机产生
		while (true) {
			while (arr2[i++] < p)
				;
			--i;
			while (arr2[j--] > p)
				;
			++j;
			if (j == i) {
				return i;
			} else if (i < j) {
				swap(arr2, i, j);
			}
		}

	}

	public static int Partion(int[] arr2, int start, int end) {
		int i = start - 1; // 表示比中轴小的部分的最后一个元素的脚标
		int p = arr2[end]; // 中轴
		for (int j = start; j < end; j++) {
			if (arr2[j] <= p) {
				i++;
				swap(arr2, i, j);
			}
		}
		swap(arr2, i + 1, end); // 把中轴作为大小部分数组的分界点
		return i + 1; // 返回分界点
	}

	private static void swap(int[] arr2, int i, int j) {
		int temp = arr2[i];
		arr2[i] = arr2[j];
		arr2[j] = temp;
	}
}

6）Stooge排序  

时间性能比插入排序还差。。。

/**
 *Apr 24, 2013
 *Copyright(c)JackWang
 *All rights reserve
 *@Author <a href="mailto:wangchengjack@163.com">JackWang</a>
*/
package com.example.sort;

public class StoogeSort {
	private static int[] arr = { 13, 27, 17, 3, 16, 10, 1,13, 5, 7, 12, 4, 8, 9, 0 };
//	private static int[] arr = { 13, 9, 21, 3 };

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		stoogeSort(arr,0,arr.length-1);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}

	}

	public static void stoogeSort(int[] arr2, int i, int j) {
		if (arr2[i] > arr2[j])
			swap(arr2,i,j);
		if(i+1 < j){
			int k = (j-i+1)/3;
			stoogeSort(arr2, i, j-k);  //数组的前三分之二
			stoogeSort(arr2, i+k, j);  //数组的后三分之二
			stoogeSort(arr2, i, j-2*k);  //数组的前三分之二
		}else
			return;
	}
	
	private static void swap(int[] arr2, int i, int j) {
		int temp = arr2[i];
		arr2[i] = arr2[j];
		arr2[j] = temp;
	}

}

7）计数排序

/**
 *Apr 26, 2013
 *Copyright(c)JackWang
 *All rights reserve
 *@Author <a href="mailto:wangchengjack@163.com">JackWang</a>
*/
package com.example.sort;
/**
 * 计数排序
 * 优点：排序稳定，在n较大时时间复杂度远远低于比较排序O(n)
 * 缺点：空间复杂度较大
 * 		当元素值分布非常离散时空间复杂度就更大，极大浪费内存
 * @author Administrator
 *
 */

public class CountSort {
	private static int[] arr = {13, 27, 17, 3, 16, 13, 10, 1, 5, 7, 12, 4, 8, 9, 0 };
	private static int[] B = new int[arr.length]; //用于存储排序后的数组

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		arr = countSort(arr,27);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}

	}

	/**
	 * 计数排序
	 * @param arr2 要排序的数组
	 * @param i   要排序数组中元素最大值
	 * @return
	 */
	public static int[] countSort(int[] arr, int k) {
//		int[] B = new int[arr.length];    
		int[] C = new int[k+1];           //记录每个元素的位置
		/*
		 * 初始化C数组
		 */
		for(int i = 0;i<=k;i++)
			C[i] = 0;
		for(int i = 0;i<arr.length;i++)
			C[arr[i]] = C[arr[i]] + 1;
		for(int i = 1;i<C.length;i++)
			C[i] += C[i - 1];
		for(int i = arr.length-1;i>=0;i--){
			B[C[arr[i]]-1] = arr[i];
			C[arr[i]] = C[arr[i]] - 1;
		}
		return B;
	}

}


附：习题：逆序对

/**
 *Apr 19, 2013
 *Copyright(c)JackWang
 *All rights reserve
 *@Author <a href="mailto:wangchengjack@163.com">JackWang</a>
 */
package com.example.sort;

/**
 * 计算逆序对（i<j 当A[i]>A[j]就是一个逆序对） 1)改造合并排序 2)改造冒泡排序
 * 
 * @author Administrator
 * 
 */

public class CountingInversion {
	private static int[] a = {41,4,78,5,14,56,4,74,120,103,51};
	private static int count = 0;

	/**
	 * @param args
	 */
	public static void main(String[] args) {
//		CountInversion(a, 0, a.length - 1);
		CountInversion1(a, 0, a.length - 1);
		System.out.println(count);

	}

	public static void CountInversion1(int[] a2, int start, int end) {
		for (int i = start; i < end; i++) {
			for (int j = i + 1; j < end + 1; j++) {
				if (a2[i] > a2[j])
					count++;
			}
		}
	}

	public static void CountInversion(int[] a2, int start, int end) {
		if ((end - start + 1) > 1) {
			int mid = (end + start) / 2;
			CountInversion(a, start, mid);
			CountInversion(a, mid + 1, end);
			Count(a, start, mid, end);
		} else {
			return;
		}
	}

	public static void Count(int[] a, int start, int mid, int end) {
		int[] LeftArr = new int[mid - start + 1];
		int[] RightArr = new int[end - mid];
		for (int i = 0; i < mid - start + 1; i++)
			LeftArr[i] = a[start + i];
		for (int j = 0; j < end - mid; j++)
			RightArr[j] = a[mid + 1 + j];
		for (int i = 0; i < LeftArr.length; i++)
			for (int j = 0; j < RightArr.length; j++)
				if (LeftArr[i] > RightArr[j])
					count++;
	}

}


------------------------------------

学习   交流

俺是小王子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
各种排序方法
05-27
该资源详细描述了各种C++的排序方法和技巧。
算法之逆序对
banji5552的博客
01-29 153
算法之逆序对 逆序对问题 ​ 假设A[1..n]是一个有n个不同数的数组。若i<j且A[i]>A[j],则对偶(i, j)称为A的一个逆序对(inversion)。 列出数组{2, 3, 8, 6, 1}的5个逆序对 由集合{1, 2, ..., n}中的元素构成的什么数组具有最多的逆序对？它有多少逆序对? 插入排序的运行时间与输入数组中的逆序对的数量有什么关系? 给出一...
c语言实现各种排序
热门推荐
QiHai的博客
06-11 1万+
hi~(￣▽￣)／ 欢迎大家能够点进我的文章٩(๑❛ᴗ❛๑)۶，这一篇，只是我对排序用c语言实现的一些粗糙的想法，讲的就是数据结构里面的选择排序，交换排序，插入排序啦~ヾ(✿ﾟ▽ﾟ)ノ，这里我会尽量用思路加图解的方式将每一个排序大致弄懂的啦~ 还请大家多多支持或者给我指出错误，我们能够一起共同学习呀！φ(>ω..............................
各种排序算法比较
wardseptember的博客
06-22 3125
排序算法的稳定性和源码 稳定性： 所谓稳定性是指当待排序列中有两个或两个以上相同的关键字时，排序前和排序后这些关键字的相对位置，如果没有发生变化就是稳定的，否则就是不稳定的。 如果关键字不能重复，则排序结果是唯一的，那么选择的排序算法稳定与否就无关紧要；如果关键字可以重复，则在选择排序算法是，就要根据具体的需求来考虑选择稳定的还是不稳定的排序算法。 排序算法 源码链接 ...
各种排序算法耗时比较
the_dog_tail_grass的博客
10-11 3867
我们知道，各个排序算法的时间复杂度从快速排序的nlogn到冒泡的n^2，但是即使时间复杂度相同，其具体的耗时也是不同的。今天就来实地测测每种算法到底耗时如何 一号选手：冒泡排序。我们知道冒泡排序算的上是最慢的一种排序方法了 #include<stdio.h> #include<stdlib.h> #include<memory.h> #include&lt...
各种排序算法代码
FlyingJack
04-23 2756
插入排序 #include <iostream> #include <algorithm> #include <cstdio> using namespace std; int const N = 10 + 5; int main(){ int n = 10; int test[N] = {12,9,2,31,10,1,15,7,8,11...
各种排序方法的比较
Levon123的博客
03-17 1093
各种排序方法的比较 排序方法有很多，它们各有优缺点，没有绝对最好的和最坏的排序方法，只有最符合某个使用场景的方法。在选用排序方法的时候，我们应该综合考虑以下方面： 1）时间复杂度； 2) 空间复杂度； 3）稳定性； 4）算法简单性； 5）待排序记录个数n的大小； 6）记录本身信息量的大小； 7）关键码的分布情况； 下面先从每个方面逐个对常用的一些算法进行比较和分析，然后给出综合讨论。 一、时间复杂度和空间复杂度 排序方法 平均情况 最好情况 最坏情况 辅助空间
各种排序算法的比较
08-17 3919
各种排序算法的比较排序算法的比较从时间复杂度上来看从空间复杂度来看从稳定性看其他特点后续 排序算法的比较 从时间复杂度上来看 简单选择排序、直接插入排序和冒泡排序平均情况下的时间复杂度都为O（n^2），且实现过程也较为简单，但直接插入排序和冒泡排序最好情况下的时间复杂度的时间复杂度可以达到O(n)，而简单选择排序则与序列的初始状态无关。希尔排序作为插入排序的拓展，对较大规模的排序都可以达到很高的效率，但目前未得出其精确的渐近时间。堆排序利用了一种称为堆的数据结构，可在线性时间内完成建堆。且在O（nlog2
各种排序算法及Python源代码
m0_49963403的博客
11-14 1942
文章目录排序算法排序算法稳定性冒泡排序源代码选择排序源代码插入排序源代码希尔排序源代码 排序算法 排序算法稳定性 在满足排序规则的前提下，保持原有顺序即具备稳定性，不保持原有顺序即不具稳定性 冒泡排序 源代码 具备稳定性，最坏时间复杂度=O(n^2) def bubble_list(list): for i in range(len(list)): for k in range(len(list)-1-i): if list[k] > list[k
数据结构----各种排序方法总结
weixin_52301714的博客
12-03 1742
数据结构----各种排序方法总结 提示：数据结构中的排序方法包括插入排序 文章目录数据结构----各种排序方法总结一、插入排序1.直接插入排序1.折半插入排序二、使用步骤1.引入库2.读入数据总结 一、插入排序 插入排序的定义：在有序序列中插入一个元素，保持序列有序，有序长度不断增加 1.直接插入排序 利用图形理清思路 void InsertSort(int a[], int n) { //在直接插入排序中，使用0号位置作为哨兵，用于暂时存放当前要插入的元素 int i, j; for (i =
各种排序算法
09-21
里面含有编程所用的大部分算法排序，包括冒泡排序，希尔排序，直接插入排序，快速排序，堆排序，简单选择排序，等等，适合刚入门的学习者
java各种排序
07-18
java排序
各种排序 冒泡排序.zip
01-30
精选上网上大量各种快速排序、冒泡排序等算法，本人测试通过
PHP 各种排序算法实现代码
01-20
php // 功能: PHP实现各种排序算法 // Author: windlike // Datetime: 2007-06-09 // 冒泡排序 function BubbleSort($arr){ $num = count($arr); for($i=1;$i<$num;$i++){ for($j=$num-1;$j>=$i;$j–){ if($arr[$...
JAVA 学习·泛型（二）——通配泛型
wr114514的博客
05-02 1057
介绍了Java泛型中的重要知识点——通配泛型及其应用。
获取Java 虚拟机进程ID（java应用进程Id的方法） Linux & windows
weixin_44131922的博客
04-30 505
这个命令会列出所有包含"java"的进程信息。从中你可以找到你的Java应用对应的进程行，第一列就是进程ID（PID）。这个命令会列出所有包含"java"的进程信息。在输出的信息中，你可以找到Java进程及其PID。替换为你的Java主类名或jar文件名的部分匹配字符串，pgrep会直接返回对应的进程ID。如果你需要在Java程序内部获取其自身的进程ID，可以使用。这段代码会打印出当前运行Java程序的进程ID。
springboot 获取maven打包时间
I do more ，you do less
04-30 503
【代码】springboot 获取maven打包时间。
Java---类和方法的再学习
最新发布
m0_74012211的博客
05-05 1070
Java类与对象
pandas各种排序函数
11-29
以下是Pandas中常用的各种排序函数： 1. Series数据的排序： - 按值排序：sort_values()函数 ```python import pandas as pd s = pd.Series([3, 1, 4, 2, 5]) s_sorted = s.sort_values() print(s_sorted) ``...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值