[Hausaufgaben für Pädagogen] C&C++-Lineartabellentraining

[Hausaufgaben für Pädagogen] C&C++-Lineartabellentraining

Wenn Sie zum ersten Mal mit verknüpften Listen in Berührung kommen, sind Sie möglicherweise verwirrt. Der Zweifel liegt darin, dass es besser ist als Arrays. Möglicherweise spüren Sie es, nachdem Sie dieses praktische Training geschrieben haben, oder Sie haben möglicherweise immer noch keine Ahnung, nachdem Sie diese 10 Fragen geschrieben haben. Lassen Sie uns am Ende dieses Artikels ein wenig darüber sprechen.

T1 erstellt nacheinander eine lineare Tabelle

Man kann sagen, dass diese Frage den Ton des gesamten Trainings vorgibt. Die Struktur enthält ihre eigenen Daten$data$Japanischer einzelner Finger$next$, wir verwenden diese Zwei Dinge, um eine verknüpfte Liste zu erstellen.
Gleichzeitig setzen wir standardmäßig: $next$为$NULL$。

#include "linearList.h"

node *insertTail(node *h, node *t)
{
    
    
    // 请在此添加代码，补全函数insertTail
    /********** Begin *********/
	node *p = h;
	if (h == NULL) return t;
	while (p -> next != NULL) p = p -> next;
	p -> next = t;
	return h;

    /********** End **********/
}

T2 erstellt eine lineare Tabelle in umgekehrter Reihenfolge

Das ist einfach, weil wir eine einseitig verknüpfte Liste erstellen.

#include "linearList.h"

node * insertHead(node *h, node *t)
{
    
    
    // 请在此添加代码，补全函数insertHead
    /********** Begin *********/
	t -> next = h;
	return t;

    /********** End **********/
}

T3-Sortierung zum Erstellen einer linearen Tabelle

Es ist relativ einfach, sich das vorzustellen. Betrachten wir die letzte Situation: Finden Sie den Ort, an dem die aktuellen Daten gespeichert sind, und stopfen Sie dann die aktuellen Daten an diesen Ort.
Dann brauchen wir auch $P\to next$和$p$，在写$while$ Ein Teil der Zeit- und Ereigniskarte.

#include "linearList.h"

node * insertSort(node *h, node *t)
{
    
    
    // 请在此添加代码，补全函数insertSort
    /********** Begin *********/
	node *p = h;
	if (h == NULL) return t;
	if (t -> data <= h -> data) return insertHead(h, t);
	if (h -> next == NULL) return insertTail(h, t);
	bool flag = false;
	while (p -> next -> data <= t -> data) {
    
    
		if (p -> next -> next == NULL) {
    
    
			flag = true;
			break;
		}
		p = p -> next;
	}
	if (flag) return insertTail(h, t);
	t -> next = p -> next;
	p -> next = t;
	return h;
    /********** End **********/
}

T4 Elemente finden

Das ist es, Chido Ryo$T_3$Wie es geht, der Rest ist einfacher.
Sie müssen die verknüpfte Liste nur der Reihe nach vom Kopf der Tabelle aufzählen und dann suchen.

#include "linearList.h"

node * search(node * h, int num)
{
    
    
    // 请在此添加代码，补全函数search
    /********** Begin *********/
	node *p = h;
	if (h == NULL) return NULL;
	while (p != NULL) {
    
    
		if (p -> data == num) return p;
		p = p -> next;
	}
	return NULL;
    /********** End **********/
}

T5 löscht den Knoten an der angegebenen Position

Da der angegebene Ort gelöscht ist, muss der letzte Schritt darin bestehen, einen solchen zu finden$p$，然后有$P\to next=P\to next\to next$, also bin ich< /span>$while$ Außerdem gibt es nur eine Ergänzung zum Meeting.

#include "linearList.h"

