java实现内部排序算法

最新推荐文章于 2022-10-07 14:33:07 发布
最新推荐文章于 2022-10-07 14:33:07 发布
阅读量840 收藏
点赞数 1
分类专栏： web开发 文章标签： 希尔排序 快速排序 归并排序 排序算法 堆排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/suixingbugai/article/details/13511515
版权
  • 冒泡排序

public class BubbleSort{

	public static int[] asc(int[] a){
		int item;
		for (int i = 0; i < a.length-1; i++) {
			item = a[i];
			for (int j = i+1; j < a.length; j++) {
				if (a[j]<a[i]) {
					a[i] = a[j];
					a[j] = item;
					item = a[i];
				}
			}
		}
		return a;
	}
	

	public static int[] desc(int[] a){
		int item;
		for (int i = 0; i < a.length-1; i++) {
			item = a[i];
			for (int j = i+1; j < a.length; j++) {
				if (a[j]>a[i]) {
					a[i] = a[j];
					a[j] = item;
					item = a[i];
				}
			}
		}
		return a;
	}
	
	public static void main(String[] args) {
		int a[] = {23,14,25,32,8,27,15,13,58,8,2,36};
		a = asc(a);
		pump(a);
	}

	private static void pump(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+"\t");
		}
		System.out.println("\n");
	}
}

  • 堆排序

public class HeapSort{

	public static int[] asc(int[] a){
		a = buildHeap(a);
		int item;
		for (int i = a.length-1; i >=1; i--) {
			item = a[0];
			a[0] = a[i];
			a[i] = item;
			heapAdjust(a,0,i-1);
		}
		return a;
	}
	
	private static int[] buildHeap(int[] a) {
		return buildHeap(a,true);
	}
	
	private static int[] buildHeap(int[] a,boolean asc) {
		for (int i = a.length/2; i >= 0; i--) {
			a = heapAdjust(a,i,a.length-1,asc);
		}
		return a;
	}

	public static int[] heapAdjust(int[] a,int index,int size){
		return heapAdjust(a, index, size, true);
	}
	
	public static int[] heapAdjust(int[] a,int index,int size,boolean asc){
		int left = index*2 + 1;
		int right = left + 1;
		int max = index;
		if (left<=size) {
			if (asc&&a[left]>a[max]) {
				max = left;
			}
			if (!asc&&a[left]<a[max]) {
				max = left;
			}
		}
		if (right<=size) {
			if (asc&&a[right]>a[max]) {
				max = right;
			}
			if (!asc&&a[right]<a[max]) {
				max = right;
			}
		}
		if (max != index) {
			int temp = a[max];
			a[max] = a[index];
			a[index] = temp;
			heapAdjust(a, max, size, asc);
		}
		return a;
	}
	

	public static int[] desc(int[] a){
		a = buildHeap(a,false);
		int item;
		for (int i = a.length-1; i >=1; i--) {
			item = a[0];
			a[0] = a[i];
			a[i] = item;
			heapAdjust(a,0,i-1,false);
			pump(a);
		}
		return a;
	}
	
	public static void main(String[] args) {
		int a[] = {23,14,25,32,8,27,15,13,58,8,2,36};
		a = desc(a);
		pump(a);
	}

	private static void pump(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+"\t");
		}
		System.out.println("\n");
	}
}

  • 插入排序

public class InsertSort{

	public static int[] asc(int[] a){
		int item;
		for (int i = 0; i < a.length-1; i++) {
			item = a[i+1];
			for (int k = i; k >= 0; k--) {
				if (a[k]>item) {
					a[k+1] = a[k];
					a[k] = item;
				}else {
					break ;
				}
			}
		}
		return a;
	}
	
	public static int[] desc(int[] a){
		int item;
		for (int i = 0; i < a.length-1; i++) {
			item = a[i+1];
			for (int k = i; k >= 0; k--) {
				if (a[k]<item) {
					a[k+1] = a[k];
					a[k] = item;
				}else {
					break ;
				}
			}
		}
		return a;
	}
	
	public static void main(String[] args) {
		int a[] = {23,14,25,32,18,27,15,13,58,8,2,36};
		a = desc(a);
		for (int i = 0; i < a.length; i++) {
			System.out.println(a[i]);
		}
	}
}

  • 归并排序

