2. 程式人生 > >八大內部排序演算法總結

八大內部排序演算法總結

阿新 • • 發佈：2019-01-29

插入排序：直接插入排序

思想：將資料分為兩組，一組為已排序序列，另一組為待排序序列，不斷的將待排序序列加入已排序序列。最終得到的是已排序序列。

public class InsertionSort implements Sort{

	public void sort(int a[]){
		for(int i = 1; i < a.length; i++){
			int t = a[i], j = i-1;
			while(j >= 0 && a[j] > t){
				a[j+1] = a[j];
				j--;
			}
			a[j+1] = t;
		}
		SortUtils.print(a);
	}
	public static void main(String[] args) {
		new InsertionSort().sort(SortUtils.generate(10));
	}
}

插入排序：Shell排序

思想：帶有間隔的插入排序，插入排序每次的消耗都在比較當前元素在已排序元素中的位置，所以希爾排序要減少這種比較，它使用帶有間隔的插入排序方式，每次選取n/2作為間隔，然後跳著比較資料，直到間隔為1結束。

public class ShellSort implements Sort{

	public static void shellNSort(int a[], int k) {
		for (int t = 0; t < k; t++) {
			for (int i = t + k; i < a.length; i += k) {
				int p = a[i], j = i - k;
				while (j >= 0 && p < a[j]) {
					a[j + k] = a[j];
					j -= k;
				}
				a[j + k] = p;
			}
		}
	}

	public void sort(int a[]) {
		int k = a.length / 2;
		while (k >= 1) {
			shellNSort(a, k);
			k /= 2;
		}
		SortUtils.print(a);
	}

	public static void main(String[] args) {
		new ShellSort().sort(new int[] { 49, 38, 65, 97, 76, 13, 27, 48, 55, 4 });
	}

}
選擇排序：直接選擇排序

思想：每次選擇最大或者最小的元素，直到資料結尾，之後再交換最大元素和末尾元素，這之後按照同樣的方法找到次小元素，直到只剩下一個元素為止。

public class SelectionSort implements Sort{

	public void sort(int a[]){
		for(int i = 1; i < a.length;i++){
			int max = 0;
			for(int j = 1; j <= a.length-i;j++){
				if(a[j] > a[max]){
					max = j;
				}
			}
			SortUtils.swap(a, max, a.length-i);
			//SortUtils.print(a);
		}
		SortUtils.print(a);
	}
	public static void main(String[] args) {
		new SelectionSort().sort(SortUtils.generate(4091,10));
	}
}

選擇排序：堆排序

思想：構建堆資料結構，每次從堆中選出堆頂元素放到堆的末尾，這樣當所有的堆頂元素都被放到末尾過一次，整體就是有序的。此外如果是大頂堆，則會是從小到大的順序，如果是小頂堆，則會是從大到小的順序。

public class HeapSort implements Sort{
	private static int left(int i) {
		return 2 * i + 1;
	}

	private static int right(int i) {
		return 2 * i + 2;
	}

	public static void maxHeapIFY(int a[], int size, int index) {
		int l = left(index), r = right(index);
		int largest = index;
		if (l < size && a[l] > a[index]) {
			largest = l;
		}
		if (r < size && a[r] > a[largest]) {
			largest = r;
		}
		if (largest != index) {
			SortUtils.swap(a, index, largest);
			maxHeapIFY(a, size, largest);
		}
	}

	public static void buildMaxHeap(int a[]) {
		for (int i = a.length / 2; i >= 0; i--) {
			maxHeapIFY(a, a.length, i);
		}
	}

	public void sort(int a[]) {
		buildMaxHeap(a);
		for (int i = a.length - 1; i > 0; i--) {
			SortUtils.swap(a, 0, i);
			maxHeapIFY(a, i, 0);
		}
		SortUtils.print(a);
	}

	public static void main(String[] args) {
		new HeapSort().sort(new int[] { 9, 9, 7, 6, 5, 4, 3, 2, 1 });
	}

}