node * delAt(node * h, int i)
{
    
    
    // 请在此添加代码，补全函数delAt
    /********** Begin *********/
	node *p = h;
	if (!i) return h -> next;
	int cnt = 1;
	while (p -> next -> next != NULL) {
    
    
		if (cnt == i) {
    
    
			p -> next = p -> next -> next;
			return h;
		}
		cnt ++ ;
		p = p -> next;
	}
	p -> next = NULL;
	return h;
    /********** End **********/
}

T6 löscht Knoten, die bestimmte Daten enthalten

Eine solche Löschung wird etwas komplizierter sein und$T_5$一样$while$ 's Beurteilungssitzungsvergleich.

#include "linearList.h"

node * delHas(node * h, int n)
{
    
    
    // 请在此添加代码，补全函数delHas
    /********** Begin *********/
	if (h -> data == n) return h -> next;
	node *p = h;
	while (p -> next -> next != NULL) {
    
    
		if (p -> next -> data == n) {
    
    
			p -> next = p -> next -> next;
			return h;
		}
		p = p -> next;
	}
	if (p -> next -> data == n) {
    
    
		p -> next = NULL;
		return h;
	}

    /********** End **********/
}

T7-Lineartischlänge

Dies ist relativ einfach. Beginnen Sie einfach mit der Traversierung am Kopfende des Tisches und zählen Sie dann.

#include "linearList.h"

int listLength(node * h)
{
    
    
    // 请在此添加代码，补全函数listLength
    /********** Begin *********/
	int ans = 0;
	while (h != NULL) ans ++ , h = h -> next;
	return ans;

    /********** End **********/
}

T8-Lineartischanwendung 1: Stapel

Der Stapel ist eine Datenstruktur, gekennzeichnet durch$FILO\left(FirstinLastout\right)$ .
Es ist jedoch nicht notwendig, die tatsächliche Anzeige zu verwenden, aber es ist notwendig, dass wir sie überprüfen.

#include "mstack.h"
// 函数empty：判断栈sk是否为空
// 参数：sk-栈
// 返回值：true-sk为空，false-sk不为空
bool empty(intStack sk)
{
    
    
    // 请在此添加代码，补全函数empty
    /********** Begin *********/
	return sk == NULL ? true : false;


    /********** End **********/
}
// 函数pop：弹栈
// 参数：sk-栈，传引用，弹栈可能会改变sk的值
// 返回值：弹栈的弹出的整数，如果栈空，返回-1
int pop(intStack &sk)
{
    
    
    // 请在此添加代码，补全函数pop
    /********** Begin *********/
	intStack p = sk;
	if (empty(sk)) return 0;
	if (p -> next == NULL) {
    
    
		int re = p -> data;
		sk = NULL;
		return re;
	}
	while (p -> next -> next != NULL) p = p -> next;
	int re = p -> next -> data;
	p -> next = NULL;
	return re;


    /********** End **********/
}
// 函数push：压栈，将整数n压入栈sk中
// 参数：sk-栈，传引用，压栈会改变sk的值，n-要压栈的整数
// 返回值：无，采用链表实现栈，只要还有内存，压栈都会成功
void push(intStack &sk, int n)
{
    
    
    // 请在此添加代码，补全函数push
    /********** Begin *********/
	intStack p = sk;
	if (empty(sk)) {
    
    
		sk = new node;
		sk -> data = n;
		sk -> next = NULL;
		return;
	}
	while (p -> next != NULL) p = p -> next;
	p -> next = new node;
	p -> next -> next = NULL;
	p -> next -> data = n;
    /********** End **********/
}

T9-Lineartabellenanwendung 2: Warteschlange

队列的特点是$FIFO\left(FirstinFirstout\right)$
Es ist eine Frontalfunktion für das tatsächliche Auftreten und außerdem einfach.

#include "mqueue.h"

