C ++の単純なリンクリスト
今まで挿入して表示できるリンクを作成しようとしています：
struct Node {
int x;
Node *next;
};
これは私の初期化関数で、最初のNodeに対してのみ呼び出されます：
void initNode(struct Node *head, int n){
head->x = n;
head->next = NULL;
}
Nodeを追加し、リンクリストが正しく機能しない理由は、次の関数にあると思います。
void addNode(struct Node *head, int n){
struct Node *NewNode = new Node;
NewNode-> x = n;
NewNode -> next = head;
head = NewNode;
}
私のmain関数：
int _tmain(int argc, _TCHAR* argv[])
{
struct Node *head = new Node;
initNode(head, 5);
addNode(head, 10);
addNode(head, 20);
return 0;
}
動作すると思うようにプログラムを実行させてください。まず、ヘッドNodeをNodeとして次のように初期化します。
head = [ 5 | NULL ]
次に、n = 10の新しいノードを追加し、headを引数として渡します。
NewNode = [x | next] nextは先頭を指します。次に、NewNodeがLinkedListの最初のNodeであるため、headがNewNodeを指している場所を変更します。
なぜこれが機能しないのですか？私が正しい方向に進むためのヒントをいただければ幸いです。 LinkedListを理解するのは少し難しいと思います。
これを印刷すると、5だけが返されます。
これは、この場合に考えることができる最も単純な例であり、テストされていません。これはいくつかの悪い習慣を使用し、C++で通常行う方法（リストの初期化、宣言と定義の分離など）を行わないことを考慮してください。しかし、それはここでは説明できないトピックです。
#include <iostream>
using namespace std;
class LinkedList{
// Struct inside the class LinkedList
// This is one node which is not needed by the caller. It is just
// for internal work.
struct Node {
int x;
Node *next;
};
// public member
public:
// constructor
LinkedList(){
head = NULL; // set head to NULL
}
// destructor
~LinkedList(){
Node *next = head;
while(next) { // iterate over all elements
Node *deleteMe = next;
next = next->next; // save pointer to the next element
delete deleteMe; // delete the current entry
}
}
// This prepends a new value at the beginning of the list
void addValue(int val){
Node *n = new Node(); // create new Node
n->x = val; // set value
n->next = head; // make the node point to the next node.
// If the list is empty, this is NULL, so the end of the list --> OK
head = n; // last but not least, make the head point at the new node.
}
// returns the first element in the list and deletes the Node.
// caution, no error-checking here!
int popValue(){
Node *n = head;
int ret = n->x;
head = head->next;
delete n;
return ret;
}
// private member
private:
Node *head; // this is the private member variable. It is just a pointer to the first Node
};
int main() {
LinkedList list;
list.addValue(5);
list.addValue(10);
list.addValue(20);
cout << list.popValue() << endl;
cout << list.popValue() << endl;
cout << list.popValue() << endl;
// because there is no error checking in popValue(), the following
// is undefined behavior. Probably the program will crash, because
// there are no more values in the list.
// cout << list.popValue() << endl;
return 0;
}
C++とオブジェクト指向プログラミングについて少し読むことを強くお勧めします。適切な出発点は次のとおりです。 http://www.galileocomputing.de/1278?GPP=opoo
編集：ポップ機能といくつかの出力を追加しました。ご覧のとおり、プログラムは3つの値5、10、20をプッシュし、その後それらをポップします。このリストはスタックモード（LIFO、後入れ先出し）で機能するため、その後順序は逆になります。
ヘッドポインターの参照を取得する必要があります。それ以外の場合、ポインタの変更は関数の外部からは見えません。
void addNode(struct Node *&head, int n){
struct Node *NewNode = new Node;
NewNode-> x = n;
NewNode -> next = head;
head = NewNode;
}
両方の機能が間違っています。まず、関数initNodeにはわかりにくい名前が付いています。たとえばinitListのような名前を付ける必要があり、addNodeのタスクを実行しないでください。つまり、リストに値を追加しないでください。
実際、関数initNodeには意味がありません。リストの初期化は、ヘッドが定義されているときに実行できるためです。
Node *head = nullptr;
または
Node *head = NULL;
したがって、リストの設計から関数initNodeを除外できます。
また、コードでは、名前Nodeの前にキーワードstructを指定するための構造Nodeの詳細な型名を指定する必要はありません。
関数addNodeは、headの元の値を変更します。関数の実現では、関数の引数として渡されたheadのコピーのみを変更します。
関数は次のようになります。
void addNode(Node **head, int n)
{
Node *NewNode = new Node {n, *head};
*head = NewNode;
}
または、コンパイラが初期化の新しい構文をサポートしていない場合は、次のように記述できます
void addNode(Node **head, int n)
{
Node *NewNode = new Node;
NewNode->x = n;
NewNode->next = *head;
*head = NewNode;
}
または、ポインターへのポインターを使用する代わりに、ノードへのポインターへの参照を使用できます。例えば、
void addNode(Node * &head, int n)
{
Node *NewNode = new Node {n, head};
head = NewNode;
}
または、関数から更新されたヘッドを返すことができます。
Node * addNode(Node *head, int n)
{
Node *NewNode = new Node {n, head};
head = NewNode;
return head;
}
そして、mainに以下を記述します。
head = addNode(head, 5);
争いに参加します。私がCを書いてから長すぎます。その上、とにかく完全な例はありません。 OPのコードは基本的にCなので、先に進み、GCCで動作するようにしました。
問題は以前にカバーされました。 nextポインターは進んでいませんでした。それが問題の核心でした。
また、この機会に提案された編集を行いました。 mallocに2つの関数を持たせる代わりに、initNode()に入れてからinitNode()をmalloc両方に使用しました（mallocは「C new」を選択します）。 initNode()を変更してポインターを返しました。
#include <stdlib.h>
#include <stdio.h>
// required to be declared before self-referential definition
struct Node;
struct Node {
int x;
struct Node *next;
};
struct Node* initNode( int n){
struct Node *head = malloc(sizeof(struct Node));
head->x = n;
head->next = NULL;
return head;
}
void addNode(struct Node **head, int n){
struct Node *NewNode = initNode( n );
NewNode -> next = *head;
*head = NewNode;
}
int main(int argc, char* argv[])
{
struct Node* head = initNode(5);
addNode(&head,10);
addNode(&head,20);
struct Node* cur = head;
do {
printf("Node @ %p : %i\n",(void*)cur, cur->x );
} while ( ( cur = cur->next ) != NULL );
}
コンパイル：gcc -o ll ll.c
出力：
Node @ 0x9e0050 : 20
Node @ 0x9e0030 : 10
Node @ 0x9e0010 : 5
addNode関数はheadを変更できる必要があります。現在は、ローカル変数head（パラメーター）を変更するだけで記述されています。
コードを変更する
void addNode(struct Node *& head, int n){
...
}
headパラメーターが参照によって渡され、呼び出された関数がそれを変更できるため、この問題は解決します。
headは、メイン内で次のように定義されます。
_struct Node *head = new Node;
_ただし、addNode()およびinitNode()関数でのみ頭を変更しています。変更はメインに反映されません。
ヘッドの宣言をグローバルとして作成し、関数に渡さないでください。
関数は次のようになります。
_void initNode(int n){
head->x = n;
head->next = NULL;
}
void addNode(int n){
struct Node *NewNode = new Node;
NewNode-> x = n;
NewNode->next = head;
head = NewNode;
}
_以下はリンクリストのサンプルです
#include <string>
#include <iostream>
using namespace std;
template<class T>
class Node
{
public:
Node();
Node(const T& item, Node<T>* ptrnext = NULL);
T value;
Node<T> * next;
};
template<class T>
Node<T>::Node()
{
value = NULL;
next = NULL;
}
template<class T>
Node<T>::Node(const T& item, Node<T>* ptrnext = NULL)
{
this->value = item;
this->next = ptrnext;
}
template<class T>
class LinkedListClass
{
private:
Node<T> * Front;
Node<T> * Rear;
int Count;
public:
LinkedListClass();
~LinkedListClass();
void InsertFront(const T Item);
void InsertRear(const T Item);
void PrintList();
};
template<class T>
LinkedListClass<T>::LinkedListClass()
{
Front = NULL;
Rear = NULL;
}
template<class T>
void LinkedListClass<T>::InsertFront(const T Item)
{
if (Front == NULL)
{
Front = new Node<T>();
Front->value = Item;
Front->next = NULL;
Rear = new Node<T>();
Rear = Front;
}
else
{
Node<T> * newNode = new Node<T>();
newNode->value = Item;
newNode->next = Front;
Front = newNode;
}
}
template<class T>
void LinkedListClass<T>::InsertRear(const T Item)
{
if (Rear == NULL)
{
Rear = new Node<T>();
Rear->value = Item;
Rear->next = NULL;
Front = new Node<T>();
Front = Rear;
}
else
{
Node<T> * newNode = new Node<T>();
newNode->value = Item;
Rear->next = newNode;
Rear = newNode;
}
}
template<class T>
void LinkedListClass<T>::PrintList()
{
Node<T> * temp = Front;
while (temp->next != NULL)
{
cout << " " << temp->value << "";
if (temp != NULL)
{
temp = (temp->next);
}
else
{
break;
}
}
}
int main()
{
LinkedListClass<int> * LList = new LinkedListClass<int>();
LList->InsertFront(40);
LList->InsertFront(30);
LList->InsertFront(20);
LList->InsertFront(10);
LList->InsertRear(50);
LList->InsertRear(60);
LList->InsertRear(70);
LList->PrintList();
}
つかいます：
#include<iostream>
using namespace std;
struct Node
{
int num;
Node *next;
};
Node *head = NULL;
Node *tail = NULL;
void AddnodeAtbeggining(){
Node *temp = new Node;
cout << "Enter the item";
cin >> temp->num;
temp->next = NULL;
if (head == NULL)
{
head = temp;
tail = temp;
}
else
{
temp->next = head;
head = temp;
}
}
void addnodeAtend()
{
Node *temp = new Node;
cout << "Enter the item";
cin >> temp->num;
temp->next = NULL;
if (head == NULL){
head = temp;
tail = temp;
}
else{
tail->next = temp;
tail = temp;
}
}
void displayNode()
{
cout << "\nDisplay Function\n";
Node *temp = head;
for(Node *temp = head; temp != NULL; temp = temp->next)
cout << temp->num << ",";
}
void deleteNode ()
{
for (Node *temp = head; temp != NULL; temp = temp->next)
delete head;
}
int main ()
{
AddnodeAtbeggining();
addnodeAtend();
displayNode();
deleteNode();
displayNode();
}
リスト内の各ノードの深いリンケージを確認するには、addNodeメソッドは次のようになっている必要があります。
void addNode(struct node *head, int n) {
if (head->Next == NULL) {
struct node *NewNode = new node;
NewNode->value = n;
NewNode->Next = NULL;
head->Next = NewNode;
}
else
addNode(head->Next, n);
}
コードには間違いがあります：
void deleteNode ()
{
for (Node * temp = head; temp! = NULL; temp = temp-> next)
delete head;
}
それが必要です：
for (; head != NULL; )
{
Node *temp = head;
head = temp->next;
delete temp;
}
これが私の実装です。
#include <iostream>
using namespace std;
template< class T>
struct node{
T m_data;
node* m_next_node;
node(T t_data, node* t_node) :
m_data(t_data), m_next_node(t_node){}
~node(){
std::cout << "Address :" << this << " Destroyed" << std::endl;
}
};
template<class T>
class linked_list {
public:
node<T>* m_list;
linked_list(): m_list(nullptr){}
void add_node(T t_data) {
node<T>* _new_node = new node<T>(t_data, nullptr);
_new_node->m_next_node = m_list;
m_list = _new_node;
}
void populate_nodes(node<T>* t_node) {
if (t_node != nullptr) {
std::cout << "Data =" << t_node->m_data
<< ", Address =" << t_node->m_next_node
<< std::endl;
populate_nodes(t_node->m_next_node);
}
}
void delete_nodes(node<T>* t_node) {
if (t_node != nullptr) {
delete_nodes(t_node->m_next_node);
}
delete(t_node);
}
};
int main()
{
linked_list<float>* _ll = new linked_list<float>();
_ll->add_node(1.3);
_ll->add_node(5.5);
_ll->add_node(10.1);
_ll->add_node(123);
_ll->add_node(4.5);
_ll->add_node(23.6);
_ll->add_node(2);
_ll->populate_nodes(_ll->m_list);
_ll->delete_nodes(_ll->m_list);
delete(_ll);
return 0;
}
