Java实现常见排序算法-优快云博客

这篇博客介绍了几种经典的排序算法在Java中的实现，包括冒泡排序、选择排序、插入排序、归并排序、堆排序和快速排序。此外，还提到了希尔排序和桶排序，但未给出具体代码。最后，讨论了这些排序算法的时间复杂度和稳定性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

冒泡排序：

public class BubbleSort {
	public static void main(String [] args) {
		int arr[] = {1,5,3,7,4,9,6,8,0,2};
		int end = arr.length;
		if(arr == null || arr.length < 2) {
			return;
		}else {
			for(int i = end - 1; i > 0; i-- ) {
				for(int j = 0; j < i; j++) {
					if(arr[j] > arr[j+1]) {
						swap(arr, j, j+1);
					}
				}
			}
		}
		for(int k = 0; k < arr.length; k++) {
			System.out.print(arr[k]);
		}
	}

	private static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

选择排序：

public class SelectSort {
	public static void main(String [] args) {
		int arr[] = {1,5,3,7,4,9,6,8,0,2};
		if (arr==null || arr.length < 2) {
			return;
		} else {
			for (int i = 0; i < arr.length-1; i++) {
				int min = i;
				for (int j = i + 1; j < arr.length; j++) {
					min = arr[j] < arr[min]? j : min;
				}
				swap(arr, i, min);
			}
		}
		for(int k = 0; k < arr.length; k++) {
			System.out.print(arr[k]);
		}
	}

	private static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

插入排序：

public class InsertionSort {
	public static void main(String [] args) {
		int arr[] = {1,5,3,7,4,9,6,8,0,2};
		if(arr == null || arr.length < 2) {
			return;
		}else {
			for (int i = 1; i < arr.length; i++) {
				for (int j = i-1; j >= 0 && arr[j] > arr[j+1]; j--) {
					swap(arr, j, j+1);
				}
			}
		}
		for(int k = 0; k < arr.length; k++) {
			System.out.print(arr[k]);
		}
	}

	private static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
}

归并排序：

public class MergeSort {
	public static void main(String [] args) {
		int arr[] = {1,5,3,7,4,9,6,8,0,2};
		int L = 0;
		int R = arr.length-1;
		if (arr == null || arr.length < 2) {
			return; 
		}
		processSort(arr, L, R);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]  );
		}
	}

	private static void merge(int[] arr, int l, int mid, int r) {
		int [] help = new int[r-l+1];
		int i = 0;
		int p1 = l;
		int p2 = mid + 1;
		while(p1 <= mid && p2 <= r) {
			help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
		}
		while (p1<=mid) {
			help[i++] = arr[p1++];
		}
		while (p2 <= r) {
			help[i++] = arr[p2++];
		}
		for (int j = 0; j < help.length; j++) {
			arr[j+l] = help[j];
		}
	}

	private static void processSort(int[] arr, int l, int r) {
		if (l == r) {
			return;
		}
		int mid = l + ((r - l) >> 1);
			processSort(arr, l, mid);
			processSort(arr, mid+1, r);
			merge(arr, l, mid, r);
	}
}

堆排序：

public class HeapSort {
	public static void heapSort(int [] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {			
			heapInsert(arr, i);
		}
		int heapsize = arr.length;
		swap(arr, 0, --heapsize);
		while (heapsize > 0) {
			heapify(arr, 0, heapsize);
			swap(arr, 0, --heapsize);
		}
	}

	private static void heapify(int[] arr, int index, int heapsize) {
		int left = index*2+1;
		while(left < heapsize) {
			int largest = left + 1 < heapsize && arr[left+1] > arr[left]?
							left + 1 : left;
			largest = arr[largest] > arr[index] ? largest : index;
			if (largest == index) {
				break;
			}
			swap(arr, largest, index);
			index = largest;
			left = index*2 + 1;
		}
	}

	private static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}

	private static void heapInsert(int[] arr, int index) {
		while(arr[index] > arr[(index-1)/2]) {
			swap(arr, index, (index-1)/2);
			index = (index-1)/2;
		}
	}
	
	public static void main(String [] args) {
		int arr[] = {1,5,3,7,4,9,6,8,0,2};
		heapSort(arr);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]  );
		}
	}
}

快速排序：

