基本排序算法java实现

来源：互联网发布：手机编程用什么软件编辑：程序博客网时间：2024/05/19 18:42

七种基于比较排序算法记忆口诀：冒择入希速归堆（冒失选择入口的希望是快速回归马王堆）

冒泡排序：

public class BubbleSort {

public static void sort(long[] arr) {
long tmp = 0;
for(int i = 0; i < arr.length - 1; i++) {
for(int j = arr.length - 1; j > i; j--) {
if(arr[j] < arr[j - 1]) {
//进行交换
tmp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = tmp;
} //从右边开始，每次循环最小值向左沉下去
}
}
}
}

选择排序：

public class SelectionSort {

public static void sort(long[] arr) {
int k = 0;
long tmp = 0;
for(int i = 0; i < arr.length - 1; i++) {
k = i;
for(int j = i; j < arr.length; j++) {
if(arr[j] < arr[k]) {
k = j; //k始终指向最小的元素
}
}
tmp = arr[i];
arr[i] = arr[k];
arr[k] = tmp;
} //右边未排序比左边已排序的最大值要大
}
}

插入排序：

public class InsertSort {

public static void sort(long[] arr) {
long tmp = 0;

for(int i = 1; i < arr.length; i++) {
tmp = arr[i];
int j = i;
while(j > 0 && arr[j-1] >= tmp) {
arr[j] = arr[j - 1];
j--;
}
arr[j] = tmp;
} //拿未排序的第一个数值跟已排序的从右往左比较，找到比其小的位置插入
}

｝

希尔排序（插入排序改进版）：

public class ShellSort {
/**
* 排序方法
*/
public static void sort(long[] arr) {
//初始化一个间隔
int h = 1;
//计算最大间隔
while(h < arr.length / 3) {
h = h * 3 + 1;
}

while(h > 0) {
//进行插入排序
long tmp = 0;
for(int i = h; i < arr.length; i++) {
tmp = arr[i];
int j = i;
while(j > h - 1 && arr[j - h] >= tmp) {
arr[j] = arr[j - h];
j -= h;
}
arr[j] = tmp;
}
//减小间隔
h = (h - 1) / 3;
}
}
}

快速排序（冒泡排序改进版）：

public class QuickSort {

/**
* 划分数组
*/
public static int partition(long arr[],int left, int right,long point) {
int leftPtr = left - 1;
int rightPtr = right;
while(true) {
//循环,将比关键字小的留在左端
while(leftPtr < rightPtr && arr[++leftPtr] < point);
//循环，将比关键字大的留在右端
while(rightPtr > leftPtr && arr[--rightPtr] > point);
if(leftPtr >= rightPtr) {
break;
} else {
long tmp = arr[leftPtr];
arr[leftPtr] = arr[rightPtr];
arr[rightPtr] = tmp;
}
}
//将关键字和当前leftPtr所指的这一个进行交换
long tmp = arr[leftPtr];
arr[leftPtr] = arr[right];
arr[right] = tmp;
return leftPtr;
}

public static void sort(long[] arr, int left, int right) {
if(right - left <= 0) {
return;
} else {
//设置关键字
long point = arr[right];
//获得切入点，同时对数组进行划分
int partition = partition(arr, left, right, point);
//对左边的子数组进行快速排序
sort(arr,left,partition - 1);
//对右边的子数组进行快速排序
sort(arr,partition + 1, right);
}
}
}

归并排序：

public class MergeSort {
/**
* 归并排序
* 简介:将两个（或两个以上）有序表合并成一个新的有序表即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列
* 时间复杂度为O(nlogn)
* 稳定排序方式
* @param nums 待排序数组
* @return 输出有序数组
*/
public static int[] sort(int[] nums, int low, int high) {
int mid = (low + high) / 2;
if (low < high) {
// 左边
sort(nums, low, mid);
// 右边
sort(nums, mid + 1, high);
// 左右归并
merge(nums, low, mid, high);
}
return nums;
}
public static void merge(int[] nums, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int i = low;// 左指针
int j = mid + 1;// 右指针
int k = 0;
// 把较小的数先移到新数组中
while (i <= mid && j <= high) {
if (nums[i] < nums[j]) {
temp[k++] = nums[i++];
} else {
temp[k++] = nums[j++];
}
}
// 把左边剩余的数移入数组
while (i <= mid) {
temp[k++] = nums[i++];
}
// 把右边边剩余的数移入数组
while (j <= high) {
temp[k++] = nums[j++];
}
// 把新数组中的数覆盖nums数组
for (int k2 = 0; k2 < temp.length; k2++) {
nums[k2 + low] = temp[k2];
}
}
}

堆排序：

public class Heap
{
public void heap_sort(int[] arrays,int e){
if(e>0){
init_sort(arrays,e);//初始化堆，找出最大的放在堆顶
// snp(arrays);
arrays[0]=arrays[e]+arrays[0];
arrays[e]=arrays[0]-arrays[e];
arrays[0]=arrays[0]-arrays[e];
// snp(arrays);
heap_sort(arrays, e-1);
}else{
snp(arrays);
}
}

public void snp(int[] arrays){
for(int i=0;i<arrays.length;i++){
System.out.print(arrays[i]+" ");
}
System.out.println();
}

public void init_sort(int[] arrays,int e){
int m=(e+1)/2;
for(int i=0;i<m;i++){
boolean flag=build_heap(arrays,e,i);
//如果孩子之间有交换，就要重新开始
if(flag){
i=-1;
}

}


}
//返回一个标记，如果有根与孩子交换就要重新从顶根开始查找不满足最大堆树结构
public boolean build_heap(int arrays[],int e,int i){
int l_child=2*i+1;//左孩子
int r_child=2*i+2;//右孩子
if(r_child>e){ //判断是否有右孩子，没有的话直接比较，小于交换
if(arrays[i]<arrays[l_child]){
arrays[i]=arrays[i]+arrays[l_child];
arrays[l_child]=arrays[i]-arrays[l_child];
arrays[i]=arrays[i]-arrays[l_child];
return true;
}else{
return false;
}
}
//在根与两个孩子之间找出最大的那个值进行交换
if(arrays[i]<arrays[l_child]){
if(arrays[l_child]>arrays[r_child]){
//交换根与左孩子的值
arrays[i]=arrays[i]+arrays[l_child];
arrays[l_child]=arrays[i]-arrays[l_child];
arrays[i]=arrays[i]-arrays[l_child];
return true;
}else{
//交换根与右孩子的值
arrays[i]=arrays[i]+arrays[r_child];
arrays[r_child]=arrays[i]-arrays[r_child];
arrays[i]=arrays[i]-arrays[r_child];
return true;
}
}else if(arrays[i]<arrays[r_child]){
//交换根与右孩子的值
arrays[i]=arrays[i]+arrays[r_child];
arrays[r_child]=arrays[i]-arrays[r_child];
arrays[i]=arrays[i]-arrays[r_child];
return true;
}
return false;

}
}

基于非比较排序算法：计数排序，桶排序，基数排序

计数排序：时间复杂度O(n)

public class CountSort {
    static int[] countSort(int[] a, int range/*数组元素的范围*/){
        int count[] = new int[range];
        for(int i = 0; i < a.length; i++) {
            count[a[i]]++;
        }
        for(int i = 1; i < count.length; i++) {
            count[i] += count[i-1];
        }
        int sortArr[] = new int[a.length];
        for(int i = 0; i < sortArr.length; i++) {
            count[a[i]]--;
            sortArr[count[a[i]]] = a[i];
        }
        return sortArr;
    }
}

0 0