快速排序
public class quickSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int [] arr={1,3,9,4,10,5,18,6,2,100,34,32,98,48,12,0,34,89};
sort(arr,0,arr.length-1);
for(int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
private static void sort(int[] array, int lo, int hi) {
if(lo>=hi){
return ;
}
int index=partition(array,lo,hi);
sort(array,lo,index-1);
sort(array,index+1,hi);
}
private static int partition(int[] array, int lo, int hi) {
int key=array[lo];
while(lo<hi){
while(hi>lo&&array[hi]>=key){//从后半部分向前扫描
hi--;
}
array[lo]=array[hi];
while(hi>lo&&array[lo]<=key){//从前半部分向后扫描
lo++;
}
array[hi]=array[lo];
}
array[hi]=key;
return hi;
}
}
运行结果
冒泡排序
private static void bubbleSort(int[] arr) {
// TODO Auto-generated method stub
int temp=0;
boolean flag=true;
while(flag){
flag=false;
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
flag=true;
}
}
}
}
}
选择排序
public static void selectSort(int[] a) {
if (a == null || a.length <= 0) {
return;
}
for (int i = 0; i < a.length; i++) {
int temp = a[i];
int flag = i; // 将当前下标定义为最小值下标
for (int j = i + 1; j < a.length; j++) {
if (a[j] < temp) {// a[j] < temp 从小到大排序;a[j] > temp 从大到小排序
temp = a[j];
flag = j; // 如果有小于当前最小值的关键字将此关键字的下标赋值给flag
}
}
if (flag != i) {
a[flag] = a[i];
a[i] = temp;
}
}
}
运行结果
堆排序:
堆是一种完全二叉树结构。在排序的过程中,元素是存储在一维数组中的,那么知道一个元素的位置i(起始位置为0),若存在左右子节点,则子节点的位置分别为2i+1,2i+2。父节点为(i-1)/2取整。
算法过程(大顶堆为例)
- class ArrayUtils {
- public static void printArray(int[] array) {
- System.out.print("{");
- for (int i = 0; i < array.length; i++) {
- System.out.print(array[i]);
- if (i < array.length - 1) {
- System.out.print(", ");
- }
- }
- System.out.println("}");
- }
- public static void exchangeElements(int[] array, int index1, int index2) {
- int temp = array[index1];
- array[index1] = array[index2];
- array[index2] = temp;
- }
- }
- public class HeapSort {
- public static void main(String[] args) {
- int[] array = { 12, 13, 5,24, 43, 4, 21, 33, 0, -12, -44, 18, 6 };
- System.out.println("初始序列");
- ArrayUtils.printArray(array);
- //创建堆
- heapSort(array);
- System.out.println("堆排序后结果");
- //升序输出
- ArrayUtils.printArray(array);
- }
- public static void heapSort(int[] array) {
- //如果数组中的元素为空,或者数组中的元素个数不超过1,则返回
- if (array == null || array.length <= 1) {
- return;
- }
- //创建大顶堆
- buildMaxHeap(array);
- //创建完大顶堆之后,数组中的第一个元素应该是堆中最大的元素,将最大的元素,与堆中最后一个叶子节点进行交换
- for (int i = array.length - 1; i >= 1; i--) {
- ArrayUtils.exchangeElements(array, 0, i);
- //输出堆排序的过程
- for(int t=0;t<array.length;t++){
- System.out.print(array[t]+",");
- }
- System.out.println();
- maxHeap(array, i, 0);
- }
- }
- private static void buildMaxHeap(int[] array) {
- System.out.println("建堆运行了1次");
- if (array == null || array.length <= 1) {
- return;
- }
- //从第一个非叶子节点开始调整
- int half = array.length / 2;
- for (int i = half; i >= 0; i--) {
- maxHeap(array, array.length, i);
- }
- }
- private static void maxHeap(int[] array, int heapSize, int index) {
- int left = index * 2 + 1;
- int right = index * 2 + 2;
- int largest = index;
- //左节点较大
- if (left < heapSize && array[left] > array[index]) {
- largest = left;
- }
- //右节点较大
- if (right < heapSize && array[right] > array[largest]) {
- largest = right;
- }
- //不满足大顶堆,需要交换
- if (index != largest) {
- ArrayUtils.exchangeElements(array, index, largest);
- //有可能会破坏堆的下层结构,需自上到下进行修正
- maxHeap(array, heapSize, largest);
- }
- }
- }
运行结果