public class SortMain {
// 用于临时储值
static int temp = 0;
public static void main(String[] args) {
// 需要排序的数据
int[] Source = { 2, 4, 6, 1, 3, 5, 8, 4, 10, 18 };
// 冒泡排序法
// printSource(bubbleSort(Source));
// 插入排序法
// printSource(insertSort(Source));
// 反转数组
// printSource(reverseSort(Source));
// 希尔排序法(shell)
// printSource(shellSort(Source));
// 选择排序法
// printSource(selectSort(Source));
//printSource(Source);
// 快速排序法
//printSource(QuickSort(Source, 0, Source.length - 1));
}
// 使用冒泡排序法
public static int[] bubbleSort(int[] Source) {
// 获取需要排序的数据
int[] bubbleArray = Source;
// 进行排序
for (int i = 0; i < bubbleArray.length; i++)// 从数组第一个元素进行遍历
{
for (int j = i + 1; j < bubbleArray.length; j++)// 从下标为i+1的元素进行遍历
{
if (bubbleArray[i] > bubbleArray[j])// 对bubbleArray[i]>bubbleArray[j]进行比较
{
temp = bubbleArray[i]; // 将bubbleArray[i]存于临时变量中
bubbleArray[i] = bubbleArray[j]; // 实现i和j的数据对换操作
bubbleArray[j] = temp;
}
}
}
return bubbleArray;
}
/***
*
* @param Source 返回数组
* @return
*
* 插入排序法 Insertion Sort
* 简言之,插入排序就是每一步都讲一个待排数据按其大小插入到已经排序的数据中的
* 适当位置,知道全部插入完毕。插入排序方法分直接插入排序和折半插入排序两种,
* 这里只介绍直接插入排序。
*/
// 使用插入排序法
public static int[] insertSort(int[] Source) {
// 获取需要排序的数据
int[] insertSort = Source;
// 开始执行插入排序
for (int i = 1; i < insertSort.length; i++) {
for (int j = 0; j < i; j++) {
if (insertSort[j] > insertSort[i]) {
temp = insertSort[i];
insertSort[i] = insertSort[j];
insertSort[j] = temp;
}
}
}
return insertSort;
}
// 反转数组法
public static int[] reverseSort(int[] Source) {
// 获取需要排序的数据
int[] reverseSort = Source;
for (int i = 0; i < reverseSort.length / 2; i++) {
temp = reverseSort[i];
reverseSort[i] = reverseSort[reverseSort.length - i - 1];
reverseSort[reverseSort.length - 1 - i] = temp;
}
return reverseSort;
}
// 希尔排序法
public static int[] shellSort(int[] Source) {
for (int increment = Source.length / 2; increment >= 2; increment /= 2) {
// System.out.print(increment+"\t");
System.out.println();
for (int i = 0; i < increment; i++) {
insertSource(Source, i, increment);
}
}
System.out.println();
// System.out.println("执行最后一步");
printSource(Source);
// System.out.println("执行完毕");
insertSource(Source, 0, 1);
// System.out.println();
return Source;
}
// 希尔排序法中的调用方法
public static void insertSource(int[] Source, int start, int inc) {
System.out.print("start:" + start + "inc:" + inc + "\t");
System.out.println();
int temp;
for (int i = start + inc; i < Source.length; i += inc) {
System.out.println("i-------:" + i);
for (int j = i; j >= inc; j -= inc) {
System.out.println("j:" + j);
if (Source[j] < Source[j - inc]) {
temp = Source[j];
Source[j] = Source[j - inc];
Source[j - inc] = temp;
}
}
}
}
/***
*
* @param Source
* @return
* 选择排序法 Selecttion Sort
* 选择排序的基本思想是:对待排序的记录序列进行n-1遍的处理,第一遍是将L[1..n]中
* 的最小者与L[1]交换位置,第二遍处理是讲L[2..n]中的最小者与L[2]交换位置,....,第i遍
* 处理是讲L[i..n]中的最小者与L[i]交换位置。这样,经过i遍处理之后,前i个记录的位置就已
* 经从小到大的顺序排列好了。
*
* 选择排序于冒泡排序的区别:冒泡排序每次比较后,如果发现书序不对立即进行交换,而选择排序
* 不立即进行交换,而是找出最小的元素后在进行交换
*/
// 选择排序法
public static int[] selectSort(int[] Source) {
// 获取需要排序的数据
int[] selectSort = Source;
int index;
for (int i = 0; i < selectSort.length; i++) {
index = i;
for (int j = i + 1; j < selectSort.length; j++) {
if (selectSort[index] > selectSort[j]) {
index = j;
}
}
temp = selectSort[i];
selectSort[i] = selectSort[index];
selectSort[index] = temp;
}
return selectSort;
}
/***
* 快速排序法
* 快速排序是对冒泡排序的一种改进,它的基本思想是:通过一趟排序将排序的数据分割
* 成独立的两部分,其中一部分的所有数据都比另一部分的所有数据都要小,然后再按此
* 方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数
* 据变成有序序列
*/
// 快速排序法
static boolean bool = true;
public static int[] QuickSort(int[] Source, int left, int right) {
int i = left;
int j = right;
int temp = 0;
int between = Source[(left + right) / 2];
do {
while (Source[i] < between && i <= right) {
i++;
}
while (Source[j] > between && j >= left) {
j--;
}
if (i <= j) {
temp = Source[i];
Source[i] = Source[j];
Source[j] = temp;
i++;
j--;
}
/*if (bool) {
printSource(Source);
bool = false;
}*/
} while (i <= j);
printSource(Source);
if (left < j) {
QuickSort(Source, left, j);
}
if (right > i) {
QuickSort(Source, i, right);
}
return Source;
}
// 打印方法
public static void printSource(int[] Source) {
for (int i = 0; i < Source.length; i++) {
System.out.print(Source[i] + "\t");
}
System.out.println();
}
}
分享到:
相关推荐
SS系统软件设计说明书详细阐述了Java排序方法的实现与应用,是J-car项目的重要文档。文档的目的是为了明确SS系统的设计规格,特别是其中涉及到的排序功能。本文档适用于所有参与SS系统开发、测试和维护的人员,以及...
这个文档“java排序方法.pdf”涵盖了多种经典的排序算法的实现,包括插入排序、冒泡排序、选择排序、Shell排序以及更高效的快速排序、归并排序和堆排序。下面我们将详细探讨这些排序算法。 1. **插入排序(Insertion...
初学Java中有对一串数字的排序,而且对考试面试什么的都有可能用得到,帮助学习,增加知识有冒泡排序选择排序等等几种方式
本文将深入探讨Java中的各种排序方法以及它们的改良策略。首先,我们来看看几种基础的排序算法,然后讨论如何通过优化来提高这些算法的性能。 1. **冒泡排序**(Bubble Sort): 冒泡排序是最基础的排序算法之一,...
简单的8种排序方法,有冒泡排序,基本排序,快速排序等等等等
下面将详细介绍几种常见的Java排序方法。 1. **Java内置排序方法**: - **Arrays.sort()**: 这是Java提供的最基础的排序方法,适用于数组和对象数组。对于基本类型的数组(如int、double等),它使用快速排序或...
### Java 实现几种常见排序方法 #### 泡泡排序(Bubble Sort) 泡泡排序是一种简单的排序算法,它重复地遍历待排序的数列,依次比较相邻的两个元素,如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复...
### Java排序方法面试知识点详解 在Java编程领域中,排序算法是面试中常见的技术考察点之一。本篇文章将深入分析几种基本的排序算法,并通过具体的Java代码示例来阐述每种算法的特点及其应用场景。 #### 1. 插入...
java的一些常见排序方法分析,冒泡排序,插入排序等,多种排序方法思路的分析。
使用java实现的选择、冒泡、插入、快速、希尔排序以及折半查找
### Java冒泡排序方法详解 #### 一、冒泡排序简介 冒泡排序是一种简单的排序算法,它重复地遍历待排序的数列,依次比较相邻的两个元素,如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的,直到...
### Java排序方法详解 在Java编程语言中,排序算法是数据结构与算法中的一个重要组成部分,广泛应用于各种场景中。本文将根据提供的代码片段详细介绍几种基本的排序算法:冒泡排序、选择排序、插入排序、希尔排序...
- **定义**:直接插入排序是一种简单的排序方法,它的工作原理是将一个记录插入到已排序好的有序表中,从而得到一个新的、记录增1的有序表。 - **时间复杂度**: - 最好情况:O(n),即当输入数组已经是排序好的情况...
每种排序算法都有其优缺点,实际应用中需根据数据特性和性能要求选择合适的排序方法。理解这些排序算法不仅有助于编写高效的代码,也有利于参加面试时回答相关问题。在学习过程中,可以通过实践来加深理解,比如编写...
Java集合框架中的`List`接口提供了一个`sort(Comparator<? super E> comparator)`方法,可以接受一个比较器(Comparator)来定义自定义的排序规则。默认情况下,Java使用自然排序,即按照字符串的Unicode值进行排序...
`Collections.sort()` 是 Java 中一种快速且高效地对集合(如 ArrayList)进行排序的方法。可以自定义比较器来指定排序规则。 **示例代码分析**: ```java public class Main { public static void main(String[] ...
【面向对象Java排序包】是基于Java编程语言设计的一个专门用于处理排序问题的软件组件。这个包充分体现了面向对象的设计原则,将数据结构、算法和业务逻辑封装在独立的对象中,提高了代码的可读性和可维护性。它不仅...
【JAVA排序汇总】Java编程语言中,排序是数据处理中非常基础且重要的操作。本文将对几种经典的排序算法进行简要介绍和分析。 1. **插入排序**: 插入排序分为直接插入排序和折半插入排序。直接插入排序是将每个...
根据给定文件中的标题“Java排序代码大全”以及描述与标签中的关键词如“Java排序”、“排序大全”和“算法”,本文将详细解读文件中所包含的几种排序算法的实现方式,并结合具体代码进行深入分析。 ### 快速排序...