public class MergeSort{

	public static int[] asc(int[] a){
		return asc(a,0,a.length-1);
	}
	
	public static int[] asc(int[] a,int start,int end){
		if (start<end) {
			if (start+1==end) {
				if(a[start]>a[end]){
					int temp = a[start];
					a[start] = a[end];
					a[end] = temp;
				}
				return a;
			}
			int m = (start+end)/2;
			a = asc(a,start,m);
			a = asc(a,m+1,end);
			a = merge(a,start,m,end);
		}
		return a;
	}
	

	private static int[] merge(int[] a, int start, int m, int end) {
		for (int j = m+1; j <= end; j++) {
			int index = j,i=j-1,item = a[j];
			while (i >= start&&item<a[i]) {
				index = i--;
			}
			if (index != j) {
				for (int k = j; k >index; k--) {
					a[k] = a[k-1];
				}
				a[index] = item;
			}
		}
		return a;
	}
	
	private static int[] merge(int[] a, int start, int m, int end,boolean asc) {
		for (int j = m+1; j <= end; j++) {
			int index = j,i=j-1,item = a[j];
			if (asc) {
				while (i >= start&&item<a[i]) {
					index = i--;
				}
			}else {
				while (i >= start&&item>a[i]) {
					index = i--;
				}
			}
			if (index != j) {
				for (int k = j; k >index; k--) {
					a[k] = a[k-1];
				}
				a[index] = item;
			}
		}
		return a;
	}
	

	public static int[] desc(int[] a){
		return desc(a,0,a.length-1);
	}
	
	private static int[] desc(int[] a,int start,int end) {
		if (start<end) {
			if (start+1==end) {
				if(a[start]<a[end]){
					int temp = a[start];
					a[start] = a[end];
					a[end] = temp;
				}
				return a;
			}
			int m = (start+end)/2;
			a = desc(a,start,m);
			a = desc(a,m+1,end);
			a = merge(a,start,m,end,false);
		}
		return a;
	}

	public static void main(String[] args) {
		int a[] = {23,14,25,32,8,27,15,13,58,8,2,36};
		a = desc(a);
		pump(a);
	}

	private static void pump(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+"\t");
		}
		System.out.println("\n");
	}
}

  • 快速排序

public class QuickSort {

	public static int[] asc(int[] a, int low, int high) {
		if (low >= high || (a[low] <= a[high] && low + 1 == high)) {
			return a;
		} else if (a[low] > a[high] && low + 1 == high) {
			int temp = a[high];
			a[high] = a[low];
			a[low] = temp;
			return a;
		}
		int tag = a[low], start = low, end = high;
		boolean left_right = false;
		while (low < high) {
			if (!left_right) {
				if (a[high] < tag) {
					a[low] = a[high];
					a[high] = tag;
					low++;
					left_right = true;
				} else {
					high--;
				}
			} else {
				if (a[low] > tag) {
					a[high] = a[low];
					a[low] = tag;
					left_right = false;
					high--;
				} else {
					low++;
				}
			}
		}
		if (start < high) {
			a = asc(a, start, high == low ? high - 1 : high);
		}
		if (low < end) {
			a = asc(a, low == high ? low + 1 : low, end);
		}
		return a;
	}

	public static int[] desc(int[] a, int low, int high) {
		if (low >= high || (a[low] >= a[high] && low + 1 == high)) {
			return a;
		} else if (a[low] < a[high] && low + 1 == high) {
			int temp = a[high];
			a[high] = a[low];
			a[low] = temp;
			return a;
		}
		int tag = a[low], start = low, end = high;
		boolean left_right = false;
		while (low < high) {
			if (!left_right) {
				if (a[high] > tag) {
					a[low] = a[high];
					a[high] = tag;
					low++;
					left_right = true;
				} else {
					high--;
				}
			} else {
				if (a[low] < tag) {
					a[high] = a[low];
					a[low] = tag;
					left_right = false;
					high--;
				} else {
					low++;
				}
			}
		}
		if (start < high) {
			a = desc(a, start, high == low ? high - 1 : high);
		}
		if (low < end) {
			a = desc(a, low == high ? low + 1 : low, end);
		}
		return a;
	}

