링크드리스트. 이것은 프로그래밍 해봤다는 사람은 한번씩은 들어봤을 겁니다.
기본적인 자료구조이기에.. 또한 제가 가장 즐겨쓰는 구조인 만큼 아주 확실하게 알아봅시다.
일단 아래의 모양을 한번 봐 보세요.
class Node {
int Data;
Node Link;
Node(int d,Node l) {
Data = d;
Link = l;
}
}
와 같이 만들면 됩니다. 즉 Data 라는 실제로 쓰이는 변수와 함께 자기자신과 똑같은 형인
Link 라는 변수도 만들어서 어떤 부분을 가리키도록(point) 하는것이죠
꼭 이름을 Node 라고 할 필요는 없으며 LinkedNode 라 하든지 뭐 맘대로 해도 됩니다.
그리고 위의 클래스는 변수만 있을뿐 메소드(함수)는 없지만 뭐 넣어도 됩니다. Data 라는
변수를 하나만 쓰지 않고 int Data; String aaa; 뭐 이렇게 다른 자료형도 쭉 쓸 수
있습니다. 즉
class myNode {
int a;
int b;
String c;
Object d;
int put(int aa,int bb) {
// 이 부분에 각 경우에 따른 코드를 쓰면 되겠죠..
}
}
처럼 해도 된다는 말이죠. 어렵지 않죠?
자 그럼. 아주 간단한 프로그램 만들어 봅시다.
// Simple.java
class ChainNode {
int Data;
ChainNode Link;
ChainNode(int d,ChainNode l) {
Data = d;
Link = l;
}
}
public class Simple { // 이곳에 main이 있으므로 파일이름은 Simple.java가 당연히 되겠죠?
public static void main(String[] args) {
ChainNode head = new ChainNode(0,null); // null은 가리키는 것이 없다는 뜻
// 그리고 head는 링크드리스트의 맨 처음부분이다.
ChainNode current = head; // current을 우선 head와 똑같다고 한다.그리고 current는 계속 바뀌게된다.
ChainNode temp; // 임의의 ChainNode 만든 것을 임시저장한다.
for ( int i=1; i<=10 ; i++ ) {
temp = new ChainNode(i,null); // 예를 들어 i가 1일때를 아무것도 가리키는 것이 없는 다만
// 1이라는 Data만 들어있는 걸 메모리상에 만들고(new했으니..) 그 걸 temp로 칭한다.
current.Link = temp; // current를 만들때 null값을 넣었지만 다른 부분을 링크
// 하도록 current.Link 에다가 방금 만든 temp를 넣어서 , 그 쪽을 가리키도록 한다.
current = temp; // 1부터 10까지 돌기때문에 current는 계속 바뀌게 된다.
}
// for문이 끝나면 여러개의 ChainNode가 링크되어서 그 흐름이 유지된다.
current = head; // 이제 처음(head)부터 print해서 그 내용을 확인하기 위해서
// current에 head를 넣어서 처음 위치로 이동시킨다.
while( current != null ) { // current에 아무값도 없을때까지 실행한다.
System.out.println(current.Data); // 맨 처음엔 head의 Data가 출력되고
current = current.Link; // current에다가 current가 가리키는 부분을 대입한다. 가장 중요!!
// 이 부분을 이해해야 합니다.
}
}
}
// 출력은 0부터 10까지 출력된다.
// 0은 head에 들어있었고, 1부터 10까지는 for문에서 만들었다.
가장 간단한 소스인만큼 꼭 확실하게 이해해야 합니다.
(밑의 설명에서 리스트나 링크드 리스트나 거의 같은 뜻이로 봐도 됩니다.
리스트중에 링크드리스트가 있는 것이니..) 파란색문장은 위의 소스에 그대로 있다는 걸
표시합니다.
head 와 current 와 temp 의 역할이 무엇인가를 알아봅시다.
링크드리스트는 각각의 노드(여기선 ChainNode)들이 링크(여기선 Link)를 통하여
하나의 리스트가 되는 겁니다. 따라서 전체 리스트의 처음부분은 항상 존재해야 하므로
head 라는 걸 만듭니다. 그리고 일단 구성되어 있는 링크드리스트에 새로운 노드를
뒷부분에다 집어넣을 경우 새로운 노드를 일단 메모리상에 만듭니다. 아래와 같이
temp = new ChainNode(i,null); temp는 이미 존재하고 있는 리스트하고는 아무런
연결끈이 현재로서는 없고 단지 메모리상에 있을 뿐이기에 , 연결시켜야 합니다.
따라서 리스트의 마지막노드(current)의 Link 에 temp를 넣어주면 됩니다.
즉 current.Link = temp; 이렇게.. 그러면 메모리상에 만든 temp가 리스트의 끝부분이
되기에 current = temp; 이와 같이 하면 current가 옮겨지게 되죠. 이렇게 하지말고
current = current.Link; 라고 해도 됩니다. 앞에서 먼저 current.Link = temp; 라고 했기에
당연히 되죠..됩니다. 확인해 봤어요!! 자 이렇게 해서 for 문을 분석했습니다. 즉 for 문은
링크드리스트에 데이터를 넣는(put) 역할을 하죠. 이젠 링크드리스트의 데이터를
한번 가져와(get)봅시다.
for 문이 끝난 상태에서는 current 는 링크드리스트의 맨 끝부분이기에 , 리스트의 첫
부분부터 데이터를 가져올려면 current = head; 함으로써 current를 링크드리스트의 첫
부분으로 하면 되겠죠? 계속 느꼈을텐데 current 는 줏대없이 계속 여기저기 이동되죠?
링크드리스트 특성상 이런 역할을 하는 ChainNode 가 있어야 합니다. 그리고 current 즉
우리말로 현재라는 뜻인데 , 여기저기 이동되므로 옮겨졌을 때, 링크드 리스트상에서
현재지점이 되는 의미에서 current 라고 쓴겁니다. 내키지 않으면 바꿔도 됩니다.
while ( current != null) <-- current 에 아무런 것도 있지 않을 때 즉 null 일때까지 돌게
되죠. 그럼 언제까지 돌까요? 링크드 리스트의 각 노드들은 Data 와 Link를 가지고 있죠?
Data 에는 뭐 진짜 데이터가 들어있게 되고, Link 에는 다음번 노드의 주소가 들어있죠?
그래야 링크 되고 또 링크되고 .. 해서 전체 리스트가 구성되니까요..하지만 맨 끝노드에는
어떻죠? 끝이니까 다음번 노드가 없죠? 따라서 맨 끝의 노드의 Link 에는 null 값이
들어있습니다. 실제로 Node를 만들 때 보통 temp = new ChainNode(i,null); 이라고 해서
처음에는 null이 들어가게 하는 것이죠. 그 노드가 어떤 걸 가리킬려고 하면 그냥
current.Link = temp ;처럼 해서 Link 에 어떤노드의 주소를 넣어주면 되니까요.
System.out.println(current.Data); 해서 데이터를 출력하고
current = current.Link; 라고 해서
현재노드를 이동시켜 주는 것이죠. while 문이 끝날 때 까지 current 의 Data를 출력하고
current는 다음번 노드로 이동하고 ... 아시겠죠?
자 첫 번째 과제입니다. 위의 소스를 완벽히 이해했다면 쉽게 만들 수 있으며, 반드시
소스를 보면서 만들지 말고 그냥 생각하면서 만드세요. 저는 자료구조 과제가 있는 주말은
집에서 10시간 이상 코드작성했습니다. 강의자료를 보고 만들면 쉽게 만들 수 있지만
나중에 돌이켜보면 자기것이 되지 못합니다. 기본 원리를 이해한후 참고용 소스 같은 것
보지말고 혼자 생각하면서 하나씩 하나씩 만들어 갔으니 당연히 시간을 많이 잡아 먹죠.
그러나 이런식으로 하면 개념이 정말 확실하게 잡히니까 여러분도 이렇게 하세요. 노력하지
않고 좋은 결과만 있길 바란다면 안되죠..
첫 번째 과제 : 링크드 리스트를 이용하여 10부터 1까지(자연수) 들어있는 리스트를 만들고
(즉 앞의 제가 보여준 예제는 1부터 11까지 였는데 이 번엔 10부터 1까지 역순으로
들어있는 리스트이죠.) 그리고 리스트의 처음에서부터 그 값을 출력하는데 데이터에 7이
있는 노드를 만나면 거기 까지만 출력하도록 하시오. 즉 10 9 8 7 까지만 나오게 하라
라는 뜻입니다.
밑에는 해답을 올리죠. 하지만 절대 먼저 보지 마세요 . 이리저리 해 보고 난 후 보세요.
class ChainNode {
int Data;
ChainNode Link;
ChainNode(int d,ChainNode l) {
Data = d;
Link = l;
}
}
public class Simple {
public static void main(String[] args) {
ChainNode head = new ChainNode(10,null);
ChainNode current = head;
ChainNode temp;
for ( int i=9; i>=1 ; i-- ) {
temp = new ChainNode(i,null);
current.Link = temp;
current = current.Link;
}
current = head;
while( current != null ) {
if ( current.Data == 7 ) {
System.out.println(current.Data);
break;
}
else {
System.out.println(current.Data);
current = current.Link;
}
}
}
}
보라색으로 된 부분이 원래 소스에서 수정되거나 추가 된 겁니다. 큰수에서 작은 수로
내려가니까 당연히 for 문에 i-- 가 들어가는 것은 아시죠?
출력부분에 데이터가 7이면 그까지만 출력하는 것이니
if (current.Data == 7 ) 이렇게 해서 7인 경우에 대해 따로 만들면 되죠
println 써서 출력해 주고 break; 써서 while 문을 빠져 나옵니다.
그렇지 않은 경우는 else 써서 똑같이 하면 되겠죠?
자 이제는 ChainNode에 메쏘드를 추가해서 만들어 봅시다. C 언어에서의 구조체와
C++에서의 클래스(Java도 마찬가지) 가 다른 점이 뭘까요? 가장 큰 다른 점은 데이터만
가질수 있느냐? 아니면 메쏘드(함수)까지 가질 수 있느냐 이죠?
좀 더 고급스럽게 고쳐봅시다. 훨씬 코드가 길어졌지만 가장 기본이 되는 부분이니
빠짐없이 메쏘드 부분을 유심히 보세요. 앞으로 갈길이 먼데 기초가 단단해야죠?
아래의 예제는 1부터 10까지 각 숫자에 10배 한 값을 데이터로 가지는 노드가 서로
링크되어 있으며(이전에는 1부터 10까지의 수가 들어갔지만 이번엔 1*10 , 2*10 , ...
10*10 의 수가 들어간다는 뜻이죠) 링크드리스트의 맨 처음 노드에서 index 번째있는
노드의 데이터만을 프린트해주는 프로그램입니다.(이전엔 index번째노드까지 모두 출력하는
것이었죠? 10 9 8 7 이렇게..)
// 이번 예제는 head는 단지 맨처음노드를 가리키는 역할만 하는겁니다.
// 즉 head노드의 Data는 의미가 없고 단지 Link만이 의미가 있는것이죠 이때까지 예제와는
// 다르죠. 즉 head.Link 에 있는 주소가 진짜 첫번째 노드인것이죠.head는 단지 첫번째노드를 가리킬뿐..
// 뭐 이렇게 할수도 있다는 것이고 프로그램 종류에 따라서 head의 Data에 진짜값을
// 넣을것인지 아닌지 스스로 판단해서 코딩하면 됩니다.
class ChainNode {
int Data;
ChainNode Link;
ChainNode(int d,ChainNode l) {
Data = d;
Link = l;
}
}
class LinkedList {
ChainNode head;
ChainNode current;
int size;
LinkedList() { // 생성자
head = new ChainNode(0,null);
current = new ChainNode(0,null);
size = 0;
// head.Link = current 부분이 없습니다. 즉 초기값으로 head는 아무것도 가리키지 않는다는 뜻이죠
}
boolean isEmpty() { // 링크드리스트가 비워있는지 체크.
if ( size == 0 )
return true; // size가 0 이면 true
else
return false; // 그렇지 않다면 false
}
int get(int index) { // index번째의 Data를 리턴한다.
if ( isEmpty() == true ) {
System.out.print("링크드리스트에 아무 값도 없어요 index =>");
return index;
}
else
if ( index > size || index < 1) {
System.out.print("index가 링크드리스트 size를 넘어서거나 1보다 작습니다. index=>");
return index;
}
else {
current = head.Link; // index번째로 갈려면 처음에서부터 index번 이동해야 하므로.
// head.Link가 실제 데이터가 있는 맨 처음 노드이므로
for ( int i = 1 ; i < index ; i++ ) {
current = current.Link; // index-1 번 옮겨지고
}
return current.Data; // 거기에 있는 값을 리턴
}
}
void put(int a) { // 새로운 노드를 링크드리스트의 마지막에 집어넣는다.
if ( isEmpty() == true) { // 아무것도 없을경우
ChainNode temp = new ChainNode(a,null);
current = temp;
head.Link = current; // 방금 만든 노드를 head가 가리키도록 한다.
}
else { // 이미 리스트에 노드가 있다면
while( current.Link != null ) {
current = current.Link; // current를 리스트의 맨 마지막으로 옮긴다.
}
ChainNode temp = new ChainNode(a,null); // a를 데이터로 가지는 temp노드를 만든후
current.Link = temp; // Link에 temp를 넣어줘서 리스트의 끝에 temp를 붙인다.
}
size++; // 추가했으니 당연히 size는 하나씩 증가
}
}
public class Simple {
public static void main(String[] args) {
LinkedList List = new LinkedList();
for ( int i = 1 ; i <= 10 ; i++ ) {
List.put(i*10);
}
System.out.println(List.get(6));
System.out.println(List.get(11));
System.out.println(List.get(1));
System.out.println(List.get(0));
}
}
어떤가요? 뭔가 딱딱 구분되어 지는 느낌이 들지 않나요? 이런 기능하는 것은 여기에
모아두고 .. 즉 모듈화가 잘 되어있죠? main 이 들이 있는 Simple class는 아주 간단하죠?
제가 봐도 만족스럽습니다. 사실 수업 레포트 낸 것은 이렇게 만들지 않았거든요..이제서야
제대로 만들었네요..^^ 객체지향프로그래밍은 이렇게 해야겠죠? List라는 객체의 메소드로
get이라는 것이 어떻게 코딩되어있는지 알필요없이 단지 List.get(i);처럼 쓰기만 하면
되잖아요. 또한 링크드리스트에 데이터를 집어넣을때도 단지 List.put(i*10);처럼 쓰기만
하면 되죠. 사실 이렇게 각각의 클래스를 구분시키는 습관을 가져야 패키지도 만들 수 있고
수정하기 쉽고 이해하기 쉬운 프로그램 만드는 지름길입니다.
이제는 ChainNode 클래스와 LinkedList 클래스를 다른 프로그램 코딩할때도 그대로
붙여넣기 해서 쓰기만 하면 되겠죠?
저는 이번학기동안 이 부분이 많이 모자랐습니다. 이전에 C 언어만 봤었기에 사실 이렇게
만든다는 것이 쉽지가 안더군요..한학기가 끝나고서야....^^*
자~! 이제 링크드 리스트 얼마남지 않았습니다.
이제까지 만든 링크드리스트를 이용한 프로그램은 사실 배열과 효율성이 거의 같습니다.
링크드리스트의 가장 큰 장점은 삽입과 삭제시에 그 수행 시간이 배열보다 훨씬 작다는
것이죠. 예를 들자면
2 3 5 7 9 가 차레로 들어가 있는 배열과 링크드 리스트가 있다고 합시다.
만약 4라는 수를 여기에 넣고자 한다면 (오름차순을 유지하면서)
배열이나 링크드리스트나 모두 2 3 4 5 7 9 순으로 데이터가 들어가야 하죠?
배열의 경우 4가 5의 자리에 들어가고 5,7,9는 한칸씩 뒤로 밀려서 새롭게 배열이
정렬해야 겠죠? 만약 1 이라는 수가 들어간다면 2부터 모두 한칸씩 밀려나가게 되죠?
얼마나 시간이 많이 걸리겠어요? 하지만 링크드리스트를 이용한다면 이렇게 밀려나가지
않고 해결할수 있답니다. 자~ 밑의 그림을 보세요
이렇게 링크드 리스트가 구성되어 있을 때
4를 데이터로 가지는 노드를 삽입(insert)하고자 한다면 아래와 같이 하면 되죠
일단 말로 설명을 하죠. 리스트가 오름차순으로 정렬되어 있기에 데이터가 4보다 작은 경우
계속 이동을 합니다. 그러면 3 이라는 데이터가 있는 곳까지 이동하죠? 이곳을 current
라고 합시다. current.Link 에는 5의 주소가 있겠죠?
우선 4를 데이터로 가지는 노드를 메모리상에 만듭니다. 다음과 같이
ChainNode temp = new ChainNode(4,null);
그리고 난후 이 노드를 링크드리스트에 삽입해야 하므로
보라색 화살표처럼 링크가 이루어 지면 되겠죠? 여기서 순서가 중요합니다.
temp.Link = current.Link; 해주고 나서
current.Link = temp; 해주야 하는것이죠
만약 반대로 한다면
current.Link = temp; 이것은 괜찮은데
temp.Link = current.Link; current.Link에 temp를 넣었는데 그걸 temp.Link에 넣는다?
말이 안되죠? 만약 이렇게 만든다면 이 리스트는 4가 있는 노드에서 끊임없이
자기자신에게 왔다갔다 하겠죠?
따라서 위의 파란색처럼 해야 합니다. 쉽죠? 이제 그럼 노드 삭제(remove)를 해 봅시다.
여기에서 3를 데이터로 가지는 노드를 없애봅시다.
만약 1 3 5 7 순으로 되어 있는 배열에서 3을 지운다면 5 와 7 이 한칸씩 앞으로
이동시켜야 겠죠? 데이터가 수없이 많이 있는 상태에서 이렇게 앞의 부분을 없애버리면
아무리 좋은 컴퓨터라도 버벅거리겠죠? 따라서 링크드리스트로 간단히 해결합시다
이제 코드를 어떻게 써야 할지 금방 알겠죠?
3이라는 데이터가 있는 노드까지 이동한 후 그곳을 current 라고 합시다. 즉 3이라는
데이터가 있는 노드가 current가 되겠네요... current.Link 에는 현재 5노드(5라는 데이터를
가지는 노드를 그냥 이케 부릅시다. )를 가리키죠. 1노드의 링크에는 3노드가. 그리고
3노드의 링크에는 5노드가 들어있죠? 이것을, 1노드의 링크에는 5노드(3노드의 링크)가
있게만들면 되겠죠? 따라서 current 와 함께 pre 라는 노드를 하나 더 만들어야죠.즉
지울려는 노드 바로 앞 노드가 필요하다는 것이죠. 여기선 pre 는 1노드를 뜻하네요.
pre.link = current.link; 해주면 그냥 끝나죠..
자 이게 링크드 리스트의 전부랍니다. 자 그럼 과제 나갑니다.
바로 전 예제를 참고하여 10 , 20, 30 ... 100 까지 들어가있는 노드에서 30노드를
지우고나서 리스트의 처음부터 끝까지 데이터를 출력하고
그 상태의 리스트에서 77을 삽입하고 난후(즉 10 . 20 ... 70 77 80 90 100 이런 순으로
되도록!) 리스트 전체를 처음부터 끝까지 데이터를 출력하여 그 결과를 확인해보세요
어렵더라도 절대 밑의 소스를 보지 마세요. 어느정도 혼자서 고민과 시행착오를 겪어야
합니다. 저또한 지금 소스를 만들어야겠지만 몇 번의 에러를 맞이할것이며 고민하게
되겠죠..^^ 조금 더 자세히 알려드리자면 먼저번에 만든 예제의 put 메쏘드는
링크드리스트의 마지막부분에 삽입(insert)하는 것이었죠? 근데 이번엔 순서를 따져서
넣어야 하는것이니 put 메쏘드를 없애고 insert 메쏘드를 만들면 되겠죠? remove 메쏘드
또한 만들어야 겠고.. main 이 있는 simple 클래스에서는 그냥 List.insert(숫자) 하던지
List.remove(숫자) 하면 끝이나겠죠? 더 이상의 힌트는 바라지 맙시다. !!
자. 소스를 보여드리죠. 100줄이 조금 넘는데 부담가질 것 없습니다. 각 클래스 하나씩
그리고 클래스에 있는 각 메쏘드를 하나씩 분석하시면 쉽게 알겁니다.
class ChainNode {
int Data;
ChainNode Link;
ChainNode(int d,ChainNode l) {
Data = d;
Link = l;
}
}
class LinkedList {
ChainNode head;
ChainNode current;
int size;
LinkedList() { // 생성자
head = new ChainNode(0,null);
current = new ChainNode(0,null);
size = 0; // 링크드 리스트의 사이즈.
}
boolean isEmpty() { // 링크드리스트가 비워있는지 체크.
if ( size == 0 )
return true; // size가 0 이면 true
else
return false; // 그렇지 않다면 false
}
int get(int index) { // index번째의 Data를 리턴한다.
if ( isEmpty() == true ) {
System.out.print("링크드리스트에 아무 값도 없어요 ");
return -1;
}
else
if ( index > size || index < 1) {
System.out.print("index가 링크드리스트 size를 넘어서거나 1보다 작습니다. ");
return -2;
}
else {
current = head.Link; // index번째로 갈려면 처음에서부터 index번 이동해야 하므로.
// head.Link가 실제 데이터가 있는 맨 처음 노드이므로
for ( int i = 1 ; i < index ; i++ ) {
current = current.Link; // index-1 번 옮겨지고
}
return current.Data; // 거기에 있는 값을 리턴
}
}
void remove(int a) {
if ( isEmpty() == true ) {
System.out.println("아무것도 지울것이 없어요");
}
else {
current = head.Link; // current 를 링크드 리스트의 처음으로 위치시키고..
ChainNode pre = new ChainNode(0,head.Link); // current의 바로 전(pre) 노드를 말합니다.
// 따라서 head.Link를 링크값으로 가지죠..
while( current != null ) {
if ( current.Data == a ) {
pre.Link = current.Link;
current = null;
break; // 할일을 마쳤으니 더이상 while문을 돌릴필요가 없죠,.
}
else {
pre = current;
current = current.Link;
}
}
size--;
}
}
void insert(int a) { // 새로운 노드를 집어넣는다.
if ( isEmpty() == true) { // 아무것도 없을경우
ChainNode temp = new ChainNode(a,null);
current = temp;
head.Link = current; // 방금 만든 노드를 head가 가리키도록 한다.
}
else { // 이미 리스트에 노드가 있다면
current = head.Link;
while( current.Link != null && (current.Link).Data < a ) {
// Data와 a가 같은경우는 없다고 가정
current = current.Link;
}
ChainNode temp = new ChainNode(a,null); // a를 데이터로 가지는 temp노드를 만든후
temp.Link = current.Link;
current.Link = temp;
}
size++; // 추가했으니 당연히 size는 하나씩 증가
}
}
public class Simple {
public static void main(String[] args) {
LinkedList List = new LinkedList();
for ( int i = 1 ; i <= 10 ; i++ ) {
List.insert(i*10); // 데이터 입력
}
List.remove(30); // 30을 지우기
for ( int k = 1 ; !(List.get(k)==-2 || List.get(k) == -1) ; k++) {
System.out.println(List.get(k)); // 30지운 링크드 리스트 출력
}
System.out.println("****************************");
List.insert(77); // 77삽입하기
for ( int m = 1 ; !(List.get(m) == -2 || List.get(m) == -1 ) ; m++ ) {
System.out.println(List.get(m)); // 77삽입한 링크드 리스트 출력
}
}
}
제가 만든 소스를 자기것으로 만들려는 것보다는 어느정도 링크드리스트에 관해 그 원리를
깨우쳤다면 자기만의 소스를 만드시는 것이 훨씬 더 좋을듯합니다. 표현방법은 수없이
많은데 , 이 소스는 단지 제 생각으로 만든것이니 여러분 각자의 생각에 맞게 만드시길
바라며 단지 참고용으로 보시면 좋을 듯 합니다.
근데 이 소스는 약간의 버그가 있습니다. 만약 리스트의 맨 처음 노드인 10을 지우고자
한다면? 그리고 10보다 작은 수를 넣을려고 한다면? 어떻게 될까요? 예상했던 출력이
나오지 않을 겁니다. 이런 예외적인 사항들에 대해선 나중에 좀 더 실력을 쌓은 후 고민해
보시기 바랍니다. 제 생각엔 모든 프로그래밍 순서에 있어서 이런저런 예외사항을 생각하지
말고(아주 보편적인 입력값이 오도록) 일단 프로그램을 만든후 하나씩 하나씩
예외사항(특이사항)에 대해 코드를 작성하시는 것이 빨리 쉽게 만드는 방법이 아닐까요?
처음부터 단번에 만들려고 하지말고요...
출처 : ( semtul79@hanmail.net )