交換排序：氣泡排序

思想：每次比較相鄰的元素，如果第一個元素比第二個大，那麼交換它們的順序，依次如此，直到末尾，下一次對從頭到倒數第二個元素做這些操作，直到最後只剩下一個元素為止。

public class BubbleSort implements Sort {

	public void sort(int a[]) {
		for (int i = a.length - 1; i > 0; i--) {
			boolean flag = false;
			for (int j = 0; j < i; j++) {
				if (a[j] > a[j + 1]) {
					SortUtils.swap(a, j, j + 1);
					flag = true;
				}
			}
			if (!flag) {
				break;
			}

		}
		SortUtils.print(a);
	}

	public static void main(String[] args) {
		new BubbleSort().sort(new int[] { 9, 8, 7, 6, 5, 4, 3, 2, 1 });
	}

}

交換排序：快速排序

思想：從資料中選出一個元素，每次找到這個元素應該在的位置，使得這個元素左邊都比它小，右邊都比它大，然後將資料分兩組，這個元素左邊一組，右邊一組，按照這個方式，每次都能找到一個元素應該在的位置，最終所有元素就在自己的位置了。

public class QuickSort implements Sort{

	public static int partition(int a[], int low, int high) {
		int p = a[low];
		while (low < high) {
			while (low < high && a[high] >= p) high--;
			a[low] = a[high];
			while (low < high && a[low] <= p) low++;
			a[high] = a[low];
		}
		a[low] = p;
		return low;
	}

	public static void quicksort(int a[], int low, int high) {
		if (low < high) {
			int p = partition(a, low, high);
			quicksort(a, low, p - 1);
			quicksort(a, p + 1, high);
		}
	}

	public void sort(int a[]) {
		quicksort(a, 0, a.length - 1);
		SortUtils.print(a);
	}

	public static void main(String[] args) {
		new QuickSort().sort(new int[] { 4, 1, 2, 3, 5, 7, 8, 5, 9 });
	}

}

歸併排序

思想：每次將資料分為兩部分，左邊一部分右邊一部分，分別做歸併排序，然後將兩部分合並起來，遞迴的做這個操作，最終整個陣列就是已排序序列。 
public class MergeSort implements Sort{

	public static void merge(int a[], int low, int p, int high){
		int lenC = p-low+1;
		int lenD = high-p;
		int c[] = new int[lenC+1];
		int d[] = new int[lenD+1];
		
		for(int i = 0; i < lenC;i++){
			c[i] = a[low + i];
		}
		for(int i = 0; i < lenD;i++){
			d[i] = a[p + 1 + i];
		}
		c[lenC] = d[lenD] = Integer.MAX_VALUE;
		
		int indexC = 0, indexD = 0;
		for(int i = low; i <= high; i++){
			if(c[indexC] < d[indexD]){
				a[i] = c[indexC++];
			} else {
				a[i] = d[indexD++];
			}
		}
	}
	public static void mergesort(int a[], int low, int high){
		if(low < high){
			int mid = (low + high) / 2;
			mergesort(a, low, mid);
			mergesort(a, mid+1, high);
			
			merge(a, low, mid, high);
		}
	}
	public void sort(int a[]){
		mergesort(a, 0, a.length-1);
		SortUtils.print(a);
	}
	public static void main(String[] args) {
		new MergeSort().sort(new int[]{4,3,2,1,9,8,7,6,5});
	}

}

基數排序（這個演算法寫的不太好，效率不高）

思想：按照每個位的資料大小排序，如個位，按照大小排序，按十位的大小排序，按百位的大小排序（注意必須使用穩定的排序演算法，也就是說排序過程中元素的相對順序不變），這樣排序後，從頭到尾取出所有的元素即排序好的序列。

public class RadixSort implements Sort{

	public static class Entry {
		int value;
		Entry next;
		Entry pre;

