java--六种常用排序算法
下面的BaseSort是基础类：
package com.commontest.alorg;/**
* @author jiangfuqiang
* @version 2016/6/30.
* @see com.commontest.alorg
*/
import java.util.Random;
/**
* 数据
* @author jiangfuqiang
* @date 2016-06-30
*/
public abstract class BaseSort {
protected int[] initArray(int n) {
Random random = new Random();
int[] arrays = new int[n];
for (int i = 0; i < n; i++) {
arrays[i] = random.nextInt(n);
}
return arrays;
}
private long start = 0;
private long end = 0;
protected void printData(int[] arrays, boolean isBefore) {
if (isBefore) {
start = System.currentTimeMillis();
System.out.println("\nbefore sorted: ");
} else {
end = System.currentTimeMillis();
System.out.println("\nafter sorted: ");
}
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i] + " ");
}
if (!isBefore) {
System.out.println("\ntime is " + (end - start));
}
}
protected abstract void sort();
}
package com.commontest.alorg;/**
* @author jiangfuqiang
* @version 2016/6/30.
* @see com.commontest.alorg
*/
/**
* 冒泡排序 基本思想是:两两比较相邻记录的关键字,如果反序则交换 冒泡排序时间复杂度最好的情况为O(n),最坏的情况是O(n^2)
* @author jiangfuqiang
* @date 2016-06-30
*/
public class BubbleSort extends BaseSort{
public static void main(String[] args) {
BubbleSort bubbleSort = new BubbleSort();
bubbleSort.sort();
}
public void sort() {
int[] arrays = initArray(10000);
printData(arrays,true);
for (int i = 0; i < arrays.length - 1; i++) {
int a = arrays[i];
boolean flag = false;
for (int j = i + 1; j < arrays.length; j++) {
if (a > arrays[j]) {
int temp = arrays[j];
arrays[i] = arrays[j];
arrays[j] = a;
a = temp;
flag = true;
}
}
if (!flag) {
break;
}
}
printData(arrays,false);
}
}
package com.commontest.alorg;/**
* @author jiangfuqiang
* @version 2016/6/30.
* @see com.commontest.alorg
*/
/**
* 从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中从后向前扫描
如果被扫描的元素（已排序）大于新元素，将该元素后移一位
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置后
重复步骤2~5
* @author jiangfuqiang
* @date 2016-06-30
*/
public class InsertionSort extends BaseSort{
public static void main(String[] args) {
InsertionSort insertionSort = new InsertionSort();
insertionSort.sort();
}
@Override
protected void sort() {
int[] arrays = initArray(10);
printData(arrays,true);
for (int i = 1; i < arrays.length; i++) {
int a = arrays[i];
int index = i;
for (int j = i - 1; j >= 0; j--) {
if (a < arrays[j]) {
arrays[j + 1] = arrays[j];
index = j;
} else {
break;
}
}
if (index != i) {
arrays[index] = a;
}
}
printData(arrays,false);
}
}
package com.commontest.alorg;/**
* @author jiangfuqiang
* @version 2016/7/7.
* @see com.commontest.alorg
*/
/**
* 归并排序的思想就是先递归分解数组，再合并数组。
* @author jiangfuqiang
* @date 2016-07-07
*/
public class MergeSort extends BaseSort{
public static void main(String[] args) {
MergeSort mergeSort = new MergeSort();
mergeSort.sort();
}
@Override
protected void sort() {
int[] arrays = initArray(10);
printData(arrays,true);
arrays = merge(arrays,0,arrays.length);
printData(arrays,false);
}
private int[] merge(int[] arrays, int start, int length) {
if (arrays.length == 1) {
return arrays;
}
if (arrays.length == 2) {
if (arrays[0] > arrays[1]) {
int temp = arrays[0];
arrays[0] = arrays[1];
arrays[1] = temp;
}
return arrays;
}
int mid = arrays.length/2;
int[] tempLeftArrays = new int[mid];
System.arraycopy(arrays,0,tempLeftArrays,0,mid);
int[] tempRightArrays = new int[arrays.length - mid];
System.arraycopy(arrays,mid,tempRightArrays,0,tempRightArrays.length);
int[] leftArrays = merge(tempLeftArrays,0,mid);
int[] rightArrays = merge(tempRightArrays,mid,tempRightArrays.length);
int[] totalArrays = new int[leftArrays.length + rightArrays.length];
int left = 0;
int right = 0;
int index = 0;
while(right < rightArrays.length && left < leftArrays.length) {
if(leftArrays[left] < rightArrays[right]) {
totalArrays[index++] = leftArrays[left];
left++;
} else if(leftArrays[left] >= rightArrays[right]){
totalArrays[index++] = rightArrays[right];
right++;
}
}
if (left < leftArrays.length) {
while(left < leftArrays.length) {
totalArrays[index++] = leftArrays[left++];
}
}
if (right < rightArrays.length) {
while(right < rightArrays.length) {
totalArrays[index++] = rightArrays[right++];
}
}
return totalArrays;
}
}
package com.commontest.alorg;/**
* @author jiangfuqiang
* @version 2016/7/7.
* @see com.commontest.alorg
*/
/**
* 步骤： 从数列中挑出一个元素作为基准数。 分区过程，将比基准数大的放到右边，小于或等于它的数都放到左边。 再对左右区间递归执行第二步，直至各区间只有一个数。
* @author jiangfuqiang
* @date 2016-07-07
*/
public class QuickSort extends BaseSort {
public static void main(String[] args) {
QuickSort quickSort = new QuickSort();
quickSort.sort();
}
@Override
protected void sort() {
int[] arrays = initArray(10);
printData(arrays,true);
quickSort(arrays,0, arrays.length-1);
printData(arrays,false);
}
private void quickSort(int[] arrays, int left, int right) {
int lp = left;
int rp = right;
int key = arrays[left];
while(lp < rp) {
while(arrays[rp] >= key && lp < rp) {
rp -= 1;
}
while(arrays[lp] <= key && lp < rp) {
lp += 1;
}
int temp = arrays[lp];
arrays[lp] = arrays[rp];
arrays[rp] = temp;
}
if (lp > left) {
int temp = arrays[left];
arrays[left] = arrays[lp];
arrays[lp] = temp;
quickSort(arrays, left, lp - 1);
}
if (right > rp) {
quickSort(arrays, rp + 1, right);
}
}
}
package com.commontest.alorg;/**
* @author jiangfuqiang
* @version 2016/6/30.
* @see com.commontest.alorg
*/
/**
* 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。 以此类推，直到所有元素均排序完毕。
* @author jiangfuqiang
* @date 2016-06-30
*/
public class SelectionSort extends BaseSort {
public static void main(String[] args) {
SelectionSort selectionSort = new SelectionSort();
selectionSort.sort();
}
@Override
protected void sort() {
int[] arrays = initArray(10);
printData(arrays,true);
for (int i = 0; i < arrays.length - 1; i++) {
int index = i;
for (int j = i+1; j < arrays.length; j++) {
if (arrays[index] > arrays[j]) {
index = j;
}
}
if (index != i) {
int temp = arrays[index];
arrays[index] = arrays[i];
arrays[i] = temp;
}
}
printData(arrays,false);
}
}
package com.commontest.alorg;/**
* @author jiangfuqiang
* @version 2016/6/30.
* @see com.commontest.alorg
*/
/**
* 希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。
* 最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。
* @author jiangfuqiang
* @date 2016-06-30
*/
public class ShellSort extends BaseSort {
public static void main(String[] args) {
ShellSort shellSort = new ShellSort();
shellSort.sort();
}
@Override
protected void sort() {
int[] arrays = initArray(10);
printData(arrays,true);
int gap = arrays.length/2;
while(gap > 0) {
for(int i = gap; i < arrays.length; i++) {
int temp = arrays[i];
int j = i;
while(j >= gap && arrays[j-gap] > temp) {
arrays[j] = arrays[j-gap];
j = j- gap;
}
arrays[j] = temp;
}
gap = gap/2;
}
printData(arrays,false);
}
private int[] copySubArray(int[] arrays, int start, int end) {
int[] data = new int[end - start];
for (int i = 0; i < data.length; i++) {
data[i] = arrays[i + start];
}
return data;
}
private void sortArray(int[] arrays) {
for (int i = 1; i < arrays.length; i++) {
int a = arrays[i];
int index = i;
for (int j = i-1; j >=0; j--) {
if (a < arrays[j]) {
arrays[j+1] = arrays[j];
index = j;
}
}
arrays[index] = a;
}
}
}
浙公网安备 33010602011771号