Java基础语法30-排序算法

最新推荐文章于 2022-04-01 22:19:17 发布
最新推荐文章于 2022-04-01 22:19:17 发布
阅读量133 收藏
点赞数
分类专栏： JAVA基础 文章标签： java 排序算法 编程语言 数据结构 排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A1066223647/article/details/118280884
版权

Java基础语法30-排序算法

文章目录

本文大多数代码来自于尚硅谷教程资料，如有侵权请告知。

一、整型数组-不考虑排序的稳定性

1.折半插入排序

package com.atguigu.array.sort;

/**
 * 折半插入排序
 * 
 * @author shkstart 2018-12-17
 */

public class BinaryInsertSort {
	public static void binaryInsertSort(int[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		for (int i = 1; i < arrayLength; i++) {
			int temp = data[i];
			int low = 0;
			int high = i - 1;
			while (low <= high) {
				int mid = (low + high) / 2;
				if (temp > data[mid]) {
					low = mid + 1;
				} else {
					high = mid - 1;
				}
			}
			for (int j = i; j > low; j--) {
				data[j] = data[j - 1];
			}
			data[low] = temp;
			System.out.println(java.util.Arrays.toString(data));
		}

	}

	public static void main(String[] args) {
		int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		binaryInsertSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

2.冒泡排序

package com.atguigu.array.sort;

/**
 * 冒泡排序 
 * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
 * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 
 * 针对所有的元素重复以上的步骤，除了最后一个。
 * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
 * 
 * @author shkstart 2018-12-17
 */
public class BubbleSort {
	
	public static void bubbleSort(int[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		for (int i = 0; i < arrayLength - 1; i++) {
			for (int j = 0; j < arrayLength - 1 - i; j++) {
				if (data[j] > data[j + 1]) {
					int temp = data[j + 1];
					data[j + 1] = data[j];
					data[j] = temp;
				}
			}
			System.out.println(java.util.Arrays.toString(data));
		}
	}
	//优化1
	public static void bubbleSort1(int[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		for (int i = 0; i < arrayLength - 1; i++) {
			boolean flag = false;
			for (int j = 0; j < arrayLength - 1 - i; j++) {
				if (data[j] > data[j + 1]) {
					int temp = data[j + 1];
					data[j + 1] = data[j];
					data[j] = temp;
					flag = true;
				}
			}
			System.out.println(java.util.Arrays.toString(data));
			if (!flag)
				break;
		}
	}

	public static void main(String[] args) {
		int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		bubbleSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

3.桶排序

package com.atguigu.array.sort;

import java.util.Arrays;

/**
 * 桶式排序
 * 
 * @author shkstart 2018-12-17
 */
public class BucketSort {
	public static void bucketSort(int[] data, int min, int max) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		int[] temp = new int[arrayLength];
		int[] buckets = new int[max - min];
		for (int i = 0; i < arrayLength; i++) {
			buckets[data[i] - min]++;
		}
		System.out.println(Arrays.toString(buckets));
		for (int i = 1; i < max - min; i++) {
			buckets[i] = buckets[i] + buckets[i - 1];
		}
		System.out.println(Arrays.toString(buckets));
		System.arraycopy(data, 0, temp, 0, arrayLength);
		for (int k = arrayLength - 1; k >= 0; k--) {
			data[--buckets[temp[k] - min]] = temp[k];
		}
	}

	public static void main(String[] args) {
		int[] data = { 9, 5, -1, 8, 5, 7, 3, -3, 1, 3 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		bucketSort(data, -3, 10);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

4.堆排序

package com.atguigu.array.sort;

/**
 * 堆排序
 * 
 * @author shkstart 2018-12-17
 */
public class HeapSort {
	public static void heapSort(int[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		// 循环建堆
		for (int i = 0; i < arrayLength - 1; i++) {
			// 建堆
			buildMaxdHeap(data, arrayLength - 1 - i);
			// 交换堆顶和最后一个元素
			swap(data, 0, arrayLength - 1 - i);
			System.out.println(java.util.Arrays.toString(data));
		}
	}

	// 对data数组从0到lastIndex建大顶堆
	private static void buildMaxdHeap(int[] data, int lastIndex) {
		// 从lastIndex处节点（最后一个节点）的父节点开始
		for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
			// k保存当前正在判断的节点
			int k = i;
			// 如果当前k节点的子节点存在
			while (k * 2 + 1 <= lastIndex) {
				// k节点的左子节点的索引
				int biggerIndex = 2 * k + 1;
				// 如果biggerIndex小于lastIndex，即biggerIndex +1
				// 代表k节点的右子节点存在
				if (biggerIndex < lastIndex) {
					// 如果右子节点的值较大
					if (data[biggerIndex] - data[biggerIndex + 1] < 0) {
						// biggerIndex总是记录较大子节点的索引
						biggerIndex++;
					}
				}
				// 如果k节点的值小于其较大子节点的值
				if (data[k] - data[biggerIndex] < 0) {
					// 交换它们
					swap(data, k, biggerIndex);
					// 将biggerIndex赋给k，开始while循环的下一次循环
					// 重新保证k节点的值大于其左、右节点的值
					k = biggerIndex;
				} else {
					break;
				}
			}
		}
	}

	// 交换data数组中i、j两个索引处的元素
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	public static void main(String[] args) {
		int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		heapSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

5.直接插入排序

package com.atguigu.array.sort;

/**
 * 直接插入排序
 * 
 * @author shkstart 2018-12-17
 */
public class InsertSort {
	public static void insertSort(int[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		for (int i = 1; i < arrayLength; i++) {
			int temp = data[i];
			if (data[i] - data[i - 1] < 0) {
				int j = i - 1;
				for (; j >= 0 && data[j] - temp > 0; j--) {
					data[j + 1] = data[j];
				}
				data[j + 1] = temp;
			}
			System.out.println(java.util.Arrays.toString(data));
		}

	}

	public static void main(String[] args) {
		int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		insertSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

6.归并排序

package com.atguigu.array.sort;

/**
 * 归并排序
 * 
 * @author shkstart 
 * 2018-12-17
 */
public class MergeSort {
	public static void mergeSort(int[] data) {
		// 归并排序
		sort(data, 0, data.length - 1);
	}

	// 将索引从left到right范围的数组元素进行归并排序
	private static void sort(int[] data, int left, int right) {
		if(left < right){
			//找出中间索引
			int center = (left + right)/2;
			sort(data,left,center);
			sort(data,center+1,right);
			//合并
			merge(data,left,center,right);
		}
	}

	// 将两个数组进行归并，归并前两个数组已经有序，归并后依然有序
	private static void merge(int[] data, int left, int center, int right) {
		int[] tempArr = new int[data.length];
		int mid = center + 1;
		int third = left;
		int temp = left;
		while (left <= center && mid <= right) {
			if (data[left] - data[mid] <= 0) {
				tempArr[third++] = data[left++];
			} else {
				tempArr[third++] = data[mid++];
			}
		}
		while (mid <= right) {
			tempArr[third++] = data[mid++];
		}
		while (left <= center) {
			tempArr[third++] = data[left++];
		}
		while (temp <= right) {
			data[temp] = tempArr[temp++];
		}
	}

	public static void main(String[] args) {
		int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		mergeSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

7.基数排序

package com.atguigu.array.sort;

import java.util.Arrays;

/**
 * 基数排序
 * 
 * @author shkstart 2018-12-17
 */
public class MultiKeyRadixSort {
	public static void radixSort(int[] data, int radix, int d) {
		System.out.println("开始排序：");
		int arrayLength = data.length;
		int[] temp = new int[arrayLength];
		int[] buckets = new int[radix];
		for (int i = 0, rate = 1; i < d; i++) {
			// 重置count数组，开始统计第二个关键字
			Arrays.fill(buckets, 0);
			// 当data数组的元素复制到temp数组中进行缓存
			System.arraycopy(data, 0, temp, 0, arrayLength);
			for (int j = 0; j < arrayLength; j++) {
				int subKey = (temp[j] / rate) % radix;
				buckets[subKey]++;
			}
			for (int j = 1; j < radix; j++) {
				buckets[j] = buckets[j] + buckets[j - 1];
			}
			for (int m = arrayLength - 1; m >= 0; m--) {
				int subKey = (temp[m] / rate) % radix;
				data[--buckets[subKey]] = temp[m];
			}
			System.out.println("对" + rate + "位上子关键字排序："
					+ java.util.Arrays.toString(data));
			rate *= radix;
		}
	}

	public static void main(String[] args) {
		int[] data = { 1100, 192, 221, 12, 13 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		radixSort(data, 10, 4);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

8.快速排序

package com.atguigu.array.sort;

/**
 * 快速排序
 * 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，
 * 则分别对这两部分继续进行排序，直到整个序列有序。
 * @author shkstart
 * 2018-12-17
 */
public class QuickSort {
	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	private static void subSort(int[] data, int start, int end) {
		if (start < end) {
			int base = data[start];
			int low = start;
			int high = end + 1;
			while (true) {
				while (low < end && data[++low] - base <= 0)
					;
				while (high > start && data[--high] - base >= 0)
					;
				if (low < high) {
					swap(data, low, high);
				} else {
					break;
				}
			}
			swap(data, start, high);
			
			subSort(data, start, high - 1);//递归调用
			subSort(data, high + 1, end);
		}
	}
	public static void quickSort(int[] data){
		subSort(data,0,data.length-1);
	}
	
	
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

9.直接选择排序

package com.atguigu.array.sort;


/**
 * 直接选择排序
 * @author shkstart
 * 2018-12-17
 */
public class SelectSort {
	public static void selectSort(int[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		for (int i = 0; i < arrayLength - 1; i++) {
			for (int j = i + 1; j < arrayLength; j++) {
				if (data[i] - data[j] > 0) {
					int temp = data[i];
					data[i] = data[j];
					data[j] = temp;
				}
			}
			System.out.println(java.util.Arrays.toString(data));
		}
	}

	public static void main(String[] args) {
		int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		selectSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

10.直接选择排序改进

package com.atguigu.array.sort;

/**
 * 直接选择排序-改进
 * @author shkstart
 * 2018-12-17
 */
public class SelectSort2 {
	public static void selectSort(int[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		for (int i = 0; i < arrayLength - 1; i++) {
			int minIndex = i;
			for (int j = i + 1; j < arrayLength; j++) {
				if (data[minIndex] - data[j] > 0) {
					minIndex = j;
					
				}
			}
			if(minIndex != i){
				int temp = data[i];
				data[i] = data[minIndex];
				data[minIndex] = temp;
			}
			System.out.println(java.util.Arrays.toString(data));
		}
	}

	public static void main(String[] args) {
		int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		selectSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

11.希尔排序

package com.atguigu.array.sort;
/**
 * Shell排序
 * @author shkstart
 * 2018-12-17
 */

public class ShellSort {
	public static void ShellSort(int[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;

		int h = 1;
		while (h <= arrayLength / 3) {
			h = h * 3 + 1;
		}
		while (h > 0) {
			System.out.println("===h的值：" + h + "===");
			for (int i = h; i < arrayLength; i++) {
				int temp = data[i];
				if (data[i] - data[i - h] < 0) {
					int j = i - h;
					for (; j >= 0 && data[j] - temp > 0; j -= h) {
						data[j + h] = data[j];
					}
					data[j + h] = temp;
				}
				System.out.println(java.util.Arrays.toString(data));
			}
			h = (h - 1) / 3;
		}
	}

	public static void main(String[] args) {
		int[] data = { 9, -16, 21, 23, -30, -49, 21, 30, 30 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		ShellSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

二、对象数组—考虑排序的稳定性

0.DataWrap类

package com.atguigu.array.sort2;

public class DataWrap implements Comparable<DataWrap>{
	int data;
	String flag;
	public DataWrap(int data,String flag){
		this.data = data;
		this.flag = flag;
	}
	public String toString(){
		return data + flag;
	}
	//根据data实例变量来决定两个dataWrap的大小
	@Override
	public int compareTo(DataWrap dw) {
		return this.data > dw.data? 1 : (this.data == dw.data? 0 : -1);
	}
	
}

1.折半插入排序

package com.atguigu.array.sort2;
/**
 * 折半插入排序
 * @author shkstart
 * 2018-12-17
 */

public class BinaryInsertSort {
	public static void binaryInsertSort(DataWrap[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		for (int i = 1; i < arrayLength; i++) {
			DataWrap temp = data[i];
			int low = 0;
			int high = i - 1;
			while (low <= high) {
				int mid = (low + high) / 2;
				if (temp.compareTo(data[mid]) > 0) {
					low = mid + 1;
				} else {
					high = mid - 1;
				}
			}
			for (int j = i; j > low; j--) {
				data[j] = data[j - 1];
			}
			data[low] = temp;
			System.out.println(java.util.Arrays.toString(data));
		}

	}

	public static void main(String[] args) {
		DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),
				new DataWrap(21, "*"), new DataWrap(23, ""),
				new DataWrap(-30, ""), new DataWrap(-49, ""),
				new DataWrap(21, ""), new DataWrap(30, "*"),
				new DataWrap(30, "")};
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		binaryInsertSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

2.冒泡排序

package com.atguigu.array.sort2;

/**
 * 冒泡排序
 * @author shkstart
 * 2018-12-17
 */
public class BubbleSort {
	public static void bubbleSort(DataWrap[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		for (int i = 0; i < arrayLength - 1; i++) {
			boolean flag = false;
			for (int j = 0; j < arrayLength - 1 - i; j++) {
				if (data[j].compareTo(data[j + 1]) > 0) {
					DataWrap temp = data[j + 1];
					data[j + 1] = data[j];
					data[j] = temp;
					flag = true;
				}
			}
			System.out.println(java.util.Arrays.toString(data));
			if (!flag)
				break;
		}
	}

	public static void main(String[] args) {
		DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),
				new DataWrap(21, "*"), new DataWrap(23, ""),
				new DataWrap(-30, ""), new DataWrap(-49, ""),
				new DataWrap(21, ""), new DataWrap(30, "*"),
				new DataWrap(30, "")};
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		bubbleSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

3.桶排序

package com.atguigu.array.sort2;

import java.util.Arrays;

/**
 * 桶式排序
 * 
 * @author shkstart 
 * 2018-12-17
 */
public class BucketSort {
	public static void bucketSort(DataWrap[] data, int min, int max) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		DataWrap[] temp = new DataWrap[arrayLength];
		int[] buckets = new int[max - min];
		for (int i = 0; i < arrayLength; i++) {
			buckets[data[i].data - min]++;
		}
		System.out.println(Arrays.toString(buckets));
		for (int i = 1; i < max - min; i++) {
			buckets[i] = buckets[i] + buckets[i - 1];
		}
		System.out.println(Arrays.toString(buckets));
		System.arraycopy(data, 0, temp, 0, arrayLength);
		for (int k = arrayLength - 1; k >= 0; k--) {
			data[--buckets[temp[k].data - min]] = temp[k];
		}
	}

	public static void main(String[] args) {
		DataWrap[] data = { new DataWrap(9, ""), new DataWrap(5, ""),
				new DataWrap(-1, ""), new DataWrap(8, ""),
				new DataWrap(5, "*"), new DataWrap(7, ""),
				new DataWrap(3, ""), new DataWrap(-3, ""),
				new DataWrap(1, ""),new DataWrap(3, "*")};
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		bucketSort(data, -3, 10);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

4.堆排序

package com.atguigu.array.sort2;

/**
 * 堆排序
 * @author shkstart
 * 2018-12-17
 */
public class HeapSort {
	public static void heapSort(DataWrap[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		// 循环建堆
		for (int i = 0; i < arrayLength - 1; i++) {
			// 建堆
			builMaxdHeap(data, arrayLength - 1 - i);
			// 交换堆顶和最后一个元素
			swap(data, 0, arrayLength - 1 - i);
			System.out.println(java.util.Arrays.toString(data));
		}
	}

	// 对data数组从0到lastIndex建大顶堆
	private static void builMaxdHeap(DataWrap[] data, int lastIndex) {
		// 从lastIndex处节点（最后一个节点）的父节点开始
		for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
			// k保存当前正在判断的节点
			int k = i;
			// 如果当前k节点的子节点存在
			while (k * 2 + 1 <= lastIndex) {
				// k节点的左子节点的索引
				int biggerIndex = 2 * k + 1;
				// 如果biggerIndex小于lastIndex，即biggerIndex +1
				// 代表k节点的右子节点存在
				if (biggerIndex < lastIndex) {
					// 如果右子节点的值较大
					if (data[biggerIndex].compareTo(data[biggerIndex + 1]) < 0) {
						// biggerIndex总是记录较大子节点的索引
						biggerIndex++;
					}
				}
				// 如果k节点的值小于其较大子节点的值
				if (data[k].compareTo(data[biggerIndex]) < 0) {
					// 交换它们
					swap(data, k, biggerIndex);
					// 将biggerIndex赋给k，开始while循环的下一次循环
					// 重新保证k节点的值大于其左、右节点的值
					k = biggerIndex;
				} else {
					break;
				}
			}
		}
	}

	// 交换data数组中i、j两个索引处的元素
	private static void swap(DataWrap[] data, int i, int j) {
		DataWrap temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	public static void main(String[] args) {
		DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),
				new DataWrap(21, "*"), new DataWrap(23, ""),
				new DataWrap(-30, ""), new DataWrap(-49, ""),
				new DataWrap(21, ""), new DataWrap(30, "*"),
				new DataWrap(30, "")};
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		heapSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

5.直接插入排序

package com.atguigu.array.sort2;

/**
 * 直接插入排序
 * @author shkstart
 * 2018-12-17
 */
public class InsertSort {
	public static void insertSort(DataWrap[] data){
		System.out.println("开始排序");
		int arrayLength = data.length;
		for(int i = 1;i < arrayLength;i++){
			DataWrap temp = data[i];
			if(data[i].compareTo(data[i-1]) < 0){
				int j = i -1;
				for(;j >= 0 && data[j].compareTo(temp) > 0;j--){
					data[j +1] = data[j];
				}
				data[j + 1] = temp;
			}
			System.out.println(java.util.Arrays.toString(data));
		}
		
	}
	public static void main(String[] args) {
		DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),
				new DataWrap(21, "*"), new DataWrap(23, ""),
				new DataWrap(-30, ""), new DataWrap(-49, ""),
				new DataWrap(21, ""), new DataWrap(30, "*"),
				new DataWrap(30, "")};
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		insertSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

6.归并排序

package com.atguigu.array.sort2;

/**
 * 归并排序
 * 
 * @author shkstart 
 * 2018-12-17
 */
public class MergeSort {
	public static void mergeSort(DataWrap[] data) {
		// 归并排序
		sort(data, 0, data.length - 1);
	}

	// 将索引从left到right范围的数组元素进行归并排序
	private static void sort(DataWrap[] data, int left, int right) {
		if(left < right){
			//找出中间索引
			int center = (left + right)/2;
			sort(data,left,center);
			sort(data,center+1,right);
			//合并
			merge(data,left,center,right);
		}
	}

	// 将两个数组进行归并，归并前两个数组已经有序，归并后依然有序
	private static void merge(DataWrap[] data, int left, int center, int right) {
		DataWrap[] tempArr = new DataWrap[data.length];
		int mid = center + 1;
		int third = left;
		int temp = left;
		while (left <= center && mid <= right) {
			if (data[left].compareTo(data[mid]) <= 0) {
				tempArr[third++] = data[left++];
			} else {
				tempArr[third++] = data[mid++];
			}
		}
		while (mid <= right) {
			tempArr[third++] = data[mid++];
		}
		while (left <= center) {
			tempArr[third++] = data[left++];
		}
		while (temp <= right) {
			data[temp] = tempArr[temp++];
		}
	}

	public static void main(String[] args) {
		DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),
				new DataWrap(21, "*"), new DataWrap(23, ""),
				new DataWrap(-30, ""), new DataWrap(-49, ""),
				new DataWrap(21, ""), new DataWrap(30, "*"),
				new DataWrap(30, "") };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		mergeSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

7.基数排序

package com.atguigu.array.sort2;

import java.util.Arrays;

/**
 * 基数排序
 * 
 * @author shkstart 2018-12-17
 */
public class MultiKeyRadixSort {
	public static void radixSort(int[] data, int radix, int d) {
		System.out.println("开始排序：");
		int arrayLength = data.length;
		int[] temp = new int[arrayLength];
		int[] buckets = new int[radix];
		for (int i = 0, rate = 1; i < d; i++) {
			// 重置count数组，开始统计第二个关键字
			Arrays.fill(buckets, 0);
			// 当data数组的元素复制到temp数组中进行缓存
			System.arraycopy(data, 0, temp, 0, arrayLength);
			for (int j = 0; j < arrayLength; j++) {
				int subKey = (temp[j] / rate) % radix;
				buckets[subKey]++;
			}
			for (int j = 1; j < radix; j++) {
				buckets[j] = buckets[j] + buckets[j - 1];
			}
			for (int m = arrayLength - 1; m >= 0; m--) {
				int subKey = (temp[m] / rate) % radix;
				data[--buckets[subKey]] = temp[m];
			}
			System.out.println("对" + rate + "位上子关键字排序："
					+ java.util.Arrays.toString(data));
			rate *= radix;
		}
	}

	public static void main(String[] args) {
		int[] data = { 1100, 192, 221, 12, 13 };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		radixSort(data, 10, 4);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

8.快速排序

package com.atguigu.array.sort2;

/**
 * 快速排序
 * @author shkstart
 * 2018-12-17
 */
public class QuickSort {
	private static void swap(DataWrap[] data, int i, int j) {
		DataWrap temp = data[i];
		data[i] = data[j];
		data[j] = temp;
	}

	private static void subSort(DataWrap[] data, int start, int end) {
		if (start < end) {
			DataWrap base = data[start];
			int i = start;
			int j = end + 1;
			while (true) {
				while (i < end && data[++i].compareTo(base) <= 0)
					;
				while (j > start && data[--j].compareTo(base) >= 0)
					;
				if (i < j) {
					swap(data, i, j);
				} else {
					break;
				}
			}
			swap(data, start, j);
			subSort(data, start, j - 1);
			subSort(data, j + 1, end);
		}
	}
	public static void quickSort(DataWrap[] data){
		subSort(data,0,data.length-1);
	}
	public static void main(String[] args) {
		DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),
				new DataWrap(21, "*"), new DataWrap(23, ""),
				new DataWrap(-30, ""), new DataWrap(-49, ""),
				new DataWrap(21, ""), new DataWrap(30, "*"),
				new DataWrap(30, "") };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

9.直接选择排序

package com.atguigu.array.sort2;


/**
 * 直接选择排序
 * @author shkstart
 * 2018-12-17
 */
public class SelectSort {
	public static void selectSort(DataWrap[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		for (int i = 0; i < arrayLength - 1; i++) {
			for (int j = i + 1; j < arrayLength; j++) {
				if (data[i].compareTo(data[j]) > 0) {
					DataWrap temp = data[i];
					data[i] = data[j];
					data[j] = temp;
				}
			}
			System.out.println(java.util.Arrays.toString(data));
		}
	}

	public static void main(String[] args) {
		DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),
				new DataWrap(21, "*"), new DataWrap(23, ""),
				new DataWrap(-30, ""), new DataWrap(-49, ""),
				new DataWrap(21, ""), new DataWrap(30, "*"),
				new DataWrap(30, "") };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		selectSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

10.直接选择排序改进

package com.atguigu.array.sort2;

/**
 * 直接选择排序-改进
 * @author shkstart
 * 2018-12-17
 */
public class SelectSort2 {
	public static void selectSort(DataWrap[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;
		for (int i = 0; i < arrayLength - 1; i++) {
			int minIndex = i;
			for (int j = i + 1; j < arrayLength; j++) {
				if (data[minIndex].compareTo(data[j]) > 0) {
					minIndex = j;
					
				}
			}
			if(minIndex != i){
				DataWrap temp = data[i];
				data[i] = data[minIndex];
				data[minIndex] = temp;
			}
			System.out.println(java.util.Arrays.toString(data));
		}
	}

	public static void main(String[] args) {
		DataWrap[] data = { new DataWrap(9, ""), new DataWrap(-16, ""),
				new DataWrap(21, "*"), new DataWrap(23, ""),
				new DataWrap(-30, ""), new DataWrap(-49, ""),
				new DataWrap(21, ""), new DataWrap(30, "*"),
				new DataWrap(30, "") };
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		selectSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}

11.希尔排序

package com.atguigu.array.sort2;
/**
 * Shell排序
 * @author shkstart
 * 2018-12-17
 */

public class ShellSort {
	public static void ShellSort(DataWrap[] data) {
		System.out.println("开始排序");
		int arrayLength = data.length;

		int h = 1;
		while (h <= arrayLength / 3) {
			h = h * 3 + 1;
		}
		while (h > 0) {
			System.out.println("===h的值：" + h + "===");
			for (int i = h; i < arrayLength; i++) {
				DataWrap temp = data[i];
				if (data[i].compareTo(data[i - h]) < 0) {
					int j = i - h;
					for (; j >= 0 && data[j].compareTo(temp) > 0; j -= h) {
						data[j + h] = data[j];
					}
					data[j + h] = temp;
				}
				System.out.println(java.util.Arrays.toString(data));
			}
			h = (h - 1) / 3;
		}
	}

	public static void main(String[] args) {
		DataWrap[] data = { 
				new DataWrap(9, ""), new DataWrap(-16, ""),
				new DataWrap(21, "*"), new DataWrap(23, ""),
				new DataWrap(-30, ""), new DataWrap(-49, ""),
				new DataWrap(21, ""), new DataWrap(30, "*"),
				new DataWrap(30, "")};
		System.out.println("排序之前：\n" + java.util.Arrays.toString(data));
		ShellSort(data);
		System.out.println("排序之后：\n" + java.util.Arrays.toString(data));
	}
}
MarxistVive
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java基础语法面试题.docx
08-06
Java基础语法面试题资源通常是指帮助准备Java编程面试的问题集合，涵盖了Java编程语言的基础概念、语法、特性和常见问题。这些资源可以帮助面试者巩固和扩展他们的Java知识，准备应对面试过程中的技术问题。 这些...
Java快速排序
Violet277的博客
04-23 1371
快速排序是排序算法中很重要，而且也是使用很广泛的一种排序算法。它的思想也归并排序有点类似，都是需要分区，并对每个分区进行排序，然后对整个分区进行排序。
java中三种常见的排序方式
you_never_alone的博客
04-17 2万+
这节我们来了解一下java中常见的三种排序方式，这里我们说的是1.冒泡排序2.选择排序3.插入排序排序中要考虑到的主要因素是时间复杂度和空间复杂度，时间我们可以用System.currentTimeMillis()这个来查看。下面我们依次来说明1.冒泡排序所谓冒泡排序就是从前到后遍历选出最大值放到最后一个，然后在遍历剩下的找出剩下中最大的放到倒数第二个，依次直至遍历到最后一个，也就是最小的放到第一...
Java基础——Java的基本语法（数组、排序）
abelboy的博客
11-02 502
Java基础——Java的基本语法（数组）Java基础知识图解数组一维数组声明一维数组初始化内存结构内存的基本结构：数组声明与赋值：多维数组二位数组的声明与赋值内存结构 Java基础知识图解 数组 数组是多个相同类型数据的组合，实现对这些数据的统一管理 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型 数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象...
java数据的排序算法,java常用数据结构排序算法
weixin_33480732的博客
03-10 51
import java.util.*;public class TestSort1{private int[] a = {9,5,8,2,1,4,3,7};private int n = 8;public void BubbleSortedArray(){//冒泡排序for(int i = 1;ifor(int j = 0;jif(a[j] > a[j+1]){int temp;temp =...
Java实现常用的几种排序方法
qq_41924554的博客
04-14 833
Java实现几种常见排序方法 1、定义 将杂乱无章的数据元素，通过一定的方法按关键字顺序排列的过程叫做排序。 2、排序方法 日常操作中常见的排序方法有：冒泡排序、快速排序、选择排序、堆排序、归并排序、插入排序、希尔排序等。 以下是代码的实现： package sort; public class SortTest { /** * 冒泡排序的流程： * （1）：和相邻元素进行比较，如果后一个比前一个小（从小到大排序），则交换两个元素 * （2）冒泡排序一趟
Java SE完整版精品优质课件 自学入门必看的优秀Java基础知识培训教案 数据结构_排序算法(共144页).pptx
08-29
Java SE完整版精品优质课件 自学入门必看的优秀Java基础知识培训教案 特别适合新入门自学的新手同学，也适合老手回顾学习，巩固知识 第1章 Java语言概述 第2章 基本语法 第3章 面向对象编程 第4章 高级类特性1 第5...
JAVA经典算法42例.rar
03-10
对于初学者，这些算法可以帮助他们掌握Java语言的基本语法和编程技巧，同时了解常见算法的实现方式。对于有一定基础的开发者，可以通过学习和实践这些算法，提高自己的编程能力和解决问题的能力。 此外，这些算法还...
Java常用算法手册
07-26
　赵志云、衡友跃编著的《Java常用算法手册》分三篇，共13章，分别介绍了算法基础、算法应用和算法面试题。首先介绍了算法概述，然后重点分析了数据结构和基本算法思想；接着，详细讲解了算法在排序、查找、数学计算...
Java基本语法——数组中涉及的常见排序算法
灬小言灬的博客
07-25 126
冒泡排序 public class BubbleSortTest { public static void main(String[] args) { int[] arr = new int[]{ 10, -11, 32, 2, -30, -59, 21, 51, 60 }; //冒泡排序 for(int i = 0;i < arr.length - 1;i++){ for(int j = 0;j < arr.length - 1 - i;j++){
排序10万数据仅用2秒,Java帮你实现
IT邦德
12-07 1933
JAVA排序(Sorting)是数据处理中一种很重要的运算，同时也是很常用的运算， 一般数据处理工作25%的时间都在进行排序。 简单地说，排序就是把一组记录(元素)按照 某个域的值的递增(即由小到大)或递减(即由大到小)的次序重新排列的过程。
Java的List排序
热门推荐
weixin_44547786的博客
06-08 4万+
开发工具与关键技术：MyEclipse 10、Java语法 作者：邓婵 撰写时间：2019年6 月 5日 集合和数组的不同点： 数组：只能存储固定大小同一类型的元素。数组元素可以是基本数据类型的值，也可以是对象。 集合：可用于存储数量不等的对象，并可以实现常用的数据结构。还可以保存具有映射关系的关联数组。而集合只能保存对象。 Collection和map属于同一系统集合，list接口和set接口继...
Java基础语法25-求数值型数组中元素的最大值、最小值、平均数、总和等
A1066223647的博客
06-11 1668
Java基础语法25-求数值型数组中元素的最大值、最小值、平均数、总和等 定义一个int型的一维数组,包含18个元素,分别赋一些随机整数,然后求出所有元素的最大值,最小值,和值,平均值,并输出出来。 要求:所有随机数都是两位数。 [10,99] 公式：(int)Math.random() * (99 - 10 + 1) + 10 public class ArrayTest1 { public static void main(String[] args) { int[] arr
Java基础语法96-Java9&10&11新特性
A1066223647的博客
04-01 1641
Java基础语法96-Java9&10&11新特性 一、java9新特性 一、 JDK 和 JRE 目录结构的改变 bin 目录 包含命令行开发和调试工具，如javac，jar和javadoc。 include目录 包含在编译本地代码时使用的C/C++头文件 lib 目录 包含JDK工具的几个JAR和其他类型的文件。 它有一个tools.jar文件，其中包 含javac编译器的Java类 jre/bin 目录 包含基本命令，如java命令。 在Windows平台上
Java基础语法69-接口
A1066223647的博客
10-14 1558
Java基础语法69-接口 文章目录Java基础语法69-接口一、接口的使用二、接口的应用：代理模式三、Java8接口的新特性 一、接口的使用 接口使用interface来定义 在java中接口和类是并列的结构 如何定义接口：定义接口中的成员 ​ 3.1 JDK7及以前：只能定义全局常量和抽象方法 ​ 全局常量：public static final的，但是书写时可以省略不写 ​ 抽象方法：public abstract的 ​ 3.2 JD
Java基础语法23-数组练习
A1066223647的博客
06-11 1173
Java基础语法23-数组练习 1.计算二维数组数值的总和 public class ArrayExer { public static void main(String[] args) { int[][] arr = new int[][]{{3,5,8},{12,9},{7,0,6,4}}; int sum = 0; for (int i = 0; i < arr.length; i++) { for (int j
Java基础语法17-Switch-case结构
A1066223647的博客
05-31 802
Java基础语法17-Switch-case结构 分支结构一：if-else 分支结构二：switch-case 1.格式 switch(表达式){ case 常量1： ​ 执行语句； ​ break； case 常量2： ​ 执行语句； ​ break； ···· default： ​ 执行语句n； } class SwitchCaesTest { public static void main(String[] args){
Java基础语法68-抽象类练习
A1066223647的博客
10-12 577
Java基础语法68-抽象类练习 编写工资系统，实现不同类型员工(多态)的按月发放工资。如果当月出现某个 Employee对象的生日，则将该雇员的工资增加100元。 实验说明： （1） 定义一个Employee类，该类包含： private成员变量name,number,birthday，其中birthday 为MyDate类的对象； abstract方法earnings()； toString()方法输出对象的name,number和birthday。 （2） MyDate类包含: private成
Java基础语法24-LeetCode蛇形填数的实现
A1066223647的博客
06-11 519
Java基础语法24-回形数格式方阵的实现 从键盘输入一个整数（1~20） 则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如： 输入数字2，则程序输出： 1 2 4 3 输入数字3，则程序输出： 1 2 3 8 9 4 7 6 5 输入数字4， 则程序输出： 1 2 3 4 12 13 14 5 11 16 15 6 10 9 8 7 思路：将这个数组横向看做为x轴，纵向为y轴，原点为左上角，数变大的方向为正方向。如图所示： 观察矩阵可
java算法怎么学习
最新发布
03-15
4. 学习常见的算法和数据结构：在掌握了基本的数据结构和算法思想后，可以开始学习一些常见的算法和数据结构，如排序算法（如冒泡排序、快速排序）、查找算法（如二分查找）、图算法（如深度优先搜索、广度优先搜索...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MarxistVive

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值