	public static void main(String[] args) {
		int a[] = { 23, 14, 25, 32, 8, 27, 15, 13, 58, 8, 2, 36 };
		a = desc(a, 0, a.length - 1);
		pump(a);
	}

	private static void pump(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + "\t");
		}
		System.out.println("\n");
	}
}

  • 基数排序

public class RadixSort {

	private static int[] radix(int[] a, int radix, boolean asc) {
		int[][] index = new int[10][];
		int pow = Double.valueOf(Math.pow(10, radix)).intValue(), bucket = 0;
		for (int i = 0; i < a.length; i++) {
			bucket = a[i] % pow / (pow / 10);
			if (index[bucket] == null) {
				index[bucket] = new int[] { a[i] };
			} else {
				index[bucket] = add(index[bucket], a[i]);

			}
		}
		int k = 0;
		int[] b = new int[a.length];
		if (asc) {
			for (int i = 0; i < 10; i++) {
				if (index[i] != null && index[i].length > 0) {
					System.arraycopy(index[i], 0, b, k, index[i].length);
					k += index[i].length;
				}
			}
		} else {
			for (int i = 9; i >= 0; i--) {
				if (index[i] != null && index[i].length > 0) {
					System.arraycopy(index[i], 0, b, k, index[i].length);
					k += index[i].length;
				}
			}
		}
		return b;
	}

	private static int[] add(int[] a, int v) {
		if (a == null || a.length == 0) {
			return new int[] { v };
		} else {
			int[] b = new int[a.length + 1];
			System.arraycopy(a, 0, b, 0, a.length);
			b[a.length] = v;
			return b;
		}
	}

	public static int[] asc(int[] a) {
		int bucket = 1, max = 0;
		for (int i = 1; i < a.length; i++) {
			if (a[i] > a[max]) {
				max = i;
			}
		}
		bucket = String.valueOf(a[max]).length();
		for (int i = 1; i <= bucket; i++) {
			a = radix(a, i, true);
		}
		return a;
	}

	public static int[] desc(int[] a) {
		int bucket = 1, max = 0;
		for (int i = 1; i < a.length; i++) {
			if (a[i] > a[max]) {
				max = i;
			}
		}
		bucket = String.valueOf(a[max]).length();
		for (int i = 1; i <= bucket; i++) {
			a = radix(a, i, false);
		}
		return a;
	}

	public static void main(String[] args) {
		int a[] = { 23, 14, 25, 32, 8, 27, 15, 13, 58, 8, 2, 36 };
		a = desc(a);
		pump(a);
	}

	private static void pump(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + "\t");
		}
		System.out.println("\n");
	}
}

  • 选择排序

public class SelectSort{

	public static int[] asc(int[] a){
		int index;
		for (int i = 0; i < a.length-1; i++) {
			index = i;
			for (int j = i+1; j < a.length; j++) {
				if (a[j]<a[index]) {
					index = j;
				}
			}
			if (a[i]>a[index]) {
				int item = a[i];
				a[i] = a[index];
				a[index] = item;
			}
		}
		return a;
	}
	

	public static int[] desc(int[] a){
		int index;
		for (int i = 0; i < a.length-1; i++) {
			index = i;
			for (int j = i+1; j < a.length; j++) {
				if (a[j]>a[index]) {
					index = j;
				}
			}
			if (a[i]<a[index]) {
				int item = a[i];
				a[i] = a[index];
				a[index] = item;
			}
		}
		return a;
	}
	
	public static void main(String[] args) {
		int a[] = {23,14,25,32,8,27,15,13,58,8,2,36};
		a = desc(a);
		pump(a);
	}

	private static void pump(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i]+"\t");
		}
		System.out.println("\n");
	}
}


  • 希尔排序

public class ShellSort {

	public static int[] asc(int[] a) {
		int d = (a.length + 1) / 2;
		while (d >= 1) {
			shell(a, d, true);
			d = d / 2;
		}
		return a;
	}