		public Entry(int value) {
			this(value, null, null);
		}

		public Entry(int value, Entry pre, Entry next) {
			this.value = value;
			this.pre = pre;
			this.next = next;
		}

		public void addNext(Entry e) {
			e.next = next;
			e.pre = this;
			if (next != null)
				next.pre = e;
			next = e;
		}

		public void addPre(Entry e) {
			e.next = this;
			e.pre = pre;
			if (pre != null)
				pre.next = e;
			pre = e;
		}

		public Entry remove() {
			if (pre != null)
				pre.next = next;
			if (next != null)
				next.pre = pre;
			pre = null;
			Entry n = next;
			next = null;
			return n;
		}

		public void clear() {
			while (next != null) {
				next = next.remove();
			}
		}

		public void swap(Entry e) {
			if (e == null)
				return;
			value = (e.value + value) - (e.value = value);
		}

		public String toString() {
			return String.valueOf(value);
		}
	}

	private static Entry bucketsA[] = new Entry[10];
	private static Entry bucketsB[] = new Entry[10];
	static {
		for (int i = 0; i < 10; i++) {
			bucketsA[i] = new Entry(0);
			bucketsB[i] = new Entry(0);
		}
	}

	public static void addToList(Entry head, Entry e, int t) {
		Entry p = head;
		while (p.next != null) {
			if ((p.next.value / t) % 10 > (e.value / t) % 10) {
				p.next.addPre(e);
				break;
			}
			p = p.next;
		}
		if (p.next == null && (p.value / t) % 10 <= (e.value / t) % 10) {
			p.addNext(e);
		}
	}

	public static int[] CollectResult(int a[]) {
		int index = 0;
		for (int j = 0; j < bucketsA.length; j++) {
			Entry p = bucketsA[j].next;
			while (p != null) {
				a[index++] = p.value;
				p = p.next;
			}
		}
		return a;
	}

	public void sort(int a[], int radix) {
		for (int j = 0; j < bucketsA.length; j++) {
			bucketsA[j].clear();
		}
		for (int i = 0; i < a.length; i++) {
			addToList(bucketsA[a[i] % 10], new Entry(a[i]), 1);
		}

		int t = 10;
		for (int i = 1; i < radix; i++) {
			Entry[] bucketsC = bucketsA;// swap
			bucketsA = bucketsB;
			bucketsB = bucketsC;

			for (int j = 0; j < bucketsA.length; j++) {
				bucketsA[j].clear();
			}
			for (int j = 0; j < bucketsB.length; j++) {
				while (bucketsB[j].next != null) {
					Entry e = bucketsB[j].next;
					bucketsB[j].next.remove();
					addToList(bucketsA[(e.value / t) % 10], e, t);
				}
			}
			t *= 10;
		}

		CollectResult(a);
		SortUtils.print(a);
	}
	
	public void sort(int a[]){
		sort(a, 3);
	}

	public static void main(String[] args) {
		new RadixSort().sort(new int[] { 329, 457, 657, 839, 436, 720, 355 }, 3);
	}
}
這裡使用了兩組桶，其效果可能會比正常的基數排序要差，但是基數的期望複雜度是O(n)。

總結

類別

排序方法

 時間複雜度

空間複雜度

穩定性

平均

最好

最壞

插入排序

直接插入

O(n2)

O(n)

O(n2)

O(1)

穩定

Shell排序

O(n1.3)

O(n)

O(n2)

O(1)

不穩定

選擇排序

直接選擇

O(n2)

O(n2)

O(n2)

O(1)

不穩定

堆排序

O(nlgn)

O(nlgn)

O(nlgn)

O(1)

不穩定

交換排序

氣泡排序

O(n2)

O(n)

O(n2)

O(1)

穩定

快速排序

O(nlgn)

O(nlgn)

O(n2)

O(nlgn)

不穩定

歸併排序

O(nlgn)

