Tags: Java 数据结构 算法
Auteur: mäxchen
Version: V1.0.0
Date: 01/04/2020
1. individuellement reliés liste - Principe
Si nous voulons maintenant stocker certains articles, mais pas assez d' espace pour mettre bas tous les articles à usage unique (ordinateurs utilisent un magasin de la chaîne parce que la mémoire ne suffit pas à expliquer ... à l' avance, nous discuterons des raisons spécifiques pour le suivi), tout en nous fixant parce que la taille du cerveau est très faible, afin d'économiser de l' espace, que de se rappeler l'emplacement d'un élément. A ce stade , nous avons trouvé une solution très intelligente: chacun placé un élément dans un article publié sur un petit morceau de papier lors de l' enregistrement des articles marqués sous un point là - bas, rappelez - vous l'emplacement du premier élément, à la recherche le temps de commencer à chercher le premier élément, nous pouvons trouver un petit morceau de papier à travers tous les éléments, ce qui est un magasin de la chaîne. Liste lorsque mis en œuvre comme une table linéaire non seulement pour stocker des données, et l' adresse de l'élément suivant de données, définissant ainsi un premier noeud de classe (le nœud), et des informations de l' élément enregistré à une position d'un article, l'article lui - même nous appelé le champ de données, un petit morceau de postes du papier stocké dans l'information d'adresse est appelé champ de référence. diagramme de structure de la chaîne est le suivant: 1
Astuce: regard de l'article, je remarque un problème en essayant de trouver un élément d'un article est facile, mais si vous cherchez sur un article que vous devez commencer à partir de zéro pour trouver, vraiment beaucoup d'ennuis. Pour résoudre ce problème , nous avons une poignée d'esprit, avant d' imiter la pratique, lorsque les éléments stockés plus qu'un petit morceau de papier placé sur enregistrer la position d'un élément, de sorte que vous pouvez trouver rapidement un élément sur la. Nous appelons cela la façon dont nous appelons une liste doublement chaînée façon, placée devant seulement un petit morceau de papier appelé une liste chaînée .
2. Le sens unique liste liée - code
Code global mis en œuvre comme suit: Tout d'abord, une construction à une seule chaîne, puis initialiser le premier noeud, puis ajouter le nœud suivant, puis la liste complète des données d'impression.
La première étape: les noeuds définis, nous sommes ici avec quelques grandes marques utilisent souvent l' ordinateur ordinaire, par exemple, contient les champs suivants: numéro de série, le nom de la marque, le surnom de la marque, pointez sur le noeud suivant.
class ComputerNode {
public int no; //序号
public String name; //品牌名称
public String nickname; //品牌外号
public ComputerNode next; //指向下一个节点
//构造器
public ComputerNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
//为了显示方法，我们重新toString
@Override
public String toString() {
return "ComputerNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
}
}
Étape: définir et initialiser une liste de noeuds à tête simple
class SingleLinkedList {
//先初始化一个头节点,头不存放具体的数据
private ComputerNode head = new ComputerNode(0, "", "");
}
La troisième étape: ajouter à cette liste un seul noeud
class SingleLinkedList {
……
//添加节点到单向链表
public void add(ComputerNode computerNode) {
//因为head节点不能动，因此我们需要一个辅助遍历 temp
ComputerNode temp = head;
//遍历链表，找到最后
while(true) {
//找到链表的最后
if(temp.next == null) {//next字段为空，则表示为链表结尾
break;
}
//如果没有找到最后,next字段不为空 将temp后移
temp = temp.next;
}
//当退出while循环时，temp就指向了链表的最后
//将最后这个节点的next指向新的节点
temp.next = computerNode;
}
}
Quatrième étape: réglé pour afficher les méthodes de la liste
class SingleLinkedList {
……
//显示链表[遍历]
public void list() {
//判断链表是否为空
if(head.next == null) {
System.out.println("链表为空");
return;
}
//因为头节点，不能动，因此我们需要一个辅助变量来遍历
ComputerNode temp = head.next;
while(true) {
//判断是否到链表最后
if(temp == null) {
break;
}
//输出节点的信息
System.out.println(temp);
//将temp后移， 一定小心
temp = temp.next;
}
}
}
Cinquième étape: Nous avons effectué un test de la méthode ci - dessus tout, vous pouvez voir un phénomène, les résultats montrent que la liste finale est triée par le code ajouté
public class SingleLinkedListDemo {
public static void main(String[] args) {
//先创建节点
ComputerNode computer1 = new ComputerNode(1, "联想", "美帝良心想");
ComputerNode computer2 = new ComputerNode(2, "惠普", "铁板熊掌普");
ComputerNode computer4 = new ComputerNode(4, "戴尔", "人傻钱多戴");
ComputerNode computer3 = new ComputerNode(3, "华硕", "奸若磐石硕");
//创建要给链表并将节点加入到链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(computer1);
singleLinkedList.add(computer2);
singleLinkedList.add(computer4);
singleLinkedList.add(computer3);
//显示链表，最后得到的结果如下，显然链表最后展示的结果是按照代码添加的顺序排列的
// ComputerNode [no=1, name=联想, nickname=美帝良心想]
// ComputerNode [no=2, name=惠普, nickname=铁板熊掌普]
// ComputerNode [no=4, name=戴尔, nickname=人傻钱多戴]
// ComputerNode [no=3, name=华硕, nickname=奸若磐石硕]
singleLinkedList.list();
}
}
Sixième étape: nous avons ajouté plus tôt sur la base d'une demande: en ordre numérique, et le nombre de doublons ne peut être ajouté
class SingleLinkedList {
……
//第二种方式在添加电脑时，根据编号顺序将电脑插入到指定位置
public void addByOrder(ComputerNode computerNode) {
//头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
//因为单链表，因为我们找的temp 是位于 添加位置的前一个节点，否则插入不了
ComputerNode temp = head;
boolean flag = false; // flag标志添加的编号是否存在，默认为false
while(true) {
if(temp.next == null) {//说明temp已经在链表的最后
break;
}
if(temp.next.no > computerNode.no) { //位置找到，就在temp的后面插入
break;
} else if (temp.next.no == computerNode.no) {//说明希望添加的heroNode的编号已然存在
flag = true; //说明编号存在
break;
}
temp = temp.next; //后移，遍历当前链表
}
//判断flag 的值
if(flag) { //不能添加，说明编号存在
System.out.printf("准备插入的电脑的编号 %d 已经存在了, 不能加入\n", computerNode.no);
} else {
//插入到链表中, temp的后面
computerNode.next = temp.next;
temp.next = computerNode;
}
}
}
Septième étape: La addméthode a été modifiée addByOrderet la liste testée pourrait ajouter des nœuds ordre séquentiel
public class SingleLinkedListDemo {
public static void main(String[] args) {
……
//创建要给链表并将节点加入到链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
/*singleLinkedList.add(computer1);
singleLinkedList.add(computer2);
singleLinkedList.add(computer4);
singleLinkedList.add(computer3);*/
singleLinkedList.addByOrder(computer1);
singleLinkedList.addByOrder(computer2);
singleLinkedList.addByOrder(computer4);
singleLinkedList.addByOrder(computer3);
……
}
}
Huitième étape: Nous testons l' addition répétée il y aura des circonstances dans lesquelles un noeud
public class SingleLinkedListDemo {
public static void main(String[] args) {
……
//重复添加computer3
singleLinkedList.addByOrder(computer1);
singleLinkedList.addByOrder(computer2);
singleLinkedList.addByOrder(computer3);
singleLinkedList.addByOrder(computer3);
……
}
}
3. manière liste chaînée - tout le code
Tout le code est joint ci-dessous la liste liée à sens unique
package com.maxchen.demo.linkedlist;
/**
* @ClassName: SingleLinkedListDemo
* @Description: TODO
* @Author Maxchen
* @Date 2020/4/1 18:32
* @Version V1.0.0
*/
public class SingleLinkedListDemo {
public static void main(String[] args) {
//先创建节点
ComputerNode computer1 = new ComputerNode(1, "联想", "美帝良心想");
ComputerNode computer2 = new ComputerNode(2, "惠普", "铁板熊掌普");
ComputerNode computer3 = new ComputerNode(3, "华硕", "奸若磐石硕");
ComputerNode computer4 = new ComputerNode(4, "戴尔", "人傻钱多戴");
//创建要给链表并将节点加入到链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
/*singleLinkedList.add(computer1);
singleLinkedList.add(computer2);
singleLinkedList.add(computer4);
singleLinkedList.add(computer3);*/
singleLinkedList.addByOrder(computer1);
singleLinkedList.addByOrder(computer2);
singleLinkedList.addByOrder(computer3);
singleLinkedList.addByOrder(computer3);
//显示链表，最后得到的结果如下，显然链表最后展示的结果是按照代码添加的顺序排列的
// ComputerNode [no=1, name=联想, nickname=美帝良心想]
// ComputerNode [no=2, name=惠普, nickname=铁板熊掌普]
// ComputerNode [no=4, name=戴尔, nickname=人傻钱多戴]
// ComputerNode [no=3, name=华硕, nickname=奸若磐石硕]
singleLinkedList.list();
}
}
class SingleLinkedList {
//先初始化一个头节点,头不存放具体的数据
private ComputerNode head = new ComputerNode(0, "", "");
//添加节点到单向链表
public void add(ComputerNode computerNode) {
//因为head节点不能动，因此我们需要一个辅助遍历 temp
ComputerNode temp = head;
//遍历链表，找到最后
while(true) {
//找到链表的最后
if(temp.next == null) {//next字段为空，则表示为链表结尾
break;
}
//如果没有找到最后,next字段不为空 将temp后移
temp = temp.next;
}
//当退出while循环时，temp就指向了链表的最后
//将最后这个节点的next指向新的节点
temp.next = computerNode;
}
//第二种方式在添加电脑时，根据编号顺序将电脑插入到指定位置
public void addByOrder(ComputerNode computerNode) {
//头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
//因为单链表，因为我们找的temp 是位于 添加位置的前一个节点，否则插入不了
ComputerNode temp = head;
boolean flag = false; // flag标志添加的编号是否存在，默认为false
while(true) {
if(temp.next == null) {//说明temp已经在链表的最后
break;
}
if(temp.next.no > computerNode.no) { //位置找到，就在temp的后面插入
break;
} else if (temp.next.no == computerNode.no) {//说明希望添加的heroNode的编号已然存在
flag = true; //说明编号存在
break;
}
temp = temp.next; //后移，遍历当前链表
}
//判断flag 的值
if(flag) { //不能添加，说明编号存在
System.out.printf("准备插入的电脑的编号 %d 已经存在了, 不能加入\n", computerNode.no);
} else {
//插入到链表中, temp的后面
computerNode.next = temp.next;
temp.next = computerNode;
}
}
//显示链表[遍历]
public void list() {
//判断链表是否为空
if(head.next == null) {
System.out.println("链表为空");
return;
}
//因为头节点，不能动，因此我们需要一个辅助变量来遍历
ComputerNode temp = head.next;
while(true) {
//判断是否到链表最后
if(temp == null) {
break;
}
//输出节点的信息
System.out.println(temp);
//将temp后移， 一定小心
temp = temp.next;
}
}
}
class ComputerNode {
public int no; //序号
public String name; //品牌名称
public String nickname; //品牌外号
public ComputerNode next; //指向下一个节点
//构造器
public ComputerNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
//为了显示方法，我们重新toString
@Override
public String toString() {
return "ComputerNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
}
}
