数据结构之排序算法整理（2）

首先，看一下两种交换排序。

1.冒泡排序

package com.BubbleSort;

import java.util.Arrays;

/**
* 交换排序中的冒泡排序
* 对于一个包含n个元素的数组，需要进行n-1趟比较。
第一趟：依次比较数组索引为0和1,1和2，……，n-2和n-1的元素，如果发现前一个数据大于后一个数据，则进行交换。经过第一趟，最大（最小）元素排到最后；
第一趟：依次比较数组索引为0和1,1和2，……，n-3和n-2的元素，如果发现前一个数据大于后一个数据，则进行交换。经过第二趟，最大（最小）元素排到倒数第二位；
……
第n-1趟：依次比较数组索引为0和1，如果发现前一个数据大于后一个数据，则进行交换。
冒泡排序的每趟结束后，不仅能将当前最大(最小)值排列出来，还能部分理顺数组中其他元素；一旦某一趟遍历是没有发生元素交换，则可提前结束排序。
算法时间复杂度O(n*n)；空间复杂度O(1)；稳定
* @author tcj
*
*/
public class BubbleSort {
public static void bubbleSort(int[] datas){
//边界检查
if(datas == null){
return;
}
int length = datas.length - 1;
if(length == -1){
return;
}

for(int i = 0;i < length;i++){
//一趟冒泡中有没有做交换
boolean flag = false;
for(int j = 0;j < length - i;j++){
//交换
if(datas[j] > datas[j+1]){
int tmp = datas[j];
datas[j] = datas[j+1];
datas[j+1] = tmp;
flag = true;
}
}
//			System.out.println(Arrays.toString(datas));
//如果某次遍历未发生交换，结束遍历
if(!flag){
break;
}
}
}

//测试
public static void main(String[] args){
//		int[] array = {22,30,49,30,16,9};
//		BubbleSort.bubbleSort(array);
//		System.out.println(Arrays.toString(array));
//		int[] a = {};
//		BubbleSort.bubbleSort(a);
//		System.out.println(Arrays.toString(a));
//		int[] b = null;
//		BubbleSort.bubbleSort(b);
//		System.out.println(Arrays.toString(b));
int[] c = {1,2,3,4,5};
BubbleSort.bubbleSort(c);
System.out.println(Arrays.toString(c));

}
}

2.快速排序

package com.QuickSort;

import java.util.Arrays;

/**
* 交换排序中的快速排序
* 基本思想：
* 从待排序的数组中任取一个数据作为分界值，所有比其小的数据元素一律放到左边，所有比其大的元素一律放到右边。
* 经过一趟遍历，该数组形成左右两个子序列，左边序列中数据元素的值都比分界值小，右边序列中的数据元素值都比分界值大。
* (分界值的选取是关键点，简单起见，一般都是选择一个值)。
* 然后对左右两个子数组进行递归，对两个子序列重新选择分界值并以此进行调整，知道每个子数组只有一个元素。
* @author tcj
*
*/
public class QuickSortImp {
private static void QuickSort(int[] a,int start,int end){
if(start < end){
int j = Partition(a,start,end);
QuickSort(a,start,j);
QuickSort(a,j+1,end);
}
}

private static int Partition(int[] a,int start,int end){
if(a == null){
return -1;
}

int i = start;
int j = end;
int pivot = a[start];
while(i < j){
while(i < j && a[i] < pivot){
i++;
}
while(i < j && a[j] > pivot){
j--;
}
if(i < j){
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}

// int temp = pivot;
// pivot = a[j];
// a[j] = temp;
return j;
}

public static int partition(int n[], int left, int right) {

int pivot = n[left];

while (left < right) {

while (left < right && n[right] >= pivot)

right--;

if (left < right)

n[left++] = n[right];

while (left < right && n[left] <= pivot)

left++;

if (left < right)

n[right--] = n[left];

}
n[left] = pivot;
return left;
}

public static void main(String[] args){
int[] a = {1,2,4,6,8,0,3,5,7,9};
System.out.println(partition(a,0,9));
QuickSort(a,0,9);
System.out.println(Arrays.toString(a));
// int[] b = {3,4,1,2,5};
// System.out.println(Partition(b,0,4));
// System.out.println(Arrays.toString(b));
}
}