//********************************************************************
// Sorting.java Java Foundations
//
// Contains various sort algorithms that operate on an array of
// Comparable objects.
//********************************************************************
public class Sorting {
// -----------------------------------------------------------------
// Sorts the specified array of integers using the selection
// sort algorithm.
// -----------------------------------------------------------------
public static void selectionSort(Comparable[] data) // 选择排序
{
int min;
for (int index = 0; index < data.length - 1; index++) {
min = index;
for (int scan = index + 1; scan < data.length; scan++) //选出index+1。。。之后最小的与当前的min交换
if (data[scan].compareTo(data[min]) < 0)
min = scan;
swap(data, min, index);
}
}
// -----------------------------------------------------------------
// Swaps two elements in the specified array.
// -----------------------------------------------------------------
private static void swap(Comparable[] data, int index1, int index2) {
Comparable temp = data[index1];
data[index1] = data[index2];
data[index2] = temp;
}
// -----------------------------------------------------------------
// Sorts the specified array of objects using an insertion
// sort algorithm.
// -----------------------------------------------------------------
public static void insertionSort(Comparable[] data) // 插入排序
{
for (int index = 1; index < data.length; index++) {
Comparable key = data[index]; //当前要插入的元素
int position = index;
// Shift larger values to the right
while (position > 0 && data[position - 1].compareTo(key) > 0) { //将当前要插入的元素插入到已排序的数列中
data[position] = data[position - 1];
position--;
}
data[position] = key; //插入元素
}
}
// -----------------------------------------------------------------
// Sorts the specified array of objects using a bubble sort
// algorithm.
// -----------------------------------------------------------------
public static void bubbleSort(Comparable[] data) // 冒泡排序
{
int position, scan;
for (position = data.length - 1; position >= 0; position--) {
for (scan = 0; scan <= position - 1; scan++)
if (data[scan].compareTo(data[scan + 1]) > 0)
swap(data, scan, scan + 1);
}
}
// -----------------------------------------------------------------
// Sorts the specified array of objects using the quick sort
// algorithm.
// -----------------------------------------------------------------
public static void quickSort(Comparable[] data, int min, int max) { // 快速排序
int pivot;
if (min < max) {
pivot = partition(data, min, max); // make partitions
quickSort(data, min, pivot - 1); // sort left partition
quickSort(data, pivot + 1, max); // sort right partition
}
}
// -----------------------------------------------------------------
// Creates the partitions needed for quick sort.
// -----------------------------------------------------------------
private static int partition(Comparable[] data, int min, int max) {
// Use first element as the partition value
Comparable partitionValue = data[min];
int left = min;
int right = max;
while (left < right) {
// Search for an element that is > the partition element
while (data[left].compareTo(partitionValue) <= 0 && left < right) //只要小于中轴元素
left++;
// Search for an element that is < the partitionelement
while (data[right].compareTo(partitionValue) > 0)
right--;
if (left < right) //推出两个while,肯定是left的大,right的小,将两者交换
swap(data, left, right);
}
// Move the partition element to its final position
swap(data, min, right); //将中轴元素移动到两个子数列之间
return right;
}
// -----------------------------------------------------------------
// Sorts the specified array of objects using the merge sort
// algorithm.
// -----------------------------------------------------------------
public static void mergeSort(Comparable[] data, int min, int max) {
if (min < max) {
int mid = (min + max) / 2;
mergeSort(data, min, mid);
mergeSort(data, mid + 1, max);
merge(data, min, mid, max);
}
}
// -----------------------------------------------------------------
// Sorts the specified array of objects using the merge sort
// algorithm.
// -----------------------------------------------------------------
public static void merge(Comparable[] data, int first, int mid, int last) {
Comparable[] temp = new Comparable[data.length];
int first1 = first, last1 = mid; // endpoints of first subarray
int first2 = mid + 1, last2 = last; // endpoints of second subarray
int index = first1; // next index open in temp array
// Copy smaller item from each subarray into temp until one
// of the subarrays is exhausted
while (first1 <= last1 && first2 <= last2) {
if (data[first1].compareTo(data[first2]) < 0) {
temp[index] = data[first1];
first1++;
} else {
temp[index] = data[first2];
first2++;
}
index++;
}
// Copy remaining elements from first subarray, if any
while (first1 <= last1) {
temp[index] = data[first1];
first1++;
index++;
}
// Copy remaining elements from second subarray, if any
while (first2 <= last2) {
temp[index] = data[first2];
first2++;
index++;
}
// Copy merged data into original array
for (index = first; index <= last; index++)
data[index] = temp[index];
}
}
分享到:
相关推荐
JAVA排序大全 冒泡 快速 选择 归并排序
排序算法java版,速度排行:冒泡排序、简单选择排序、直接插入排序、折半插入排序、希尔排序、堆排序、归并排序、快速排序.mht
JAVA实现选择,冒泡,归并,插入,快速排序。并随机生成不同规模的随机数来测试各种排序方法耗费的时间。
本文将深入探讨Java编程语言中实现的七种主要排序算法:直接插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序以及归并排序。每种算法都有其独特性,适用于不同的场景和数据特性。 1. **直接插入排序**:...
这里我们将深入探讨快速排序、归并排序、希尔排序、冒泡排序、选择排序以及插入排序这六种经典的排序算法,并通过Java语言来实现它们。 1. **快速排序**:由C.A.R. Hoare在1960年提出,是基于分治策略的一种高效...
在Java中,冒泡排序的基本思路是使用两个for循环,外层循环控制比较的轮数,内层循环用于两两比较并交换。改进的冒泡排序通常包括设置标志位来检测是否已经完成排序,以及添加一个提前退出循环的条件,当某次遍历...
Java中可以使用`PriorityQueue`类实现堆排序。 4. **快速排序(Quick Sort)**: 快速排序是效率较高的排序算法,基于“分而治之”的策略。选择一个基准值,将数组分为两部分,一部分所有元素都小于基准,另一部分...
java实现10种排序算法:选择排序、冒泡排序、插入排序、快速排序、归并排序、堆排序、希尔排序、桶排_sorting-algorithms
下面我们将详细介绍如何用Java实现冒泡排序及其工作原理。 冒泡排序的工作原理: 冒泡排序的基本思想是重复地遍历待排序的序列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。遍历序列的工作是重复地...
本文将深入探讨四种常见的排序算法:快速排序、归并排序、冒泡排序和选择排序。这些算法不仅在理论上有其重要性,而且在实际编程项目中也经常被用到。 ### 快速排序 快速排序是由英国计算机科学家C.A.R. Hoare提出...
八种排序算法原理及Java实现是排序算法中的一种,包括冒泡排序、快速排序、直接插入排序、希尔排序、选择排序、归并排序和基数排序等。 冒泡排序是八种排序算法中的一种,属于交换排序。冒泡排序的基本思想是重复...
Java代码-排序-直接插入排序、希尔排序、直接选择排序、冒泡排序、堆排序、快速排序、归并排序中部分排序以及算法-贪心法,大家可以将源码下载下来进行学习,附带着注释和解释,有不理解的可以找博主一起探讨,共同...
这些算法包括冒泡排序、插入排序、选择排序、归并排序以及快速排序。 **冒泡排序**是一种基础的排序方法,它通过重复遍历数组,比较相邻元素并交换位置,使得较大的元素逐渐“浮”到数组的一端。冒泡排序的时间...
这里我们关注的是三种经典的排序算法:冒泡排序、归并排序和快速排序。这些排序算法各有特点,适应不同的场景需求。 **冒泡排序(Bubble Sort)** 冒泡排序是一种简单的排序算法,它通过重复遍历待排序的列表,比较...
总结来说,冒泡排序和选择排序都是简单且易于理解的排序算法,它们在实际应用中可能不如更高效的算法(如快速排序、归并排序)常见,但对于初学者来说,它们是理解排序算法和编程逻辑的良好起点。在Java中实现这两种...
这里我们将深入探讨标题和描述中提到的六种排序算法:快速排序、归并排序、插入排序、冒泡排序、选择排序以及堆排序。 1. **快速排序**:由C.A.R. Hoare在1960年提出,是一种高效的分治算法。快速排序的基本思想是...
例如,快速排序可以利用递归来实现,归并排序则可能需要用到STL中的`std::merge`函数,而冒泡排序则是一系列基本比较和交换操作的组合。 当选择排序算法时,开发者应考虑以下几个因素: 1. 时间复杂度:快速排序...
冒泡排序 3. 插入排序 4. 希尔排序 5. 堆排序 6. 归并排序 7. 快速排序 8. 基数排序 9. 计数排序 10. 桶排序 十种排序代码 我的博文地址:http://blog.csdn.net/u010156024/article/details/48932219
在Java中,我们通常使用`for`循环来实现冒泡排序。下面是一个简单的Java代码示例,用于对一个整型数组进行升序排序: ```java public class BubbleSort { public static void bubbleSort(int[] arr) { int n = ...
在Java中,我们可以使用数组来实现冒泡排序。以下是关于Java实现冒泡排序的详细知识: 1. **冒泡排序原理**: 冒泡排序的核心思想是每次比较两个相邻的元素,如果它们的顺序错误就交换它们的位置。这个过程就像水...