	private static void shell(int[] a, int d, boolean asc) {
		int item;
		if (asc) {
			for (int i = 0; i < d; i++) {
				for (int j = i; j + d < a.length; j += d) {
					item = a[j + d];
					for (int k = j; k >= 0; k -= d) {
						if (a[k] > item) {
							a[k + d] = a[k];
							a[k] = item;
						} else {
							break;
						}
					}
				}
			}
		} else {
			for (int i = 0; i < d; i++) {
				for (int j = i; j + d < a.length; j += d) {
					item = a[j + d];
					for (int k = j; k >= 0; k -= d) {
						if (a[k] < item) {
							a[k + d] = a[k];
							a[k] = item;
						} else {
							break;
						}
					}
				}
			}
		}
	}

	public static int[] desc(int[] a) {
		int d = (a.length + 1) / 2;
		while (d >= 1) {
			shell(a, d, false);
			d = d / 2;
		}
		return a;
	}

	public static void main(String[] args) {
		int a[] = { 23, 14, 25, 32, 18, 27, 15, 13, 58, 8, 2, 36 };
		a = desc(a);
		pump(a);
	}

	private static void pump(int[] a) {
		for (int i = 0; i < a.length; i++) {
			System.out.print(a[i] + "\t");
		}
		System.out.println("\n");
	}
}



