十大排序算法Java

十大排序算法Java

一、冒泡排序

		    public void BubbleSort(int[] nums) {
				for (int i = 0; i < nums.length; i++) {
					for (int j = 0; j < nums.length - 1 - i; j++) {
						if (nums[j + 1] < nums[j]) {
							int temp = nums[j + 1];
							nums[j+1] = nums[j];
							nums[j] = temp;
						}
					}
				}	
			}

二、选择排序

		    public void ChoiceSort(int[] nums) {
				for (int i = 0; i < nums.length; i++) {
					int minIndex = i;
					for (int j = i; j < nums.length; j++) {
						if (nums[j] < nums[minIndex]) {
							minIndex = j;
						}
					}
					int temp = nums[minIndex];
					nums[minIndex] = nums[i];
					nums[i] = temp;
				}
			}

三、插入排序

		    public void InsertionSort(int[] nums) {
				int curIndex;
				for (int i = 0; i < nums.length - 1; i++) {
					int preIndex = i;
					curIndex = nums[preIndex + 1];
					
					while(preIndex >= 0 && curIndex < nums[preIndex]) {
						nums[preIndex + 1] = nums[preIndex];
						preIndex--;					
					}					
					nums[preIndex + 1] = curIndex;
				}
			}

四、快速排序

	public void sort(int[] nums, int start, int end) {
		int zoneIndex = partition(nums, start, end);

		if (zoneIndex > start) {
			sort(nums, start, zoneIndex - 1);
		}

		if (zoneIndex < end) {
			sort(nums, zoneIndex + 1, end);
		}
	}

	public int partition(int[] nums, int start, int end) {
		int pivot = (int) (start + Math.random() * (end - start + 1));
		int zoneIndex = start - 1;
		swap(nums, pivot, end);
		for (int i = start; i <= end; i++) {
			if (nums[i] <= nums[end]) {
				zoneIndex++;

				if (i > zoneIndex) {
					swap(nums, i, zoneIndex);
				}

			}

		}
		return zoneIndex;

	}

	public void swap(int[] nums, int i, int j) {
		int temp = nums[i];
		nums[i] = nums[j];
		nums[j] = temp;
	}

五、希尔排序

	public void ShellSort(int[] nums) {
		int n = nums.length;
		int curIndex,gap = n / 2;
		
		while(gap > 0) {
			for (int i = gap; i < n; i++) {
				curIndex = nums[i];
				int preIndex = i - gap;
				while(preIndex >= 0 &&  nums[preIndex] > curIndex) {
					nums[preIndex + gap] = nums[preIndex];
					preIndex -= gap;
				}
				nums[preIndex + gap] = curIndex;
			}
			gap /= 2;
		}
	}

六、归并排序

	public void mergesort(int[] nums) {
		int[] nums1 = MergeSort(nums);
		for (int i = 0; i < nums1.length; i++) {
			nums[i] = nums1[i];
		}
	}

	public int[] MergeSort(int[] nums) {
		int n = nums.length;
		int mid = n / 2;
		if (n < 2) {
			return nums;
		}
		int[] left = Arrays.copyOfRange(nums, 0, mid);
		int[] right = Arrays.copyOfRange(nums, mid, n);
		return merge(MergeSort(left), MergeSort(right));

	}

	public int[] merge(int[] left, int[] right) {
		int[] res = new int[left.length + right.length];
		for (int i = 0, index = 0, j = 0; index < res.length; index++) {
			if (i >= left.length) {
				res[index] = right[j++];
			} else if (j >= right.length) {
				res[index] = left[i++];
			} else if (left[i] > right[j]) {
				res[index] = right[j++];
			} else {
				res[index] = left[i++];
			}
		}
		return res;
	}

七、堆排序

