十大排序算法的Java实现
回头补一补细节和思想
import java.util.*;
public class SortAlgorithm {
public static void main(String[] args) {
int[] a = new int[]{9,3,14,-1,-8,1,0,21,-4,-9,12,9};
RadixSort.sort(a);
System.out.println(Arrays.toString(a));
}
}
class BubbleSort {
static void sort(int[] nums) {
int left = -1;
int right = nums.length;
int tag;
int tmp;
while (left < right) {
tag = -1;
for (int i = left+2; i < right; i++) {
if (nums[i] < nums[i-1]) {
tmp = nums[i];
nums[i] = nums[i-1];
nums[i-1] = tmp;
tag = i;
}
}
if (tag == -1) {
return;
} else {
right = tag;
}
tag = nums.length;
for (int i = right-2; i > left; i--) {
if (nums[i] > nums[i+1]) {
tmp = nums[i];
nums[i] = nums[i+1];
nums[i+1] = tmp;
tag = i;
}
}
if (tag == nums.length) {
return;
} else {
left = tag;
}
}
}
}
class QuickSort {
static void sort(int[] nums) {
sort(nums, 0, nums.length-1);
}
static void sort(int[] nums, int startIndex, int endIndex) {
if (startIndex >= endIndex) {
return;
}
int pivot = Partition2(nums, startIndex, endIndex);
sort(nums, startIndex, pivot-1);
sort(nums, pivot+1, endIndex);
}
private static int Partition(int[] nums, int left, int right) {
int startIndex = left;
int pivot = nums[left];
int tmp;
left++;
while (left < right) {
while (left < right && nums[right] > pivot) {
right--;
}
while (left < right && nums[left] <= pivot) {
left++;
}
tmp = nums[left];
nums[left] = nums[right];
nums[right] = tmp;
}
tmp = nums[startIndex];
nums[startIndex] = nums[left];
nums[left] = tmp;
return left;
}
private static int Partition2(int[] nums, int left, int right) {
int startIndex = left;
int pivot = nums[left];
int index = right;
int tmp;
while (left <= index) {
if (nums[left] > pivot) {
tmp = nums[left];
nums[left] = nums[index];
nums[index] = tmp;
index--;
continue;
} else {
left++;
}
}
nums[startIndex] = nums[index];
nums[index] = pivot;
return index;
}
}
class StraigntSelectSort {
static void sort(int[] nums) {
int minIndex;
int tmp;
for (int i=0; i<nums.length-1; i++) {
minIndex = i;
for (int j=i; j<nums.length; j++) {
if (nums[j] < nums[minIndex]) {
minIndex = j;
}
}
tmp = nums[i];
nums[i] = nums[minIndex];
nums[minIndex] = tmp;
}
}
}
class HeapSort {
public static void sort(int[] nums) {
buildHeap(nums);
for (int i=0; i<nums.length-1; i++) {
swap(nums, 0, nums.length-1-i);
adjustHeap(nums, 0, nums.length-2-i);
}
}
private static void buildHeap(int[] nums) {
for (int i=(nums.length-2)/2; i>=0; i--) {
adjustHeap(nums, i, nums.length-1);
}
}
private static void adjustHeap(int[] nums, int i, int size) {
if (2*i+1 > size) {
return;
}
int maxIndex = i;
if (2*i+1 <= size && nums[maxIndex] < nums[2*i+1]) {
maxIndex = 2*i+1;
}
if (2*(i+1) <= size && nums[maxIndex] < nums[2*(i+1)]) {
maxIndex = 2*(i+1);
}
if (maxIndex != i) {
swap(nums, i, maxIndex);
adjustHeap(nums, maxIndex, size);
}
}
private static void swap(int[] nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
}
class StraightInsertionSort {
static void sort(int[] nums) {
int tmp;
for (int i=0; i<nums.length; i++) {
tmp = nums[i];
for (int j=i-1; j>=0; j--) {
if (nums[j] > tmp) {
nums[j+1] = nums[j];
} else {
nums[j+1] = tmp;
break;
}
if (j==0) {
nums[j] = tmp;
}
}
}
}
}
class ShellSort {
public static void sort(int[] nums){
int k = nums.length/2;
while (k >= 1) {
for (int i=k; i<nums.length; i++) {
int tmp=nums[i];
int j=i-k;
while (j>=0 && nums[j] > tmp) {
nums[j+k] = nums[j];
j-=k;
}
nums[j+k] = tmp;
}
k/=2;
}
}
}
class MergeSort {
public static void sort(int[] nums) {
int[] res = mergeSortRecursion(nums, 0, nums.length-1);
for (int i=0; i<nums.length; i++) {
nums[i] = res[i];
}
}
public static void sort2(int[] nums) {
int k=1;
int right;
int mid;
int size;
int leftEndIndex;
int rightEndIndex;
while (k < nums.length) {
for (int left=0; left<nums.length; left+=2*k) {
mid=0;
right=left+k;
leftEndIndex = right;
size=left+2*k-1>=nums.length?nums.length-left:2*k;
rightEndIndex = left+size;
int[] tmp = new int[size];
while (left < leftEndIndex && right < rightEndIndex) {
if (nums[left] <= nums[right]) {
tmp[mid]=nums[left];
mid++;
left++;
} else {
tmp[mid]=nums[right];
mid++;
right++;
}
}
while (left < leftEndIndex) {
tmp[mid]=nums[left];
left++;
mid++;
}
while (right < rightEndIndex) {
tmp[mid]=nums[right];
right++;
mid++;
}
for (int i=leftEndIndex-k; i<rightEndIndex; i++) {
nums[i] = tmp[i-left+k];
}
left = leftEndIndex-k;
}
k=2*k;
}
}
public static int[] mergeSortRecursion(int[] nums, int left,
int right) {
if (right == left) {
int[] res = {nums[left]};
return res;
}
int[] leftNums = mergeSortRecursion(nums, left, (right+left)/2);
int[] rightNums = mergeSortRecursion(nums, (right+left)/2+1, right);
int[] res = merge(leftNums, rightNums);
return res;
}
public static int[] merge(int[] left, int[] right) {
int leftIndex = 0;
int rightIndex = 0;
int mergeIndex = 0;
int[] res = new int[left.length+right.length];
while (leftIndex < left.length && rightIndex < right.length) {
if (left[leftIndex] <= right[rightIndex]) {
res[mergeIndex] = left[leftIndex];
leftIndex++;
mergeIndex++;
} else {
res[mergeIndex] = right[rightIndex];
rightIndex++;
mergeIndex++;
}
}
if (leftIndex == left.length) {
while (rightIndex < right.length) {
res[mergeIndex] = right[rightIndex];
mergeIndex++;
rightIndex++;
}
} else {
while (leftIndex < left.length) {
res[mergeIndex] = left[leftIndex];
mergeIndex++;
leftIndex++;
}
}
return res;
}
}
class CountingSort {
public static void sort(int[] nums) {
int max=nums[0];
int min=nums[0];
int[] res = new int[nums.length];
for (int i:nums) {
if (i>max) {
max=i;
}
if (i<min) {
min=i;
}
}
int k=max-min+1;
int[] tag = new int[k];
for (int i:nums) {
tag[i-min]++;
}
for (int i=1; i<tag.length; i++) {
tag[i]+=tag[i-1];
}
for (int i=nums.length-1; i>=0; i--) {
res[tag[nums[i]-min]-1] = nums[i];
tag[nums[i]-min]--;
}
for (int i=0; i<nums.length; i++) {
nums[i] = res[i];
}
}
}
class BucketSort {
public static void sort(int[] nums) {
int min = nums[0];
int max = nums[0];
int tmp;
for (int i:nums) {
if (i > max) {
max = i;
}
if (i < min) {
min = i;
}
}
int bucketNum = (max-min)/10;
List<LinkedList<Integer>> bucketList = new ArrayList<>();
for (int i=0; i<bucketNum; i++) {
bucketList.add(new LinkedList<Integer>());
}
for (int i=0; i<nums.length; i++) {
tmp = (nums[i]-min)/(max-min);
bucketList.get(tmp).add(nums[i]);
}
for (int i=0; i<bucketNum; i++) {
Collections.sort(bucketList.get(i));
}
int resIndex=0;
for (int i=0; i<bucketNum; i++) {
while (bucketList.get(i).size()>0) {
nums[resIndex] = bucketList.get(i).remove();
resIndex++;
}
}
}
}
class RadixSort {
public static void sort(int[] nums) {
List<LinkedList<Integer>> bucketList = new ArrayList<>();
for (int i=0; i<10; i++) {
bucketList.add(new LinkedList<>());
}
int max=nums[0];
int min=nums[0];
for (int i:nums) {
if (i > max) {
max = i;
}
if (i < min) {
min = i;
}
}
int maxTmp=1;
while ((max-min)/(10*maxTmp)!=0) {
maxTmp++;
}
int tmp=1;
int resIndex;
while (tmp<=maxTmp) {
for (int i:nums) {
// System.out.println();
bucketList.get((i-min)%(int)Math.pow(10, tmp)/(int)Math.pow(10, tmp-1)).add(i-min);
}
resIndex=0;
for (int i=0; i<10; i++) {
while (bucketList.get(i).size()!=0) {
nums[resIndex]=bucketList.get(i).poll()+min;
resIndex++;
}
}
tmp++;
}
}
}