1、C语言中单链表的实现
typedef struct node /*节点的定义*/
{
Item item; /*数据域*/
node *next; /*链域*/
}Node,*PNode;
Node dt;
typedef PNode List;
我们将单链表和int a = 3;作类比,其中Node(别名)相当于int指代数据类型,dt相当于a指代变量名(注意dt非指针,仅仅只是一个变量,因此我们定义了*PNode别名作为指针)。而PNode则为指针数据类型,指向结构体的首地址,数据类型为Node*。比如typedef PNode List == typedef node* List == typedef Node* List
#include "testLink.h"
#include<stdio.h>
#include<stdlib.h>
#include<stdlib.h>
typedef int Item;/*定义数据项类型*/
//typedef struct node *PNode; /*定义节点指针*/ PNode next; /*链域*/
typedef struct node/*节点的定义*/
{
Item item; /*数据域*/
node *next; /*链域*/
}Node,*PNode;
typedef PNode List;
List MakeEmpty(List L)
{
L = (Node*)malloc(sizeof(Node));
L->item = 0;
L->next = NULL;
return L;
}
//在链表L中P位置之后插入数据项为X的新节点
void Insert(Item X,List L,List P)
{
List temp;
temp = (List)malloc(sizeof(Node));
if(temp==NULL)
exit(0);
temp->item = X;
temp->next = P->next;
P->next = temp; //要注意next的数据类型为Node*
}
List reverse(List header){
List p,q;
p = header;
q = (List)header->next;
if(header->next==NULL) return header;
else{
while(q!=NULL){
header->next = q->next;
q->next = p;
p = q ;
q = header->next;
}
}
return p;
}
int display(List header){
int size = 0;
if(header==NULL)
printf("[%d]",header->item);
else{
List p = header; //非传地址
while(p->next!=NULL){
printf("[%d]",p->item);
p = p->next;
size++;
}
printf("[%d]\n",p->item);
}
return size;
}
int main(){
List list=NULL;
List p;
int i;
list = MakeEmpty(list);
printf("已生成空链表list\n");
p = list;
for(i=1;i<5;i++)
{
Insert(i*i,list,p);
p = p->next;
printf("已插入的值为%d新节点\n",p->item);
}
p = list;
display(list);
printf("逆序输出后数据为:");
display(reverse(p));
return 0;
}
2、JAVA中单链表的实现
public class Node {
int value;
Node nextNode = null;
public String toString(){
return "["+this.value+"]";
}
}
public class testLink {
public static void main(String args[]){
testLink test = new testLink();
Node node1 = new Node();
node1.value = 1;
Node node2 = new Node();
node2.value = 2;
Node node3 = new Node();
node3.value = 3;
Node node4 = new Node();
node4.value = 4;
Node node5 = new Node();
node5.value = 5;
test.add(node1);
test.add(node2);
test.add(node3);
test.add(node4);
test.add(node5);
System.out.print("原链表输出为:");
test.display(test.header);
System.out.print("链表逆序输出为:");
test.header = test.reserve(test.header);
test.display(test.header);
System.out.print("链表插入节点:");
Node node7 = new Node();
node7.value = 7;
test.insert(node7,5);
test.display(test.header);
}
private Node header = null;
/*
* 单链表的插入操作 返回值为节点插入位置
*/
public int insert(Node p,int index){
Node q = header ;
int tag = 0;
while( q!=null&&tag < (index -1)){ //使得 q指向待插入位置的前一个节点
q = q.nextNode;
tag++;
}
if(q==null) return -1;
if(index!=0){
p.nextNode = q.nextNode;
q.nextNode = p;
}else{
p.nextNode = header;
header = p;
}
return tag;
}
/*
* 单链表反向输出
*/
public Node reserve(Node header){
Node p,q;
p = header;
q = header.nextNode;
if(header.nextNode==null) return header;
else{
while(q!=null){
header.nextNode = q.nextNode;
q.nextNode = p;
p = q ;
q = header.nextNode;
}
}
return p;
}
/*
* 添加一个节点
*/
public int add(Node p){
if(header==null) {
header = p ;
header.nextNode = null;
return 0;
}else{
Node q = header;
int index = 0;
while(q.nextNode!=null){
q = q.nextNode;
index++;
}
q.nextNode = p;
return index;
}
}
/*
* 输出单链表
*/
public int display(Node header){
int size = 0;
if(header==null) System.out.print(header.toString());
else{
Node p = header; //非传地址
while(p.nextNode!=null){
System.out.print(p.toString());
p = p.nextNode;
size++;
}
System.out.println(p.toString()+"");
}
return size;
}
}