快速排序基本思想:
通过一趟排序将要排序的数据分割成独立的两个部分,其中一部分的所有数据都比另外一部分的所有数据要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到排序
package com.lmh.sort;
import java.util.Arrays;
public class QuickSort {
public static void main(String[] args) {
int[] arr = {-9,78,23,0,-567,70,72,68,-1,900};
quickSort(arr,0, arr.length-1);
}
public static void quickSort(int[] arr,int left,int right){
int l = left;
int r = right;
//pivot中轴值
int pivot = arr[(left+right) /2] ;
int temp = 0;//临时变量
//while循环的目的是让比pivot值小的放到左边,大的放到右边
while (l<r){
//在pivot左边一直找,找到大于等于pivot的值才退出
while ( arr[l] < pivot){
l += 1;
}
//在pivot右边一直找,找到小于等于pivot的值才退出
while (arr[r] > pivot){
r-=1;
}
//如果l》= r 说明pivot的左右两的值,
// 已经按照左边全是小于等于pivot的值,右边全是大于
if ( l >= r){
break;
}
//交换
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
//如果交换完后发现arr[l]==pivot的值相等 .r--,前移
if (arr[l] == pivot){
r -= 1;
}
//如果交换完后发现arr[r]==pivot的值相等. l++,后移
if (arr[r] == pivot){
l += 1;
}
}
//如果l == r,必须l++ , r--,否则会发生栈溢出
if (l == r){
l +=1;
r -=1;
}
//向左递归
if (left < r){
quickSort(arr, left, r);
}
//向右递归
if (right>l){
quickSort(arr, l, right);
}
System.out.println(Arrays.toString(arr));
}
}
希尔排序介绍:
希尔排序是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序
基本思想:
希尔排序是把记录按下标的一定增量分组,对每组使用直接插入排序算法排序:随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件洽被分成一组,算法便终止。
交换式(需要很多时间)
package com.lmh.sort;
import java.util.Arrays;
public class ShellSort {
public static void main(String[] args) {
int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
shellSort(arr);
}
//希尔排序
public static void shellSort(int[] arr) {
//希尔排序
int temp = 0;
int count = 0;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
for (int i = gap; i < arr.length; i++) {
//遍历各组中所有的元素(共gap组,每组有个元素),步长gap
for (int j = i - gap; j >= 0; j -= gap) {
//如果当前元素大于步长后的哪个元素,说明交换
if (arr[j] > arr[j + gap]) {
temp = arr[j];
arr[j] = arr[j + gap];
arr[j + gap] = temp;
}
}
}
System.out.println("第" + (++count) + "轮排序后");
System.out.println(Arrays.toString(arr));
}
//第一轮
//因为第一轮排序,是将10个数据分成5组
for (int i = 5; i < arr.length; i++) {
//遍历各组中所有的元素(共5组,每组有2个元素),步长5
for (int j = i - 5; j >= 0; j -= 5) {
//如果当前元素大于步长后的哪个元素,说明交换
if (arr[j] > arr[j + 5]) {
temp = arr[j];
arr[j] = arr[j + 5];
arr[j + 5] = temp;
}
}
}
System.out.println("第一轮排序后");
System.out.println(Arrays.toString(arr));
//第二轮
//因为第二轮排序,是将5个数据分成5/2=2组
for (int i = 2; i < arr.length; i++) {
//遍历各组中所有的元素(共5组,每组有2个元素),步长5
for (int j = i - 2; j >= 0; j -= 2) {
//如果当前元素大于步长后的哪个元素,说明交换
if (arr[j] > arr[j + 2]) {
temp = arr[j];
arr[j] = arr[j + 2];
arr[j + 2] = temp;
}
}
}
System.out.println("第二轮排序后");
System.out.println(Arrays.toString(arr));
//第三轮
//因为第三轮排序,是将之前的没2组数据分成每2/2=1组
for (int i = 1; i < arr.length; i++) {
//遍历各组中所有的元素(共5组,每组有2个元素),步长5
for (int j = i - 1; j >= 0; j -= 1) {
//如果当前元素大于步长后的哪个元素,说明交换
if (arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
System.out.println("第一轮排序后");
System.out.println(Arrays.toString(arr));
}
}
移位式(很节约时间)
//移位法
public static void shellSort2(int[] arr) {
//仍然使用增量gap,并逐步的缩小增量
int count = 0;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
//从第gap个元素,逐个对其所在对组进行直接插入排序
for (int i = gap; i < arr.length; i++) {
int j = i;
int temp = arr[j];
if (arr[j] < arr[j - gap]) {
while (j - gap >= 0 && temp < arr[j - gap]) {
//移动
arr[j] = arr[j - gap];
j -= gap;
}
//当退出while后,就给temp找到插入的位置
arr[j] = temp;
}
}
System.out.println("第" + (++count) + "轮排序后");
System.out.println(Arrays.toString(arr));
}
}