Inhaltsverzeichnis
direkte Einfügungssortierung
Konzept
Einfügungssortierung ist eine Art Einfügungssortierung. Fügen Sie die zu sortierenden Zahlen nacheinander in eine geordnete Reihenfolge ein, die sortiert wurde, bis alle Datensätze eingefügt sind und eine neue geordnete Reihenfolge erhalten wird. Wenn wir beispielsweise Poker spielen, nutzen wir diese Idee.
Algorithmus-Idee
1. Beginnend mit dem ersten Element wird das Element standardmäßig sortiert.
2. Nehmen Sie das nächste Element heraus und scannen Sie es in der sortierten Elementreihenfolge von hinten nach vorne.
3. Wenn das neue herausgenommene Element größer ist als das gescannte Element in der Sequenz (bereits sortiert), verschieben Sie das gescannte Element an die nächste Position.
4. Wiederholen Sie Schritt 3, bis Sie die Position gefunden haben, an der das sortierte Element kleiner oder gleich dem neuen Element ist.
5. Fügen Sie das neue Element an der nächsten Position der Position ein (in besonderen Fällen ist das neue Element kleiner als das sortierte Element).
6. Wiederholen Sie die Schritte 2 bis 5.
Animation
Code wird wie folgt angezeigt
public static void insertSort(int[] a){
int i = 0;
int j = 0;
int tmp = 0;
for(i = 1;i<a.length;i++){ //此层循环代表待插入的新元素 从第二个元素开始
tmp = a[i]; //存储新元素，防止被覆盖
j = i-1;
while(j>=0 && a[j] > tmp){
a[j+1] = a[j]; //已排序元素向后移动
j--;
}
if(j==i-1) continue; //说明没有进入while循环，该元素目前是最大的，不用排序
if(j == -1 || (j>=0 && a[j]<=tmp)){ j==-1 //表示该元素目前最小
a[j+1] = tmp;
}
}
}♣①: Da beim Einfügen in einem Durchgang zunächst eine Zahl in ein geordnetes Intervall eingefügt werden soll, vorausgesetzt, dass die letzte Position des Intervalls (j) ist, ist die Position der einzufügenden Daten (j). +1), Da diese Daten während des Einfügevorgangs möglicherweise überschrieben werden, speichern wir sie zunächst mit einer Variablen tmp,
♣②: Vergleichen Sie dann die einzufügenden Daten mit der letzten Zahl im geordneten Intervall, da die Standardauswahl eine aufsteigende Reihenfolge ist. Wenn Sie auf Daten stoßen, die größer als tmp sind, müssen Sie ein [Ende] nach hinten und dann mit vorwärts verschieben der Index, bis (j<0) oder eine Zahl, die kleiner oder gleich den einzufügenden Daten ist, mitten im Vergleichsprozess gefunden wird, stoppen Sie den Vergleich und springen Sie aus dieser Schleife. Beim Verschieben der Daten wird nach dem Ende ein Leerzeichen angezeigt. Führen Sie zu diesem Zeitpunkt a[j + 1] = tmp aus, um die einzufügenden Daten in eine geordnete Reihe einzufügen und die Reihenfolge beizubehalten.
Komplexitätsanalyse
Zeitkomplexität am besten O(n) am schlechtesten O(n^2)
Die Raumkomplexität O(1) gilt nur für einen Raum in tmp
Die Stabilität ist stabil, da bei zwei identischen Zahlen die später hinzugefügten immer zurückliegen
Zeitkomplexitätstest
Versuchen wir als Nächstes, es mit vielen Daten zu testen.
int[] a = new int[10_0000]; //100.000 Datentest
1. Die Funktion orderArray wird implementiert, um eine grundlegende geordnete Sequenz zu generieren, die von klein nach groß angeordnet ist.
public static void orderArray(int[] a) {
for (int i = 0; i < a.length; i++) {
a[i] = i;
}
}2. Die Funktion notOrderArray generiert eine umgekehrte Reihenfolge, die vom größten zum kleinsten sortiert ist.
public static void notOrderArray(int[] a) {
for (int i = 0; i < a.length; i++) {
a[i] = a.length-i;
}
}3. Die Funktion randomArray generiert ein zufälliges ungeordnetes Array.
public static void randomArray(int[] a) {
Random random = new Random();
for (int i = 0; i < a.length; i++) {
a[i] = random.nextInt(10_0000);
}
}4. Die Funktion testInsertSort testet den Rückgabewert von System.currentTimeMillis() in Millisekunden.
public static void testInsertSort(int[] a){
int[] tmpArray = Arrays.copyOf(a,a.length);
long startTime = System.currentTimeMillis(); //注意用long接收
insertSort(tmpArray);
long endTime = System.currentTimeMillis(); //返回单位是毫秒
System.out.println("直接插入排序耗时："+(endTime-startTime));
}5. Ausführung des Hauptfunktionsaufrufs
public static void main(String[] args) {
int[] a = new int[10_0000];
//有序
System.out.println("基本有序数列");
orderArray(a);
testInsertSort(a);
//倒序
System.out.println("逆序数列");
notOrderArray(a);
testInsertSort(a);
//随机乱序
System.out.println("无序数列");
randomArray(a);
testInsertSort(a);
}
Operationsergebnis
Vollständiger Code
import java.util.Random;
public class sort {
public static void main(String[] args) {
int[] a = new int[10_0000];
//有序 1 2 3 4 5 ...
System.out.println("基本有序数列");
orderArray(a);
testInsertSort(a);
//逆序 9 8 7 6 5 ...
System.out.println("逆序数列");
notOrderArray(a);
testInsertSort(a);
//乱序
System.out.println("无序数列");
randomArray(a);
testInsertSort(a);
}
//插入排序
//时间复杂度 最好O(n) 最坏O(n^2)
//空间复杂度 O(1) 因为只申请了 tmp 一个空间
//稳定性 稳定 因为当有两个相同的数字时 后面加入的总在后面
public static void insertSort(int[] a) {
int i = 0;
int j = 0;
int tmp = 0;
for(i = 1;i<a.length;i++) {
tmp = a[i];
j = i-1;
while(j>=0 && a[j] > tmp) {
a[j+1] = a[j];
j--;
}
if(j==i-1) continue;
if(j == -1 || (j>=0 && a[j]<=tmp)) {
a[j+1] = tmp;
}
}
}
//生成有序数组 从小到大排列
public static void orderArray(int[] a) {
for (int i = 0; i < a.length; i++) {
a[i] = i;
}
}
//n无序 其实就是从大到小排列
public static void notOrderArray(int[] a) {
for (int i = 0; i < a.length; i++) {
a[i] = a.length-i;
}
}
//乱序 随机生成序列
public static void randomArray(int[] a) {
Random random = new Random();
for (int i = 0; i < a.length; i++) {
a[i] = random.nextInt(10_0000);
}
}
//大量数据测试
public static void testInsertSort(int[] a){
int[] tmpArray = Arrays.copyOf(a,a.length);
long startTime = System.currentTimeMillis(); //注意用long接收
insertSort(tmpArray);
long endTime = System.currentTimeMillis();
System.out.println("直接插入排序耗时："+(endTime-startTime));
}
}