O(nlgn)

O(nlgn)

n

穩定

基數排序

O(d(r+n))

O(d(n+rd))

O(d(r+n))

O(rd+n)

穩定

r表示關鍵字的基數，d表示長度，n表示關鍵字個數。

穩定排序包括：直接插入、氣泡排序、歸併排序、基數排序；基數排序依賴於穩定的排序方式。

附：

public interface Sort {
	public void sort(int a[]);
}
public class SortUtils {

	public static void swap(int a[], int i, int j){
		a[i] = (a[i] + a[j])-(a[j]=a[i]);
	}
	public static void print(int a[]){
		System.out.println(Arrays.toString(a));
	}
	public static Random static_rand = new Random();
	public static Random rand = new Random(37);
	
	public static int[] generate(int seed, int len){
		static_rand.setSeed(seed);
		int a[] = new int[len];
		for(int i =0 ; i < len; i++){
			a[i] = static_rand.nextInt(1000);
		}
		//System.out.print("Generated: ");
		print(a);
		return a;
	}
	public static int[] generate(int len){
		int a[] = new int[len];
		for(int i =0 ; i < len; i++){
			a[i] = rand.nextInt(1000);
		}
		//System.out.print("Generated: ");
		print(a);
		return a;
	}
}


相關推薦

八大內部排序演算法總結