追求
关注
专栏目录
九种内部排序算法，Java版
11-06
## 九种内部排序算法的Java实现及其性能测试 ### 9种内部排序算法性能比较 第九种为java.util.Arrays.sort（改进的快速排序方法） 1. 100000的随机数据集 ![](http://7xlkoc.com1.z0.glb.clouddn.com/sort1.jpg) 2. 200000的随机数据集 ![](http://7xlkoc.com1.z0.glb.clouddn.com/sort2.jpg) 3. 500000的随机数据集 ![](http://7xlkoc.com1.z0.glb.clouddn.com/sort3.jpg) 结论：归并排序和堆排序维持O(nlgn)的复杂度，速率差不多，表现优异。固定基准的快排表现很是优秀。而通过使用一个循环完成按增量分组后的直接插入的希尔排序，测试效果显著。 冒泡，选择，直接插入都很慢，而冒泡效率是最低。 ### 1.插入排序[稳定] 适用于小数组,数组已排好序或接近于排好序速度将会非常快 复杂度：O(n^2) - O(n) - O(n^2) - O(1)[平均 - 最好 - 最坏 - 空间复杂度]
Java实现桶排序算法（源代码）
最新发布
05-07
### Java实现桶排序算法 #### 实现原理与关键步骤 桶排序是一种高效的排序算法，尤其适合于处理数据分布均匀的情况。其核心思想是通过将数据分成若干个“桶”，然后分别对这些桶内的数据进行排序，最后将这些排序...
Java实现各种内部排序算法
weixin_34414650的博客
07-14 93
数据结构中常见的内部排序算法： 　　插入排序：直接插入排序、折半插入排序、希尔排序 　　交换排序：冒泡排序、快速排序 　　选择排序：简单选择排序、堆排序 　　归并排序、基数排序、计数排序 直接插入排序： 　　思想：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中，直到全部记录插入完成。 　　性能：时间复杂度：最好o(n)：有序，最坏o(n^2)：逆序,平均o(...
JAVA内部排序算法汇总
波希米亚的专栏
08-04 1277
为了增加面试的机会,针对公司的笔试题,特此整理一下排序方面的资料...定义排序的接口:Sort public interface Sort { int[] datas = {0,12,32,45,2,13,57,29,11,34,21,42,15,90}; int length =datas.length; public void sort(); public void publish()
java常见的内部排序算法
qq_41035192的博客
01-03 189
1.插入排序： 插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入 2.希尔排序： 先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序 3.选择排序： 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，再从剩余未排序元素中...
Java实现快速排序算法（源代码）
05-07
### Java实现快速排序算法知识点详解 #### 一、快速排序的基本概念 快速排序是一种非常高效且广泛应用的排序算法，最早由C.A.R. Hoare在1960年提出。其核心思想是采用分治法策略，通过一次排序操作将待排序的数据...
使用Java实现希尔排序算法的简单示例
09-02
希尔排序，又称缩小增量排序，是由希尔(Harold Shell)在1959年提出的一种改进的插入排序算法。这种排序方法将待排序的数组元素按照一定的间隔分组，然后对每组进行插入排序，随着间隔逐渐减小，直至间隔为1，此时...
java实现插入排序算法
09-03
插入排序是一种简单直观的排序...通过理解插入排序的基本概念、工作原理以及Java实现，开发者可以根据具体需求选择合适的排序算法，以达到最优的性能表现。在实际编程中，灵活运用各种排序算法是提升程序效率的关键。
Java实现快速排序算法(Quicktsort)
09-04
然而，由于快速排序的内部循环可以在大部分情况下充分利用缓存，实际性能往往优于其他O(n log n)的排序算法，如归并排序。 在测试代码中，我们创建了一个包含正负整数的数组，调用`quickSort`进行排序，然后使用`...
java 内部排序算法的性能分析
08-25
[问题描述] 设计一个测试程序比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受。 [需求分析] (1)对起泡排序、直接排序、简单选择排序、快速排序、希尔排序、堆排序算法进行比较； (2)待排序表的表长不小于100，表中数据随机产生，至少用5组不同数据作比较，比较指标有：关键字参加比较次数和关键字的移动次数（关键字交换记为3次移动）； (3)输出比较结果。 [选做内容] (1)对不同表长进行比较； (2)验证各算法的稳定性； (3)输出界面的优化。
6种内部排序算法------Java实现
三年二班—晓石头
12-22 634
6种排序算法------Java实现 直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、选择排序
Java八大内部排序算法
qq_43663493的博客
08-26 677
排序算法的分类 时间复杂度以及空间复杂度 注：为了进行一定的比较，此处不按照上面的顺序。 直接插入排序 基本思想 在要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。 场景： 正如当我们打牌的时候，需要对扑克牌排序。抽到牌后(假设每次只抽一张)，依次从排好序的排中与手中的牌进行比较，插入到合适的位置。 /** * 插入排序 * @param a */ public static void sort(in
java七大内部排序算法
Java_Programmer1的博客
07-29 261
冒泡排序
用Java实现常见的8种内部排序算法
hello_1566的博客
05-01 659
一、插入类排序 插入类排序就是在一个有序的序列中，插入一个新的关键字。从而达到新的有序序列。插入排序一般有直接插入排序、折半插入排序和希尔排序。 1. 插入排序 1.1 直接插入排序 /** * 直接比较，将大元素向后移来移动数组 */ public static void InsertSort(int[] A) { for(int i = 1; i < A.length; i++) { int temp = A[i]; //temp 用于存储元素，防止后面移动
八大排序算法及Java实现（内部排序）
weixin_45880263的博客
08-18 169
排序算法 内部排序算法：需要排序的数据可以一次全部加载到内存中 外部排序算法：需要排序的数据数量太过庞大，不能一次性全部加载到内存中 内部排序算法 速度从快到慢 希尔排序（移动法）> 简单选择 > 直接插入 > 冒泡 > 希尔排序（交换法） 1.冒泡排序 每次从头开始到未排好序部分的末尾，依次比较相邻数据，如果与要求的顺序逆序，则交换，直到某一次循环中没有发生交换结束 n-1次外循环 每次循环“末尾”数据排好，即尾部为排好序的部分 每次内循环比上一次减1 for(int
常见几种java排序算法
热门推荐
zzzgd_666的博客
02-18 10万+
1.插入排序 public class InsertSort { public static void sort(int[] arr) { if (arr.length &amp;amp;amp;gt;= 2) { for (int i = 1; i &amp;amp;amp;lt; arr.length; i++) { //挖出一个要用来插入的值,同时位置上留下...
11 种 内部排序算法 大PK（Java 语言实现），究竟谁最快？
愿你饱经冷暖，仍保纯真
10-07 3275
11 种内部排序算法
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实现内部排序算法详解：插入、交换、选择、归并与基数排序
"内部排序算法的Java实现，包括直接插入排序、折半插入排序、希尔排序、起泡排序、快速排序、简单选择排序、树形选择排序、堆排序、归并排序和基数排序等，详细介绍了每种算法的原理和Java代码实现。" 在计算机科学...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值