// 函数queueEmpty：判断队列iq是否为空
// 参数：iq-整数队列
// 返回值：true-队列iq为空，false-iq不为空
bool queueEmpty(intQueue iq)
{
    
    
    // 请在此添加代码，补全函数queueEmpty
    /********** Begin *********/ 
	return iq == NULL ? true : false;


    /********** End **********/
}
// 函数enQueue：将整数num入列到iq
// 参数：iq-整数队列，传引用，入列有可能改变队列头指针，num-入列的整数
// 返回值：无，只要还有内存，入列总会成功
void enQueue(intQueue &iq, int num)
{
    
    
    // 请在此添加代码，补全函数enQueue
    /********** Begin *********/
	node *t = new node;
	t -> data = num;
	t -> next = NULL;
	iq = insertTail(iq, t);


    /********** End **********/
}
// 函数deQueue：出列
// 参数：iq-整数队列，传引用，出列有可能改变队列头指针
// 返回值：出列结点的数据，如果队列为空，返回-1
int deQueue(intQueue &iq)
{
    
    
    // 请在此添加代码，补全函数deQueue
    /********** Begin *********/
	if (queueEmpty(iq)) return -1;
	int re = iq -> data;
	iq = delAt(iq, 0);
	return re;


    /********** End **********/
}

T10 Lineartisch Anwendung 3: Einstellen

Collection ist eine sehr leistungsstarke Datenstruktur in $C++$的$Es\; gibt\; auch\; Sets\; in\; STL$, aber die Sets dort verwenden Rot- und Schwarzabgleich . Was Tree implementiert, ist eine sehr leistungsfähige Datenstruktur.
Die Sammlung hier ist sehr einfach. Sie kann nur die Reihenfolge garantieren und kann nicht wiederholt werden. Die zusätzliche Komplexität des Vorgangs kann nicht garantiert werden.

#include "mset.h"

// 函数unionSet：求集合a和b的并集
// 参数：a-集合，b-集合
// 返回值：集合（集合a和b的并集）
intSet unionSet(intSet a, intSet b)
{
    
    
    // 请在此添加代码，补全函数unionSet
    /********** Begin *********/
	node *re = NULL;
	node *p[2] = {
    
    a, b};
	// printList(p[0]), printList(p[1]);
	for (int i = 0; i < 2; i ++ ) {
    
    
		while (p[i] != NULL) {
    
    
			if (search(re, p[i] -> data) == NULL) {
    
    
				node *mdl = new node;
				mdl -> next = NULL, mdl -> data = p[i] -> data;
				re = insertSort(re, mdl);
			}
			p[i] = p[i] -> next;
		}
	}
	return re;
 
    /********** End **********/
}
// 函数intersection：求集合a和b的交集
// 参数：a-集合，b-集合
// 返回值：集合（集合a和b的交集）
intSet intersection(intSet a, intSet b)
{
    
    
    // 请在此添加代码，补全函数intersection
    /********** Begin *********/
	node *re = NULL;
	node *p = a;
	while (p != NULL) {
    
    
		if ((search(b, p -> data) != NULL) && (search(re, p -> data) == NULL)) {
    
    
			node *mdl = new node;
			mdl -> data = p -> data, mdl -> next = NULL;
			re = insertSort(re, mdl);
		}
		p = p -> next;
	}
	return re;
    /********** End **********/
}
// 函数addElement：在集合is中增加元素num
// 参数：is-集合，num-要增加的元素
// 返回值：无
void addElement(intSet &is, int num)
{
    
    
    // 请在此添加代码，补全函数addElement
    /********** Begin *********/
	node *t = new node;
	t -> next = NULL, t -> data = num;
	if (search(is, num) == NULL) is = insertSort(is, t);


    /********** End **********/
}

---