int n;
public void maxheap(int[] nums) {
		n = nums.length;
		buildMaxHeap(nums);
		while(n > 0) {
			swap(nums, 0,n - 1);
			n--;
			adjustHeap(nums, 0);
		}
	}
	
	public void buildMaxHeap(int[] nums) {
		for (int i = (n/2 - 1); i >= 0; i--) {
			adjustHeap(nums,i);
		}
	}
	
	public void adjustHeap(int[] nums,int i) {
		int maxIndex = i;
		int left = 2*i + 1;
		int right = 2*(i + 1);
		
		if (left < n && nums[left] > nums[maxIndex]) {			
			maxIndex = left;
		}
		
		if (right < n && nums[right] > nums[maxIndex] && nums[right] > nums[left]) {
			maxIndex = right;
		}
		
		if (maxIndex != i) {
			swap(nums, maxIndex, i);
			adjustHeap(nums, maxIndex);
		}
		
	}

	public void swap(int[] nums, int i, int j) {
		int temp = nums[i];
		nums[i] = nums[j];
		nums[j] = temp;
	}

八、计数排序

	public void CountingSort(int[] nums) {
		int gap,min = nums[0],max = nums[0];
		for (int i = 0; i < nums.length; i++) {
			if (nums[i] > max) {
				max = nums[i];
			}
			if (nums[i] < min) {
				min = nums[i];
			}
		}
		
		gap = 0 - min;
		int[] counter = new int[max - min +1 ];
		Arrays.fill(counter, 0);
		
		for (int i = 0; i < nums.length; i++) {
				counter[nums[i] + gap]++;
		}
		
		int index = 0;
		int i = 0;
		
		while(index < nums.length) {
			if (counter[i] != 0 ) {
				nums[index] = i -gap;
				counter[i] --;
				index++;
			}else {
				i++;
			}
		}		
	}

九、桶排序

public void bucketsort(int[] nums) {
		ArrayList<Integer> temp = new ArrayList<Integer>();
		for (int i = 0; i < nums.length; i++) {
			 temp.add(nums[i]) ;
		}
		
		temp = BucketSort(temp, 2);
		
		for (int i = 0; i < temp.size(); i++) {
			 nums[i] = temp.get(i) ;
		}
	}
	
	
	public ArrayList<Integer> BucketSort(ArrayList<Integer> list,int bucketGap) {	
		if (list == null || list.size() < 2) {
			return list;
		}		
		int max = list.get(0),min = list.get(0);
		for (int i = 0; i < list.size(); i++) {
			if (list.get(i) > max ) {
				max = list.get(i);
			}
			
			if (list.get(i) < min) {
				min = list.get(i);
			}
		}
		
		int bucketNum = (max - min)/bucketGap + 1;
		
		List<ArrayList<Integer>> bucket = new ArrayList<ArrayList<Integer>>();
		ArrayList<Integer> res = new ArrayList<Integer>();
		for (int i = 0; i < bucketNum; i++) {
			bucket.add(new ArrayList<Integer>()); 			
		}
		
		for (int i = 0; i < list.size(); i++) {
			bucket.get((list.get(i) - min)/bucketGap).add(list.get(i));
		}
		
		for (int i = 0; i < bucketNum; i++) {
			if (bucketGap == 1) {
				for (int j = 0; j < bucket.get(i).size(); j++) {
					res.add(bucket.get(i).get(j));
				}
			}else {
				if (bucketNum == 1) {
					bucketGap--;
				}
				ArrayList<Integer> temp = BucketSort(bucket.get(i), bucketGap);
				for (int j = 0; j < temp.size(); j++) {
					res.add(temp.get(j));
				}
			}
			
		}
		return res;
	}

十、基数排序

	public void RadixSort(int[] nums) {		
		int max = nums[0];
		for (int i = 0; i < nums.length; i++) {
			max = Math.max(max, nums[i]);
		}
		
		int maxNum = 0;
		while(max != 0) {
			max /= 10;
			maxNum++;
		}
		
		int a = 10,b = 1;
		ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
		
		for (int i = 0; i < 10; i++) {
			list.add(new ArrayList<Integer>());
		}
		
		for (int i = 0; i < maxNum; i++,a*=10,b*=10) {
			
			for (int j = 0; j < nums.length; j++) {
				int num = (nums[j] % a)/b;
				list.get(num).add(nums[j]);
			}
			int index = 0;
			for (int j = 0; j < list.size(); j++) {
				for (int k = 0; k < list.get(j).size(); k++) {
					nums[index++] = list.get(j).get(k);
					list.get(j).clear();
				}
			}
			
		}
		
	}