JAVA实现部分排序方法
public class SortTest {
public static void main(String[] args) {
int[] a = { 3, 5, 2, 1, 9, 10, 8, 7, 6, 1, 2, 4 };
System.out.print("数组原序: ");
for (int k = 0; k < a.length; k++) {
System.out.print(a[k] + " ");
}
System.out.println();
// swap(int[]a ,int i,int j);交换方法
int p=0;//0代表数组索引的第一个数字
int q=2;//位置的交换
swap(a,p,q);
System.out.print("交换方法: ");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
System.out.println();
// bubbleSort(a);冒泡排序
bubbleSort(a);
System.out.print("冒泡排序: ");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
System.out.println();
//selectSort(a);直接选择排序
selectSort(a);
System.out.print("直接选择排序: ");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
System.out.println();
// insertSort(a);插入排序方法
insertSort(a);
System.out.print("插入排序方法: ");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
System.out.println();
// reverse(a);反转数组方法
reverse(a);
System.out.print("反转数组方法: ");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
System.out.println();
// quitSort(int[] a, int low, int hight)快速排序法
int low = 0;
int hight=11;
quitSort(a,low,hight);
System.out.print("快速排序方法: ");
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
System.out.println();
}
/** * 交换方法 * @param a * @param i * @param j */
public static void swap(int[] a, int i, int j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
/** * 冒泡排序 * @param a */
public static void bubbleSort(int[] a) {
for (int i = 0; i < a.length; i++) {
for (int j = i; j < a.length; j++) {
if (a[i] > a[j]) {
swap(a, i, j);
}
}
}
}
/**
* * 直接选择排序法----选择排序的一种 方法:每一趟从待排序的数据元素中选出最小(或最大)的一个元素, *
* 顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。 性能:比较次数O(n^2),n^2/2 交换次数O(n),n *
* 交换次数比冒泡排序少多了,由于交换所需CPU时间比比较所需的CUP时间多,所以选择排序比冒泡排序快。 *
* 但是N比较大时,比较所需的CPU时间占主要地位,所以这时的性能和冒泡排序差不太多,但毫无疑问肯定要快些。 *
* * @param data *
* 要排序的数组 * @param sortType * 排序类型 * @return
*/
public static void selectSort(int[] data) {
int index;
for (int i = 0; i < data.length; i++) {
index = i;
for (int j = i + 1; j < data.length; j++) {
if (data[index] > data[j]) {
index = j;
}
} // 交换在位置i和index(最大值)两个数
swap(data, i, index);
}
}
/**
* 插入排序方法:将一个记录插入到已排好序的有序表(有可能是空表)中,从而得到一个新的记录数增1的有序表。
* 性能:比较次数O(n^2),n^2/4 * 复制次数O(n),n^2/4 比较次数是前两者的一般,而复制所需的CPU时间较交换少,
* 所以性能上比冒泡排序提高一倍多,而比选择排序也要快。 *
* @param data 要排序的数组
* @param sortType 排序类型
*/
public static void insertSort(int[] data) { // 比较的轮数
for (int i = 1; i < data.length; i++) {
// 保证前i+1个数排好序
for (int j = 0; j < i; j++) {
if (data[j] > data[i]) {
// 交换在位置j和i两个数
swap(data, i, j);
}
}
}
}
/**
* * 反转数组的方法 * *
* @param data * 源数组
*/
public static void reverse(int[] data) {
int length = data.length;
int temp = 0;
// 临时变量
for (int i = 0; i < length / 2; i++) {
temp = data[i];
data[i] = data[length - 1 - i];
data[length - 1 - i] = temp;
}
}
/**
* * 快速排序 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists)。
* 步骤为:
* 1. 从数列中挑出一个元素,称为 "基准"(pivot),
* 2. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面 (相同的数可以到任一边)。
* 在这个分割之后,该基准是它的最后位置。这个称为分割(partition)操作。
* 3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
* 递回的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。
* 虽然一直递回下去,但是这个算法总会结束,因为在每次的迭代(iteration)中,
* 它至少会把一个元素摆到它最后的位置去。
*/
public static void quitSort(int[] a, int low, int hight)// 快速排序法
{
int i, j, k = 0;
if (low < hight)// 先保存
{
i = low;
j = hight;
k = a[i];
while (i < j) {
while (i < j && a[j] > k) {
j--;
}
if (i < j) {// 从后往前排序
a[i] = a[j];
i++;
}
while (i < j && a[i] < k) {
i++;
}
if (i < j) {// 从前往后排序
a[j] = a[i];
j--;
}
}
a[i] = k;
quitSort(a, low, i - 1);
quitSort(a, i + 1, hight);
}
}
}