Nachdem wir die gesamte Schulung geschrieben haben, sprechen wir über verknüpfte Listen. Viele Leute haben dieses Problem auch mit dem Autor besprochen und ihre Ansichten sind ähnlich – sie verstehen die Verwendung dieser verknüpften Liste nicht.
Dabei geht es um das Thema Komplexität. Ich werde dazu später einen separaten Artikel veröffentlichen. $Blog$Lass uns reden.
Beispielsweise möchten wir an einer bestimmten Position im Array auf das $i$ Element, direkter Zugriff$Arra{y}_i$ kann sofort abgeschlossen werden, d. h. $O\left(1\right)$.
Aber die verknüpfte Liste funktioniert nicht. Sie muss vom Kopf der Tabelle an zählen, bis der Zähler $i$, wenn Sie jedes Mal nach dem letzten Element suchen, dann hängt dieser Vorgang mit der Länge der Tabelle zusammen, wir nennen ihn $O\left(n\right)$.
Jetzt ist die Leistung von Arrays viel besser.
Zu diesem Zeitpunkt überlegen wir, ein Element an der angegebenen Position einzufügen. Im Fall eines Arrays muss jedes Element nach diesem Element um eine Position nach hinten verschoben werden. Die Komplexität beträgt $O\left(n\right)$, aber die verknüpfte Liste Nur dieser Vorgang kann durch Ändern des Zeigers seines vorherigen Elements abgeschlossen werden.
Dies ist die Bedeutung verknüpfter Listen. Bestimmte Vorgänge werden viel einfacher, wenn verknüpfte Listen verwendet werden.
Es gibt noch viele weitere Möglichkeiten, wie zum Beispiel die dynamische Zuweisung von Speicherplatz, was auch mit verknüpften Listen problemlos möglich ist. $C++$Sato Yuichi 个$STL$schreiendes Zahlenpaar$vector$ ist bei Verwendung ein Array, das automatisch Speicherplatz zuweisen kann. Seine interne Implementierung wird mithilfe der Idee von Zeiger + verknüpfter Liste implementiert.
Wenn Sie dies sehen, haben Sie möglicherweise Fragen: Gibt es eine Datenstruktur, die die Vorteile von Arrays und verknüpften Listen berücksichtigen kann? Kann auf Elemente in kurzer Zeit zugegriffen werden oder können Elemente in kurzer Zeit eingefügt und gelöscht werden?
Natürlich ist es möglich, einige leistungsstarke Datenstrukturen sind einfach zu erstellen, $splay$和非旋转$Treap$ Der durch dargestellte ausgeglichene Baum ist ausreichend.
Hier stellen wir eine leicht verständliche blockverknüpfte Liste vor.
Wir werden eine Länge von $n$s Zahlengruppe$\sqrt{N}$ aufeinanderfolgende Blöcke, offensichtlich gibt es $\sqrt{N}$ Elemente. In jedem Block befindet sich ein Array, und die Blöcke sind mithilfe der Idee einer verknüpften Liste verbunden. Diese Datenstruktur ist eine blockverknüpfte Liste.
Beispiel: Abfrage: Wir müssen nur beim Tabellenkopf beginnen und einmal springen $\sqrt{N}$ Elemente, wenn ein Element in einem Block gefunden wird, weil der Block direkt ein Array ist $O\left(1\right)$Sofort verfügbar, 复杂Grad Es ist eine chiropraktische Funktion$O\left(\sqrt{N}\right)$; Um beispielsweise ein Element einzufügen, müssen Sie nur den entsprechenden Block finden und die Elemente im Block verschieben. Da das Einfügen eines Elements in einen bestimmten Block keine Auswirkungen auf andere Blöcke hat, da Blöcke nur durch verknüpfte Listen verbunden sind, beträgt die Komplexität auch$O\left(\sqrt{N}\right)$.
Das ist alles. Tatsächlich hat jede Datenstruktur immer ihren Platz, um zu glänzen, auch wenn ihre Rolle nur darin besteht, zu einer leistungsfähigeren Datenstruktur zu führen.
Schreiben Sie es am Ende des Artikels statt am Anfang. Die Bedeutung ist, dass die Leser es selbst herausfinden müssen. Die meisten Leute lesen diese erweiterten Dinge nicht gerne (flüstern