java链表的实现

import java.util.Scanner;

class DATA2

{

String key; //结点的关键字

String name;

int age;

}

class CLType //定义链表结构

{

DATA2 nodeData=new DATA2();

CLType nextNode;

//追加结点

CLType CLAddEnd(CLType head,DATA2 nodeData)

{

CLType node,htemp;

if((node=new CLType())==null)

{

System.out.print("申请内存失败！\n");

return null; //分配内存失败}

else

{

node.nodeData=nodeData; //保存数据

node.nextNode=null; //设置结点指针为空，即为表尾

if(head==null) //头指针

{

head=node;

return head;

}

htemp=head;

while(htemp.nextNode!=null) //查找链表的末尾

{

htemp=htemp.nextNode;

}

htemp.nextNode=node;

return head;

}

}

//添加头结点

CLType CLAddFirst(CLType head,DATA2 nodeData)

{

CLType node;

if((node=new CLType())==null)

{

System.out.print("申请内存失败！\n");

return null; //分配内存失败}

else

{

node.nodeData=nodeData; //保存数据

node.nextNode=head; //指向头指针所指结点

head=node; //头指针指向新增结点

return head;

}

}

//查找结点

CLType CLFindNode(CLType head,String key)

{

CLType htemp;

htemp=head; //保存链表头指针

while(htemp!=null) //若结点有效，则进行查找

{

if(https://www.wendangku.net/doc/9d8792012.html,pareTo(key)==0) //若结点关键字与传入关键字相同

{

return htemp; //返回该结点指针

}

htemp=htemp.nextNode; //处理下一结点

}

return null; //返回空指针

}

//插入结点

CLType CLInsertNode(CLType head,String findkey,DATA2 nodeData)

{

CLType node,nodetemp;

if((node=new CLType())==null) //分配保存结点的内容

{

System.out.print("申请内存失败！\n");

return null; //分配内存失败

}

node.nodeData=nodeData; //保存结点中的数据

nodetemp=CLFindNode(head,findkey);

if(nodetemp!=null) //若找到要插入的结点

{

node.nextNode=nodetemp.nextNode; //新插入结点指向关键结点的下一结点

nodetemp.nextNode=node; //设置关键结点指向新插入结点}

else

{

System.out.print("未找到正确的插入位置！\n");

// free(node); //释放内存

}

return head; //返回头指针

}

int CLDeleteNode(CLType head,String key)

{

CLType node,htemp; //node保存删除结点的前一结点

htemp=head;

node=head;

while(htemp!=null)

{

if(https://www.wendangku.net/doc/9d8792012.html,pareTo(key)==0) //找到关键字，执行删除操作

{

node.nextNode=htemp.nextNode; //使前一结点指向当前结点的下一结点// free(htemp); //释放内存

return1;

}

else

{

node=htemp; //指向当前结点

htemp=htemp.nextNode; //指向下一结点

}

}

return0; //未删除

}

int CLLength(CLType head) //计算链表长度

{

CLType htemp;

int Len=0;

htemp=head;

while(htemp!=null) //遍历整个链表

{

Len++; //累加结点数量

htemp=htemp.nextNode; //处理下一结点

}

return Len; //返回结点数量

}

void CLAllNode(CLType head) //遍历链表

{

CLType htemp;

DATA2 nodeData;

htemp=head;

System.out.printf("当前链表共有%d个结点。链表所有数据如下：\n",CLLength(head));

while(htemp!=null) //循环处理链表每个结点

{

nodeData=htemp.nodeData; //获取结点数据

System.out.printf("结点

(%s,%s,%d)\n",nodeData.key,https://www.wendangku.net/doc/9d8792012.html,,nodeData.age);

htemp=htemp.nextNode; //处理下一结点

}

}

}

public class LinkedList {

public static void main(String[] args) {

CLType node, head=null;

CLType CL=new CLType();

String key,findkey;

Scanner input=new Scanner(System.in);

System.out.print("链表测试。先输入链表中的数据，格式为：关键字姓名年龄\n");

do

{

DATA2 nodeData=new DATA2();

nodeData.key=input.next();

if(nodeData.key.equals("0"))

{

break; //若输入0，则退出

}

else

{

https://www.wendangku.net/doc/9d8792012.html,=input.next();

nodeData.age=input.nextInt();

head=CL.CLAddEnd(head,nodeData);//在链表尾部添加结点

}

}while(true);

CL.CLAllNode(head); //显示所有结点

System.out.printf("\n演示插入结点，输入插入位置的关键字：") ;

findkey=input.next(); //输入插入位置关键字

System.out.print("输入插入结点的数据(关键字姓名年龄):");

DATA2 nodeData=new DATA2();

nodeData.key=input.next();

https://www.wendangku.net/doc/9d8792012.html,=input.next();

nodeData.age=input.nextInt();//输入插入结点数据

head=CL.CLInsertNode(head,findkey,nodeData); //调用插入函数

CL.CLAllNode(head); //显示所有结点

System.out.print("\n演示删除结点，输入要删除的关键字:");

key=input.next(); //输入删除结点关键字

CL.CLDeleteNode(head,key); //调用删除结点函数

CL.CLAllNode(head); //显示所有结点

System.out.printf("\n演示在链表中查找，输入查找关键字:");

key=input.next(); //输入查找关键字

node=CL.CLFindNode(head,key); //调用查找函数，返回结点指针if(node!=null) //若返回结点指针有效

{

nodeData=node.nodeData; //获取结点的数据

System.out.printf("关键字%s对应的结点为

(%s,%s,%d)\n",key,nodeData.key,https://www.wendangku.net/doc/9d8792012.html,,nodeData.age);

}

else//若结点指针无效

{

System.out.printf("在链表中未找到关键字为%s的结点！\n",key);

}

}

}

实验二 链表操作实现

实验二链表操作实现 实验日期： 2017 年 3 月 16 日 实验目的及要求 1. 熟练掌握线性表的基本操作在链式存储上的实现； 2. 以线性表的各种操作（建立、插入、删除、遍历等）的实现为重点； 3. 掌握线性表的链式存储结构的定义和基本操作的实现； 4. 通过本实验加深对C语言的使用（特别是函数的参数调用、指针类型的应用）。 实验容 已知程序文件linklist.cpp已给出学生身高信息链表的类型定义和基本运算函数定义。 （1）链表类型定义 typedef struct { int xh; /*学号*/ float sg; /*身高*/ int sex; /*性别，0为男生，1为女生*/ } datatype; typedef struct node{ datatype data; /*数据域*/ struct node *next; /*指针域*/ } LinkNode, *LinkList; （2）带头结点的单链表的基本运算函数原型 LinkList initList();/*置一个空表（带头结点）*/ void createList_1(LinkList head);/*创建单链表*/ void createList_2(LinkList head);/* 创建单链表*/ void sort_xh(LinkList head);/*单链表排序*/ void reverse(LinkList head);/*对单链表进行结点倒置*/ void Error(char *s);/*自定义错误处理函数*/ void pntList(LinkList head);/*打印单链表*/ void save(LinkList head,char strname[]);/*保存单链表到文件*/

Java 链表操作

链表是一种重要的数据结构，在程序设计中占有很重要的地位。C语言和C＋＋语言中是用指针来实现链表结构的，由于Java语言不提供指针，所以有人认为在Java语言中不能实现链表，其实不然，Java语言比C和C＋＋更容易实现链表结构。Java语言中的对象引用实际上是一个指针（本文中的指针均为概念上的意义，而非语言提供的数据类型），所以我们可以编写这样的类来实现链表中的结点。 class Node { Object data; Node next;// 指向下一个结点 } 将数据域定义成Object类是因为Object类是广义超类，任何类对象都可以给其赋值，增加了代码的通用性。为了使链表可以被访问还需要定义一个表头，表头必须包含指向第一个结点的指针和指向当前结点的指针。为了便于在链表尾部增加结点，还可以增加一指向链表尾部的指针，另外还可以用一个域来表示链表的大小，当调用者想得到链表的大小时，不必遍历整个链表。下图是这种链表的示意图： 链表的数据结构 我们可以用类List来实现链表结构，用变量Head、Tail、Length、Pointer来实现表头。存储当前结点的指针时有一定的技巧，Pointer并非存储指向当前结点的指针，而是存储指向它的前趋结点的指针,当其值为null时表示当前结点是第一个结点。那么为什么要这样做呢？这是因为当删除当前结点后仍需保证剩下的结点构成链表，如果Pointer指向当前结点，则会给操作带来很大困难。那么如何得到当前结点呢，我们定义了一个方法cursor(),返回值是指向当前结点的指针。类List还定义了一些方法来实现对链表的基本操作，通过运用这些基本操作我们可以对链表进行各种操作。例如reset()方法使第一个结点成为当前结点。insert(Object d)方法在当前结点前插入一个结点，并使其成为当前结点。remove()方法删除当前结点同时返回其内容，并使其后继结点成为当前结点，如果删除的是最后一个结点，则第一个结点变为当前结点。 链表类List的源代码如下：

单链表实现图书管理系统

单链表：typedef struct { char num[20]; char name[50]; float pri; }Book; typedef struct LNode{ //线性表的单链表存储 Book book; //数据域 struct LNode *next; //指针域 }LNode,*LinkList; void Input(LinkList &L){ //前插法创建图书链表 LinkList p; L=new LNode; L->next=NULL;//初始化单链表 ifstream inFile("book.txt"); if(!inFile){ cerr<<"Cannot open this file!"<>book_head1>>book_head2>>book_head3;//读取文件中的标题 while(!inFile.eof()){//到达文件尾部前逐行依次读取所有图书数据 p=new LNode; //生成新结点 inFile>>p->book.num>>p->https://www.wendangku.net/doc/9d8792012.html,>>p->book.pri; p->next=L->next; //插入到表头 L->next=p;h } inFile.close(); cout<<"读取完毕!"<next; while(p){ cout<book.num<<"\t"<https://www.wendangku.net/doc/9d8792012.html,<<"\t"<book.pri<next; } cout<<"\n信息显示完毕\n"<

数据结构(Java版)-线性表的实现与应用完整版

数据结构(Java版)-线性表的实现与应用完整版

实验报告 课程名称数据结构 实验项目线性表的实现及应用 实验仪器PC机一台 学院_____ 专业 班级/学号 姓名 实验日期 成绩 指导教师

北京信息科技大学 信息管理学院 （数据结构课程上机）实验报告 专业: 班级: 学号: 姓名: 成绩: 实验名称线性表的实现及应用实验地点实验时间 1.实验目的： （1）理解用顺序表实现线性表的特点；熟练掌握顺序表的基本操作；学会利用顺序表解决实际应用问题。 （2）熟练掌握单链表的使用；理解用链表实现线性表的特点；了解链表的多种形式；学会利用单链表解决实际应用问题。 2.实验要求： （1）学时为8学时； （2）能在机器上正确、调试运行程序； （3）本实验需提交实验报告； （4）实验报告文件命名方法：数据结构实验_信管16xx_学号_姓名.doc。 3.实验内容和步骤： 第一部分顺序表的实现与应用 （1）基于顺序表实现线性表的以下基本操作： public interface LList { //线性表接口，泛型参数T表示数据元素的数据类型 boolean isEmpty(); //判断线性表是否空 int size(); //返回线性表长度 T get(int i); //返回第i（i≥0）个元素 void set(int i, T x); //设置第i个元素值为x void insert(int i, T x); //插入x作为第i个元素 void insert(T x); //在线性表最后插入x元素 T remove(int i); //删除第i个元素并返回被删除对象 int search(T key); //查找，返回首次出现的关键字为key的元素的位序void removeAll(); //删除线性表所有元素 public String toString();//返回顺序表所有元素的描述字符串，形式为“（，）” } 要求：实现后应编写代码段对每个基本操作做测试。

实验三四 链表的实现和应用

江南大学物联网工程学院上机报告
课程名称 班 级 数据结构 上机名称 姓 名 链表的实现和应 用 上机日期 学 号 2016.3.11 上机报告要求 1．上机名称 2．上机要求 3．上机环境 4．程序清单（写明运行结果） 5．上机体会
1．上机名称
链表的实现和应用
2．上机要求
⑴定义线性表的链式存储表示； ⑵基于所设计的存储结构实现线性表的基本操作； ⑶编写一个主程序对所实现的线性表进行测试； ⑷线性表的应用：①设线性表 L1和 L2分别代表集合 A 和 B，试设计算法求 A 和 B 的并集 C，并用线 性表 L3代表集合 C；②设线性表 L1和 L2中的数据元素为整数，且均已按值非递减有序排列，试 设计算法对 L1和 L2进行合并，用线性表 L3保存合并结果，要求 L3中的数据元素也按值非递减 有序排列。 ⑸设计一个一元多项式计算器，要求能够：①输入并建立多项式；②输出多项式；③执行两个多项式 相加；④执行两个多项式相减；⑤（选做）执行两个多项式相乘。
3．上机环境
Visual C++ 6.0
4．程序清单（写明运行结果）
（1） #include #include typedef int datatype; typedef struct node { datatype data; struct node *next; }LinkList; LinkList *CREATLISTF(LinkList *L,int n) { intnum,i; LinkList *head,*s,*r; head=L; r=head; head->next=NULL;

C语言链表功能实现

#include #define MaxSize 10 #define error 0 typedef int ElemType; typedef struct{ ElemType elem[MaxSize]; int last; }SeqList; void Input(SeqList *L);//Input the list void Output(SeqList L);//Output the list void Search(SeqList L);//Search element void Insert(SeqList *L); void Delete(SeqList *L); void Sort(SeqList *L); void bubblesort(SeqList *L); void selectsort(SeqList *L); void Function(); int main(){ int i,flag=1,k; ElemType e; SeqList L; https://www.wendangku.net/doc/9d8792012.html,st=0; Function(); printf("Please pick an option: "); scanf("%d",&k); while(flag){ switch(k){ case 0:{ flag=0; break; } case 1:{ Input(&L); break; } case 2:{ Output(L); break; } case 3:{ Insert(&L); break; } case 4:{

Search(L); break; } case 5:{ Delete(&L); break; } case 6:{ bubblesort(&L); break; } case 7:{ selectsort(&L); break; } default :{ printf("\nOption is useless.Please input again."); break; } } if(flag){ printf("\nPlease pick an option: "); scanf("%d",&k); } } return 0; } void Input(SeqList *L){ int i,n; printf("Please input the sum of elements:\n"); scanf("%d",&n); while(n>MaxSize){ printf("Sum is bigger than MaxSize,please input again\n"); scanf("%d",&n); } printf("Input the elements of list:\n"); for(i=0;ielem[i]); L->last++; } } void Output(SeqList L){

JAVA数据结构——单链表的操作

单链表的操作方法一： package ch02; (1)建立结点类Node.java public class Node { public Object data;//存放结点数据值 public Node next;//存放后继结点 //无参构造函数 public Node(){ this(null,null); } //只有结点值的构造函数 public Node(Object data){ this(data,null); } //带有节点值和后继结点的构造函数 public Node(Object data,Node next){ this.data=data; this.next=next; } } （2）建立链表及操作LinkList.java package ch02; import java.util.Scanner;

public class LinkList implements IList{ public Node head;//单链表的头指针 //构造函数初始化头结点 public LinkList(){ head=new Node(); } //构造函数构造长度为n的单链表 public LinkList(int n,boolean Order) throws Exception{ this(); if(Order) create1(n); //头插法顺序建立单链表 else create2(n); //尾插法逆序建立单链表 } //头插法顺序建立单链表 public void create1(int n) throws Exception{ Scanner sc=new Scanner(System.in); System.out.println("请输入结点的数据（头插法）："); for(int i=0;i

用Java写一个链表数据

用Java写一个链表数据 Java代码 1.package arrayListTest; 2.//定义一个链表 3.public class Node{ 4. 5.private int m_Data;//链表中的数据 6.private Node m_Next;//链表中指针属性指向下个Node 对象的对象应用 7.Node(int data){ 8.m_Data=data; 9.m_Next=null; 10.} 11.Node(int data,Node next){ 12.m_Data=data; 13.m_Next=next; 14.} 15.void setData(int data){//修改节点中的数据 16.m_Data=data; 17. 18.} 19.int getData(){//获得节点中的数据 20.return m_Data; 21.} 22.void setNext(Node next){//修改节点的指针 23.m_Next=next; 24.} 25.Node getNext(){//获得节点中的指针指向的对象的引用 26.return m_Next; 27.} 28.} Java代码 1.package arrayListTest; 2.//修改链表 3.public class LinksList{ 4. 5.Node m_FirstNode;//链表中的第一个节点 6.//构造函数

7.LinksList(){ 8.m_FirstNode=null; 9.} 10.LinksList(int data){ 11.m_FirstNode=new Node(data); 12.} 13.String visitAllNode(){//遍历数据将数据串成一个字符 串返回一个S 14.Node next=m_FirstNode; 15.String s=""; 16.while(next!=null){ 17.s=s+next.getData()+";"; 18.next=next.getNext(); 19.} 20.return s; 21.} 22.void insertAtBegin(int data){//将数据插入到节点的前 面 23.if(m_FirstNode==null){//如果是空链表的话直接插入就可以 了 24.m_FirstNode=new Node(data);//把data做为第一个 节点传给Node对象 25.} 26.else{ 27.m_FirstNode=new Node(data,m_FirstNode);//把新节点 插入到第一个节点的前面并指向原来的第一个节点 28.} 29.} 30.void insertAfterId(int data,int id){//将数据data插入到 包含数据ID的节点后面若连接没有id则插入在整个链表的最后 31.Node next=m_FirstNode; 32.if(next==null){//对空链表直接插入 33.m_FirstNode=new Node(data); 34.}else{ 35.while(next.getNext()!=null&&next.getData()==id){ 36.next=next.getNext();//找到合适的插入位置 37.//Node i=next.getNext();//创建一个next的指 针 38.//Node next1=new Node(data,i);//创建Node的 对象把data插入到I的位置上 39.//next.setNext(next1); 40.next.setNext(new Node(data,next.getNext()));// 按照id来设置数据

单链表的建立及其基本操作的实现(完整程序)

#include "stdio.h"/*单链表方式的实现*/ #include "malloc.h" typedef char ElemType ; typedef struct LNode/*定义链表结点类型*/ { ElemType data ; struct LNode *next; }LNode,*LinkList;/*注意与前面定义方式的异同*/ /*建立链表，输入元素，头插法建立带头结点的单链表(逆序)，输入0结束*/ LinkList CreateList_L(LinkList head) { ElemType temp; LinkList p; printf("请输入结点值(输入0结束)"); fflush(stdin); scanf("%c",&temp); while(temp!='0') { if(('A'<=temp&&temp<='Z')||('a'<=temp&&temp<='z')) { p=(LinkList)malloc(sizeof(LNode));/*生成新的结点*/ p->data=temp; p->next=head->next; head->next=p;/*在链表头部插入结点，即头插法*/ } printf("请输入结点值(输入0结束)："); fflush(stdin); scanf("%c",&temp); } return head; } /*顺序输出链表的内容*/ void ListPint_L(LinkList head) { LinkList p; int i=0; p=head->next; while(p!=NULL) { i++; printf("单链表第%d个元素是：",i);

利用单项链表实现简单的学生信息管理

利用单项链表实现简单的学生信息管理 一、题目： 利用单项链表实现简单的学生信息治理（07） 二、设计思路 1、总体设计 1）分析程序的功能 创建单项链表储存学生的各项信息，学号、姓名、成绩。并能够完成学生信息的插入、删除及信息的显示功能。 2）系统总体结构： 按照程序要求的功能采纳结构化的设计思想，划分为五个功能模块，即创建链表、插入函数、删除函数、显示函数和主函数。 2、各功能模块的设计：讲明各功能模块的实现方法 ①头文件：对自己定义的函数进行函数声明。 ②主函数：进行函数的调用，实现各函数的功能，达到预期的目的。 ③函数定义部分：定义各个功能函数，创建链表函数、插入新信息函数、删除信息函数、显 示信息函数。 3、设计中的要紧困难及解决方案 1）在插入新信息时，有插入点在表头、中间、表尾三种情形，为此采纳讨论的方法，把三种情形进行讨论使其分开进行。 2）在删除信息时，有删除的为头结点和中间结点的情形，采纳讨论的方法，把两种情形分开来进行。 4、你所设计的程序最终完成的功能 1）创建链表、插入新信息、删除信息、显示信息。 2）测试数据 ①输入的数据

99812 LiuLifang 91 学号姓名成绩 96085 WangLiPing 77 98120 ZhangLi 75 99912 LiuHai 80 ③删除的数据 学号姓名成绩 99812 liulifang 91 运行结果

三、程序清单 本程序包含creatlist.cpp、insert.cpp、del.cpp、output.cpp、main.cpp、头文件.h六个文件

#include #include"头文件.h" int n; student *creatlist() { student *head; student *p1; student *p2; n=0; head=NULL; p1=new(student); //创建一个新结点 p2=p1; cin>>p1->num>>p1->name>>p1->score; while(p1->num!=0) //链表建立过程终止的判定条件{ n++; head=p1; else p2->next=p1; //原链表结点指向新建结点p2=p1; p1=new(student); cin>>p1->num>>p1->name>>p1->score; } delete(p1); p2->next=NULL; return head; //返回表头 } 2、insert.cpp文件清单 #include #include"头文件.h" student *insert(student *head,student *t) { student *p0; //待插入点 student *p1; student *p2; //p0插入p1之前，p2之后p1=head; p0=t; if(p1==NULL) //原链表是空表 { head=p0; p0->next=NULL; } else

《数据结构Java版》线性表之单链表的建立及操作

《数据结构Java》线性表之单链表的建立及操作 package sjjg3; //单链表结点类，T指定结点的元素类型 public class Node { public T data;//数据域，存储数据元素 public Node next;//地址域，引用后继结点 public Node(T data,Node next) {//构造结点，data指定数据元素，next指定后继结点 this.data=data;//T对象引用赋值 this.next=next;//Node对象引用赋值 } public Node() { this(null, null); } public String toString() {//返回结点数据域的描述字符串 return this.data.toString(); } } package sjjg3; //单链表类，实现ADT List声明方法，T表示数据元素的数据类型 public class SinglyList extends Object{ public Node head;//头指针，指向单链表的头结点 //（1）构造方法 public SinglyList() {//构造空单链表 this.head=new Node();//创建头结点，data和next值均为null } public SinglyList(T[] values) {//构造单链表，由values数组提供元素this();//创建空单链表，只有头结点 Node rear=this.head;//rear指向单链表最后一个结点 for(int i=0;i(values[i],null);//尾插入，创建结点链入rear结点之后 rear=rear.next;//rear指向新的链尾结点 } } public boolean isEmpty() {//判断单链表是否空，O(1) return this.head.next==null; } //（2）存取 public T get(int i) {//返回第i个元素，0<=i<表长度。若i越界，则返回null。O(n) Node p=this.head.next; for(int j=0;p!=null && j

利用单向链表,实现学生管理系统java练习

Java作业： 4-13.参照例4-23，利用单向链表，实现学生管理系统。解： 运行图： A.主菜单 B.增加学生并且打印学生信息 C.删除学生信息

D.修改学生信息 E.查找学生信息 代码实现： (1).单向链结点LinkListElement类 public class LinkListElement { protected Object data; protected LinkListElement nextElement;

public LinkListElement(Object v ,LinkListElement next) { data=v; nextElement=next; } public LinkListElement(Object v) { data=v; nextElement=null; } public LinkListElement next() { return nextElement; } public void setNext (LinkListElement next){ nextElement=next; } public Object value(){ return data; } public void setValue (Object value){ data=value; } } （2）.单向链表LinkList类描述 public class LinkList { protected int count; protected LinkListElement head; public LinkList(){ head=null; count=0; } public boolean isEmpty(){ return count==0; } public void addToTail(Object value){ LinkListElement temp=new LinkListElement(value,null); if(head!=null){ LinkListElement finger=head; while(finger.next()!=null){ finger=finger.next();

Java数据结构链表的插入与删除

import java.util.*; import java.io.*; public class zhangyue { public static void main(String args[]){ File readFile=new File("F://book.txt"); Book book=new Book(); Scanner read=new Scanner(System.in); Mylist list=new Mylist(); try { FileReader inOne=new FileReader(readFile); BufferedReader inTwo=new BufferedReader(inOne); String s=null; int j=0,x=0; while((s=inTwo.readLine())!=null) { if(x==0) { x=1; System.out.println(s); } else { Book book1=new Book(); String ss[]=s.split("\\t"); for(j=0;j<3;j++) { book1.no=ss[0]; https://www.wendangku.net/doc/9d8792012.html,=ss[1]; book1.price=Integer.parseInt(ss[2]); } //这种字符串的解析不会用 list.addTail(book1); } } inTwo.close(); inOne.close(); }catch(IOException e) {System.out.println(e);} list.output(); System.out.println("请输入你要查找的方法（1是按书名查找，2是按编号查找）："); int ch=0; String t1=null; Scanner readOne=new Scanner(System.in);

链表抽象数据类型的实现

/*线性表抽象数据类型的带头结点单链表实现*/ #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -2 #define MAXSIZE 100 #define NULL 0 typedef int status; typedef int elemtype; typedef struct lnode{ elemtype data; struct lnode *next; }lnode,*linklist; /*初始化*/ status initlist(linklist *l){ *l=(linklist)malloc(sizeof(lnode)); if(*l) {(*l)->next=NULL; return OK; } else return OVERFLOW; } /*销毁*/ status destroylist(linklist *l){ linklist p; while(*l){ p=*l; *l=(*l)->next; free(p); } return OK; } /*置空*/ status clearlist(linklist *l){ linklist p,q; p=(*l)->next; (*l)->next=NULL; while(p){ q=p; p=p->next; free(q); } return OK;

} /*求单链表长度*/ int listlength(linklist l){ linklist p; int i=0; p=l->next; while(p){ i++; p=p->next; } return i; } /*单链表空否*/ status listempty(linklist l){ if(l->next) return FALSE; else return TRUE; } /*查找*/ int locateelem(linklist l,elemtype e){ int i=0; linklist p; p=l->next; while(p){ i++; if (p->data==e) return i; p=p->next; } return 0; } /*读第i个元素*/ status getelem(linklist l,int i,elemtype *e){ int j=1; linklist p; p=l->next; while(p&&(jnext; } if (!p|| (j>i)) return ERROR; *e=p->data; return OK; } /*求前驱元素*/ status priorelem(linklist l,elemtype cur_e,elemtype *pre_e){

数据结构之双向链表的Java实现

数据结构之双向链表地Java 实现 单链表只能从前往后遍历,如果链表地长度较大, 遍历到链表后半部分地时候想要往前查找,就只能回到开头,重新遍历了. 双向链表提供了这个能力, 即允许前向遍历, 也允许后向遍历整个链表. 原因是双向链表地每个节点都有两个指向其他节点地引用. 但这也是其缺点, 因为在插入、删除地时候需要处理四个链接点地引用, 占用地空间也大了一些. 如将头节点和尾节点链接起来, 即成为双向循环链表. b5E2RGbCAP 下面是java 代码： package test 。 public class DoubleLink { public Link first 。 public Link last 。 public DoubleLink< ) {// 构造器, 初始化 this.first = null 。 https://www.wendangku.net/doc/9d8792012.html,st = null 。 } public boolean isEmpty< ) {// 判断是否为空 return first == null 。 } public void insertFirst

link.next = first 。 first = link 。 } public void insertLast

数据结构与算法单链表的实现

单链表的实现 实现单链表的基本操作，必须包括初始化链表(元素为空)、销毁链表、求表长、查找、插入、删除、遍历（打印）等操作。请编写程序，实现上述单链表的基本操作。 注意：1.元素类型可以自定义 2.可以是带头结点的单链表或不带头结点的单链表 #include #include #include typedef int datatype; typedef struct node { datatype data; struct node *next; }LNode,*LinkList; /* //创建不带头结点的单链表 Linklist Create_LinkList() { return NULL; } */ //创建带头结点的单链表 LinkList Create_LinkList() { LinkList L=NULL; L=(LinkList)malloc(sizeof(LNode)); if(L) L->next=NULL; return L; } //打印单链表

void Print_LinkList(LinkList H) { if(H == NULL) { printf("?????????\n"); } else { printf("head-->"); LinkList p=H->next; while(p!=NULL) { printf("%d",p->data); printf("-->"); p=p->next; } printf("\n"); } } //销毁单链表 void Destroy_LinkList(LinkList *H) { LinkList p, q; p = *H; while(p) { q = p; p = p->next; free(q); } *H = NULL; if(*H==NULL) printf("销毁成功，请退出\n"); else printf("销毁失败\n"); }

JAVA循环双链表的建立

JAVA循环双链表的建立 import java.util.Scanner; //循环双向链表的结点类 class DuLNode { private Object data;// 存放结点值 private DuLNode prior; // 前驱结点的引用 private DuLNode next; // 后继结点的引用 public DuLNode() {// 无参数时的构造函数 this(null); } public DuLNode(Object data) {// 构造值为data 的结点this.data = data; this.prior = null; this.next = null; } public Object getData() { return data; } public DuLNode getNext() {

return next; } public DuLNode getPrior() { return prior; } public void setData(Object data) { this.data = data; } public void setNext(DuLNode next) { this.next = next; } public void setPrior(DuLNode prior) { this.prior = prior; } } //双向链表类 public class DuLinkList{ private DuLNode head;// 双向循环链表的头结点// 双向链表的构造函数 public DuLinkList() { head = new DuLNode(); // 初始化头结点 head.setPrior(head);// 初始化头结点的前驱和后继

链表的C语言实现之单链表的查找运算

建立了一个单链表之后，如果要进行一些如插入、删除等操作该怎么办？所以还须掌握一些单链表的基本算法，来实现这些操作单链表的基本运算包括：查找、插入和删除下面我们就一一介绍这三种基本运算的算法，并结合我们建立单链表的例子写出相应的程序 1、查找 对单链表进行查找的思路为：对单链表的结点依次扫描，检测其数据域是否是我们所要查好的值，若是返回该结点的指针，否则返回null 因为在单链表的链域中包含了后继结点的存储地址，所以当我们实现的时候，只要知道该单链表的头指针，即可依次对每个结点的数据域进行检测 以下是应用查找算法的一个例子： #include ＜stdio.h＞ #include ＜malloc.h＞ #include ＜string.h＞/*包含一些字符串处理函数的头文件*/ #define n 10 typedef struct node { char name[20]; struct node *link; }stud; stud * creat(int n) /*建立链表的函数*/ { stud *p,*h,*s; int i; if((h=(stud *)malloc(sizeof(stud)))==null) { printf(\"不能分配内存空间!\"); exit(0); } h-＞name[0]=\'\\0\'; h-＞link=null; p=h; for(i=0;i＜n;i++) { if((s= (stud *) malloc(sizeof(stud)))==null) { printf(\"不能分配内存空间!\"); exit(0); } p-＞link=s;

单链表的创建及功能实现(java编写)

2014-6-28 //任一类学生为例，建立动态结构—单链表的结构形式；完成学生单链表的建立、插入、删除、查询等功能。请用面向对象的思想分析问题及书写程序。 import java.util.Scanner; public class List { //定义一个内部类 public class Node { int data; Node next;//指向下一个节点的引用 public Node(int data,Node next) { this.data=data;this.next=next; } }//内部类结束 public Node header; public Node p; static int length; public void CreatList(int a[])//尾插法创建单链表 { Node q=new Node(0,null); header=q; for(int i=0;ilength-1) { System.out.println("链表索引越界"); } Node k=header.next; for(int i=0;i

return null; } public void insertList(int index,int data)//插入元素{ if(index<0||index>length) { System.out.println("链表索引越界"); } else { Node j=getNodebyindex(index-1); Node newnode=new Node(data,null); newnode.next=j.next; j.next=newnode; length++; } } public void Delete(int index)//删除节点 { if(index<0||index>length-1) { System.out.println("链表索引越界"); } Node j=getNodebyindex(index-1); Node del=j.next; j.next=del.next; length--; } public void Getelem(int index)//查询索引index处的元素{ if(index<0||index>length-1) { System.out.println("链表索引越界"); } Node k=getNodebyindex(index); System.out.println("查询得到的元素为:"+k.data); } public void print()//输出链表 { Node p=header.next;