public class QuickSort {
	private static void quickSort(int[] arr, int l, int r) {
		if (l < r) {
			swap(arr, l + (int)((Math.random() * (r - l + 1))), r);//优化原快速排序，不再选择最后一个位置进行比较
			int [] p = partitionNum(arr, l, r);//假定选择比较对象为K，则比K小的放左边，比K大的放右边，等于K的放中间
			quickSort(arr, l, p[0]-1);
			quickSort(arr, p[1]+1, r);
		}
	}

	private static int[] partitionNum(int[] arr, int l, int r) {
		int less = l - 1;
		int more = r;
		while (l < more) {
			if (arr[l] < arr[r]) {
				swap(arr, ++less, l++);
			}else if (arr[l] > arr[r]) {
				swap(arr, --more, l);
			}else {
				l++;
			}
		}
		swap(arr, more, r);
		return new int[] {less+1, more};
	}

	private static void swap(int[] arr, int i, int l) {
		int temp = arr[i];
		arr[i] = arr[l];
		arr[l] = temp;
	}
	public static void main(String [] agrs) {
		int[] arr = {1,5,3,7,4,9,6,8,0,2,5};
		int L = 0;
		int R = arr.length - 1;
		if (arr == null || arr.length < 2) {
			return;
		}
		int []p = partitionNum(arr, L, R);
		quickSort(arr, L, p[0] - 1);
		quickSort(arr, p[1] + 1, R);
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i]  );
		}
	}
}

import java.util.Arrays;

public class QuickSort {
public static void main(String[] args) {
final int MAX = 20;
int[] nums = new int[MAX];
for (int i = 0; i < MAX; i++) {
nums[i] = (int) (Math.random() * 10 + 5);
}
QuickSort sort = new QuickSort();
sort.quickSort(nums, 0, nums.length - 1);
System.out.println(Arrays.toString(nums));
}

public void quickSort(int[] nums, int low, int high) {
    if (low < high) {
        int middle = getMiddle(nums, low, high);
        //对左子序列进行排序
        quickSort(nums, low, middle - 1);
        //对右子序列进行排序
        quickSort(nums, middle + 1, high);
    }
}

private int getMiddle(int[] nums, int low, int high) {
    //当前数组的第一个元素作为中轴（基准）
    int temp = nums[low];
    while (low < high) {
        while (low < high && temp <= nums[high]) {
            high--;
        }
        nums[low] = nums[high];
        while (low < high && temp >= nums[low]) {
            low++;
        }
        nums[high] = nums[low];
    }
    nums[low] = temp;
    return low;
}

}
希尔排序：

import java.util.Arrays;

public class ShellSort {
    public static void main(String []args){
        int []arr ={1,4,2,7,9,8,3,6};
        shellsort(arr);
        System.out.println(Arrays.toString(arr));
    }
    
    public static void shellsort(int[] arr) {
		for (int step = arr.length/2; step > 0; step /=2) {
			for (int i = step; i < arr.length; i++) {				
				int j = i;
				int temp = arr[j];
				while (j-step >= 0&&temp < arr[j-step]) {
					arr[j - step] = arr[j];
					j = j - step;
				}
				arr[j] = temp;
			}
		}
	}
	
    public static void swap(int []arr,int a,int b){
        arr[a] = arr[a]+arr[b];
        arr[b] = arr[a]-arr[b];
        arr[a] = arr[a]-arr[b];
    }
}

桶排序：

public class BucketSort {
	public static void bucketSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < arr.length; i++) {
			max = Math.max(max, arr[i]);
		}
		int[] bucket = new int[max + 1];
		for (int i = 0; i < arr.length; i++) {
			bucket[arr[i]]++;//桶数组下标值为arr数组中的数据值，若已存在数据，则++
		}
		int i = 0;
		for (int j = 0; j < bucket.length; j++) {
			while (bucket[j]-- > 0) {//此位置有数据
				arr[i++] = j;
			}
		}
	}
	
	public static void main(String [] args) {
		int arr[] = {1,5,3,7,4,9,6,8,0,2};
		bucketSort(arr);
		for(int k = 0; k < arr.length; k++) {
			System.out.print(arr[k]);
		}
	}
}

时间复杂度及稳定性：
在这里插入图片描述