Pascal-Datastructures/StackLinkedList.pas at master · matthewJamesAbbott/Pascal-Datastructures · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
//
// Created by Matthew Abbott 23/8/22
//

{$mode objfpc}
{$M+}

unit StackLinkedList;

interface

type

    node = ^NodeRec;
    NodeRec = record
        data: integer;
        next: node;
    end;

    TStackLinkedList = object

    public
        constructor create();
        procedure addNode(inputData: integer);
        procedure deleteFirstNode();
        procedure deleteLastNode();
        procedure deleteSpecificNode(nodeNumber: integer);
        function countNodes(): integer;
        function returnSpecificNodesData(nodeNumber: integer): integer;
        function returnHeadsData(): integer;
        function returnTailsData(): integer;
        function returnNodeNumberOfFirstInstanceOfData(inputData: integer): integer;
    end;
var
    head : node;

implementation

constructor TStackLinkedList.create();
begin
end;

procedure TStackLinkedList.addNode(inputData: integer);
var
    temp, newNode: node;
begin
    new(newNode);
    newNode^.data := inputData;
    newNode^.next := nil;
    if head = nil then
        head := newNode
    else
        begin
            temp := head;
            while temp^.next <> nil do
                begin
                    temp := temp^.next
                end;
            temp^.next := newNode;
        end;
end;

procedure TStackLinkedList.deleteFirstNode();
begin
    head := head^.next;
end;

procedure TStackLinkedList.deleteLastNode();
var
    temp1,temp2: node;
begin
    temp1 := head;
    while temp1^.next <> nil do
        begin
            if temp1^.next <> nil then
                begin
                    temp2 := temp1;
                end;
            temp1 := temp1^.next;
        end;
        temp2^.next := nil;;

end;

procedure TStackLinkedList.deleteSpecificNode(nodeNumber: integer);
var
    temp1,temp2: node;
    index: integer;
begin
    if nodeNumber = 1 then
        deleteFirstNode()
    else
        begin
            temp1 := head;
            for index := 2 to nodeNumber do
                begin
                    temp2 := temp1;
                    temp1 := temp1^.next
                end;
            temp2^.next := temp1^.next;
        end;
end;

function TStackLinkedList.countNodes(): integer;
var
    index: integer;
    temp: node;
begin
    if head = nil then
        countNodes := 0
    else
        begin
            index := 1;
            temp := head;
            while temp^.next <> nil do
                begin
                    temp := temp^.next;
                    inc(index);
                end;
            countNodes := index;
        end;
end;

function TStackLinkedList.returnSpecificNodesData(nodeNumber: integer): integer;
var
    temp: node;
    index: integer;

begin
    temp := head;
    if nodeNumber = 1 then
        returnSpecificNodesData := temp^.data
    else
        begin
            for index := 2 to nodeNumber do
                begin
                    temp := temp^.next;
                end;
        end;

    returnSpecificNodesData := temp^.data;
end;

function TStackLinkedList.returnHeadsData(): integer;
begin
    returnHeadsData := head^.data;
end;

function TStackLinkedList.returnTailsData(): integer;
var
    temp: node;
begin
    temp := head;
    while temp^.next <> nil do
        begin
            temp := temp^.next;
        end;
    returnTailsData := temp^.data;
end;

function TStackLinkedList.returnNodeNumberOfFirstInstanceOfData(inputData: integer): integer;
var
    temp: node;
    index: integer;
begin
    temp := head;
    if temp^.data = inputData then
        returnNodeNumberOfFirstInstanceOfData := 1
    else
        begin
            index := 1;
            while temp^.next <> nil do
                begin
                    inc(index);
                    temp := temp^.next;
                    if temp^.data = inputData then
                        begin
                            returnNodeNumberOfFirstInstanceOfData := index;
                        end;
                end;
        end;
end;
end.