插入排序：直接插入排序 思想：將資料分為兩組，一組為已排序序列，另一組為待排序序列，不斷的將待排序序列加入已排序序列。最終得到的是已排序序列。 public class InsertionSort implements Sort{ public void sort(i

八種常用內部排序演算法總結

在公司實習了，由於公司的性質，以後的工作中用到演算法&資料結構的知識可能會很少，很想把以前學的資料結構&演算法的知識系統的回憶一下，但由於時間的原因，再加上我一直都很喜歡排序演算法的思想。近期主要就排序這個問題做一個系統的介紹：氣泡排序，簡單選擇排序，直接插

王道資料結構內部排序演算法總結

首先看一下內部排序分類以及各個演算法的時間複雜度和空間複雜度   一、插入排序 　　 　　1、直接插入排序(Straight Insertion Sort)的基本思想是：把n個待排序的元素看成為一個有序表和一個無序表。開始時有序表中只包含1個元素，無序表中包含有n-1個元素，排序過程

七大內部排序演算法總結（插入排序、希爾排序、氣泡排序、簡單選擇排序、快速排序、歸併排序、堆排序）

寫在前面：         排序是計算機程式設計中的一種重要操作，它的功能是將一個數據元素的任意序列，重新排列成一個按關鍵字有序的序列。因此排序掌握各種排序演算法非常重要。對下面介紹的各個排序，我們假定所有排序的關鍵字都是整數、對傳入函式的引數預設是已經檢查好了的。只

八大內部排序演算法（上）-冒泡、直接插入、簡單選擇、快速

八大內部排序演算法（上）冒泡、直接插入、簡單選擇、快速 排序分為內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需

內部排序演算法要點總結

  本文將對於插入排序、氣泡排序、選擇排序、希爾排序、歸併排序、快速排序、堆排序、分配排序和基數排序做歸納總結，通過一些題目來掌握各大內部排序演算法的過程和特點，而不涉及具體的程式碼。 考點 排序演算法的穩定性（題1） 排序演算法的空間效率（題2）

Java 八大排序演算法總結

概述 排序有內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。我們這裡說說八大排序就是內部排序。 插入排序 思想：每步將一個待排序的記錄，按其順序碼大小插入到前面已經排序的子序列

幾個內部排序演算法的總結（JAVA版）

插入排序 1、直接插入排序 public void insertSort(int[] a){ for(int i=0;i<a.length;i++){ int key=a[i]; int pos=i; while(pos>0&&a

十大排序演算法總結 內部排序

目錄 排序測試模板 一、氣泡排序 總體思想 程式設計思想 複雜度及優缺點 優化 二、選擇排序 總體思想 ​程式設計思想 複雜度及優缺點 三、插入排序 總體思想 程式設計思想 複雜度及優缺點 四、希爾排序 總體思想 程式設計思想

python對八大常見排序演算法的總結和實現以及時間消耗分析

    昨晚上開始總結了一下常見的幾種排序演算法，由於之前我已經寫了好幾篇排序的演算法的相關博文了現在總結一下的話可以說是很方便的，這裡的目的是為了更加完整詳盡的總結一下這些排序演算法，為了複習基礎的東西，從氣泡排序、直接插入排序、選擇排序、歸併排序、希爾排序、桶排序、堆排

八大排序演算法總結與Java實現

概述 因為健忘，加上對各種排序演算法理解不深刻，過段時間面對排序就蒙了。所以決定對我們常見的這幾種排序演算法進行統一總結，強行學習。首先羅列一下常見的十大排序演算法： 直接插入排序 希爾排序 簡單選擇排序 堆排序 氣泡排

八大排序演算法總結

插入排序1.直接插入排序 原理：將陣列分為無序區和有序區兩個區，然後不斷將無序區的第一個元素按大小順序插入到有序區中去，最終將所有無序區元素都移動到有序區完成排序。 要點：設立哨兵，作為臨時儲存和判斷陣列邊界之用。 實現： Void InsertSort(Node L[],i

八大排序演算法總結Python實現

排序演算法 直接插入排序 直接插入排序是一種簡單的排序演算法，基本操作是將一個記錄插入到一個有序結果集中，並且在插入資料過程中將前面大於或者小於(取決於升序或者降序)當前要插入的資料向後移動。 def InsertSort(array):

經典內部排序演算法學習總結(演算法思想、視覺化、Java程式碼實現、改進、複雜度分析、穩定性分析)

一、什麼是排序演算法？ 排序，顧名思義，就是按照一定的規則排列事物，使之彼此間有序 而排序演算法所要做的工作，就是將資料按照人為制定的比較規則排列好，使資料處於彼此間有序的狀態。 二、為什麼要進行排序？ 那為什麼要將資料排序呢？計算機處理速度這麼

JavaScript實現八大內部排序算法

clas 建立 所有 rec 等於 function log 使用 並排 註：基數排序中：r是關鍵字的基數，d是長度，n是關鍵字的個數 1.插入排序 基本思想：在序號i之前的元素(0到i-1)已經排好序，本趟需要找到i對應的元素x (此時即arr[i]) 的正確位置

Java 常用排序演算法總結

氣泡排序：  /*冒泡演算法*/ public class BubbleSort { public static void bubble_sort(int[] arr){ int temp; for(int i = 0; i < arr

11、【演算法】排序演算法總結

常見排序演算法總結 一、氣泡排序 1、定義     氣泡排序是一種比較簡單的排序演算法，它會遍歷若干次要排序的數列，每次便利時，它都會從前往後依次的比較兩個相鄰的數的大小；如果前者比後者大，則交換它們的位置。     這樣一次遍歷之後，最大的元素就在數列的末尾了。採用相同的方法在

資料結構——排序與查詢（4）——常見的內部排序演算法大全

這篇博文就讓我水一次，這兩天量產部落格，偷個懶，不過下面的文章都是我自己寫的： 插入排序演算法及其分析 簡單的氣泡排序及其分析 希爾排序及其分析 快速排序演算法及其分析 合併排序演算法及其分析 堆排序演算法及其分析 選擇排序演算法及其分析

【初賽】各種排序演算法總結

一、演算法評價 排序方法 平均時間 最好時間 最壞時間 氣泡排序(穩定) O(n^2) O(n) O(n^2) 選擇排序(

Various sorting algorithms 排序演算法總結分析

Contents Overview 0-file I/O 1-bubble sort algorithm description Overview There exists so many kinds of