「java打印链表」链表的输入输出JAVA
本篇文章给大家谈谈java打印链表，以及链表的输入输出JAVA对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、java 链表的输出问题
- 2、使用java设计算法，完成将两个有序递增的单链表合并为一个有序递增的单链表，重复的元素只出现一次。
- 3、java 怎么把链表（linkedList) 的内容输出
- 4、用Java语言实现单向链表
java 链表的输出问题
几位的回答都比较清楚了，我想另外说点问题
你本就不应该加入‘表尾’这个属性，在数据结构中链表的特点就是能用一个地址带一个长串数据链的，不用这个属性的话思路会更加清晰。我也用java模拟过一些基本数据结构：
public class MyNodeT {
public T value;
public MyNodeT next;
public MyNode() {
}
public MyNode(T value) {
this.value = value;
}
public MyNode(MyNodeT t) {
this.value = t.value;
this.next = t.next;
}
public void connect(MyNodeT t){
this.next = t;
}
@Override
public String toString() {
return null==value?"":value+"-";
}
}
在这个节点定义的基础上的链表定义：
public class MyLinkListT{
public MyNodeT next;
public MyLinkList() {
this.next = new MyNodeT();
}
public MyLinkList(T[] tList) {
if(tList.length==0)return;
next = new MyNodeT(tList[0]);
MyNodeT temp = next;
for (int i = 1; i tList.length; i++) {
temp.connect(new MyNodeT(tList[i]));
temp = temp.next;
}
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
MyNodeT t = next;
while (null != t) {
sb.append(t);
t = t.next;
}
return sb.toString();
}
}
然后是相关的操作类：
public class LinkListAction {
MyLinkListComparable list;
public LinkListAction(MyLinkListComparable list) {
this.list = list;
}
/**
* 头插法建立单链表(数组)
* */
public void createFromHead(Comparable...objects){
MyNodeComparable start;
for (int i = 0; i objects.length; i++) {
start = new MyNodeComparable(objects[i]);
start.next = list.next;
list.next = start;
}
}
/**
* 尾插法建立单链表(数组)
* */
public void createFromTail(Comparable...objects){
MyNodeComparable start;
MyNodeComparable end = list.next;
for (int i = 0; i objects.length; i++) {
start = new MyNodeComparable(objects[i]);
end.next = start;
end = start;
}
end.next = null;
}
/**
* 在单链表中查找第i个结点
* */
public MyNodeComparable get(int i){
if(i 0)return null;
MyNodeComparable node = list.next;
int index = 0;
while (node != null index i) {
node = node.next;
index++;
}
return node;
}
/**
* 在单链表中的按值查找
* */
public MyNodeComparable locate(Comparable obj){
if(null == obj)return new MyNodeComparable();
MyNodeComparable node = list.next;
while (node != null !obj.equals(node.value)) {
node = node.next;
}
return node;
}
/**
* 求单链表的长度
* */
public int getLength(){
int length = 0;
MyNodeComparable node = list.next;
while(null != (node = node.next)){
length++;
}
return length;
}
/**
* 单链表的插入操作(按位置)
* */
public void insert(Comparable obj,int location){
int length = 0;
MyNodeComparable node = list.next;
while(node!=null location != length++){node = node.next;}
if(null == node)throw new RuntimeException("插入位置有误！");
MyNodeComparable inserter = new MyNodeComparable(obj);
inserter.next = node.next;
node.next = inserter;
}
/**
* 删除数据
* */
public Comparable delete(int i){
int length = 0;
MyNodeComparable node = list.next;
while(node!=null i != length++){node = node.next;}
if(null == node)throw new RuntimeException("删除位置有误！");
Comparable o = node.next.value;
node.next = node.next.next;
return o;
}
/**
* 合并两个有序的单链表
* */
public static MyLinkListComparable mergeLinkList(MyLinkListComparable la,MyLinkListComparable lb){
MyLinkListComparable lc = new MyLinkListComparable();
MyNodeComparable pc = lc.next;
MyNodeComparable pa = la.next.next;
MyNodeComparable pb = lb.next.next;
while(null != pa || null != pb){
if(null == pa){
pc.next = pb;
break;
}
if(null == pb){
pc.next = pa;
break;
}
if(pa.value.compareTo(pb.value) = 0){
pc.next = pa;
pa = pa.next;
}
else {
pc.next = pb;
pb = pb.next;
}
pc = pc.next;
}
return lc;
}
@Override
public String toString() {
return list.toString();
}
public static void main(String[] args) {
MyLinkListComparable list1 = new MyLinkListComparable();
MyLinkListComparable list2 = new MyLinkListComparable();
LinkListAction lla = new LinkListAction(list1);
// lla.createFromHead(1,3,4,6,8,10);
lla.createFromTail(1,3,4,6,8,10);
LinkListAction llb = new LinkListAction(list2);
llb.createFromTail(2,5,7,9,11);
System.out.println(lla);
System.out.println(llb);
// System.out.println(lla.locate(7));
// System.out.println(lla.getLength());
//
// lla.insert(20, 6);
// System.out.println(lla);
// System.out.println(lla.delete(4));
System.out.println(LinkListAction.mergeLinkList(lla.list, llb.list));
System.out.println(lla);
System.out.println(llb);
}
}
我还写了一些其他的简单数据结构，感兴趣的话，你可以Hi我一下，呵呵。
圣诞快乐！
使用java设计算法，完成将两个有序递增的单链表合并为一个有序递增的单链表，重复的元素只出现一次。
type
point=^node;
node=record
data:integer;
next:point;
end;
var h1,h2,h:point;
procedure prt(p:point); //打印链表
begin
p:=p^.next;
while pnil do
begin
write(p^.data,' ');
p:=p^.next;
end;
writeln;
end;
procedure creat(var h:point); //建立链表
var x:integer; p,q:^node;
begin
writeln('请输入升序的数，负数结束：');
new(h);
p:=h;
read(x);
while(x=0)do
begin
new(q);
q^.data:=x;
p^.next:=q;
p:=q;
read(x);
end;
p^.next:=nil;
end;
function merge_link(var p,q:point):point; //升序合并二个升序链表
var h,w:^node;
begin
w:=p; p:=p^.next; dispose(w); //回收一个头结点，p指向首个数据结点
w:=q; h:=q; q:=q^.next; //h:合并后的头结点，q指向首个数据结点
while (pnil)and(qnil) do //当二个链表都不空时
if(p^.dataq^.data) then //选一个小的结点
begin
w^.next:=p; //把小结点链入
p:=p^.next; //跳过此结点
w:=w^.next; //w指向当前合并后链表的尾结点
end
else
begin //下面三行作用同上
w^.next:=q;
q:=q^.next;
w:=w^.next;
end;
if pnil then w^.next:=p; //将未完的链表接入
if qnil then w^.next:=q; //将未完的链表接入
merge_link:=h; //返回合并后的链表头指针
end;
begin
creat(h1);
creat(h2);
h:=merge_link(h1,h2);
writeln('合并后的链表：');
prt(h);
java 怎么把链表（linkedList) 的内容输出
toString()方法是从Object类继承过来的方法，你需要在SortedTopicList 里重写toString()方法，方法里 根据len做循环，调用你写的get(i)方法输出每一个
用Java语言实现单向链表
1.先定义一个节点类
package com.buren;
public class IntNode {
//定义一个节点类
int
info;
//定义属性，节点中的值
IntNode next;
//定义指向下一个节点的属性
public IntNode(int
i){ //构造一个next为空的节点
this(i,null);
}
public IntNode(int i,IntNode
n){ //构造值为i指向n的节点
info=i;
next=n;
}
}
2.再定义一个链表类，这是主要部分
package com.buren;
public class IntSLList {
private IntNode head,tail;
//定义指向头结点和尾结点的指针，
//如果大家看着这个不像指针的话，那就需要对指针有更深刻的了解
public
IntSLList(){
//定义一个空节点
head=tail=null;
}
public boolean
isEmpty(){
//判断节点是否为空
return
head==null;
//这行代码看起来似乎很神奇，其实真的很神奇，偶是服了
}
public void addToHead(int el){
//将el插入到头结点前
head=new
IntNode(el,head);
//将节点插入到头结点前，作为新的投节点
if(head==tail){
//给空链表插入节点时
tail=head;
//头结点和尾结点指向同一个节点
}
}
public void addToTail(int
el){
//向链表的尾部增加结点
if(!isEmpty()){
//判断链表是否为空
tail.next=new
IntNode(el);
//新建立一个值为el的节点，将链表的尾结点指向新节点
tail=tail.next;
//更新尾指针的指向
}else{
head=tail=new
IntNode(el);
//如果链表为空，新建立一个节点，将头尾指针同时指向这个节点
}
}
public int
deleteFromHead(){
//删除头结点，将节点信息返回
int
el=head.info;
//取出节点信息
if(head==tail){
//如果链表中只有一个节点
head=tail=null;
//删除这一个节点
}else{
head=head.next;
//如果链表中不止一个节点，将头结点的下一个节点作为头结点
}
return
el;
//返回原头结点的值
}
public int
deleteFromTail(){
//删除尾结点，返回尾结点的信息
int
el=tail.info;
//取出尾结点的值
if(head==tail){
// 如果链表中只有一个节点
head=tail=null;
//删除这个节点
}else{
IntNode
temp;
//定义中间变量
for(temp=head;temp.next!=tail;temp=temp.next);
//找出尾结点的前一个节点，注意最后的分号，
//这个for循环是没有循环体的，目的在于找出尾结点的前一个节点
//在整个程序中用了很多次这样的写法，相当经典啊
tail=temp;
//将找出来的节点作为尾结点，删除原来的尾结点
tail.next=null;
//将新尾结点的指向设为空
}
return
el;
//返回原尾结点的信息
}
public void
printAll(){
//打印链表中所有节点的信息
if(isEmpty()){
//如果链表为空
System.out.println("This
list is
empty!");
//输出提示信息
return;
//返回到调用的地方
}
if(head==tail){
//当链表中只有一个节点时
System.out.println(head.info);
//输出这个节点的信息，就是头结点的信息
return;
}
IntNode
temp;
//定义一个中间变量
for(temp=head;temp!=null;temp=temp.next){
//遍历整个链表
System.out.print(temp.info+"
");
//输出每个节点的信息
}
System.out.println();
//输出一个换行，可以没有这一行
}
public boolean isInList(int
el){
//判断el是否存在于链表中
IntNode
temp;
//定义一个中间变量
for(temp=head;temp!=null
temp.info!=el;temp=temp.next);
//将el找出来，注意最后的分
return
temp!=null;
// 如果存在返回true，否则返回flase，这两行代码很有思想
}
public void delete(int
el){
//删除链表中值为el的节点
if(head.info==el
head==tail){
//如果只有一个节点，并且节点的值为el
head=tail=null;
//删除这个节点
}else
if(head.info==el){
// 不止一个节点，而头结点的值就是el
head=head.next;
//删除头结点
}else{
IntNode
pred,temp;
//定义两个中间变量
for(pred=head,temp=head.next;temp.info!=el
temp.next!=null;pred=pred.next,temp=temp.next);
//跟上面的类似，自己琢磨吧，也是要注意最后的分号
pred.next=temp.next;
//将temp指向的节点删除，最好画一个链表的图，有助于理解
if(temp==tail){
//如果temp指向的节点是尾结点
tail=pred;
//将pred指向的节点设为尾结点，
}
}
}
//下面这个方法是在链表中值为el1的节点前面插入一个值为el2的节点，
//用类似的思想可以再写一个在链表中值为el1的节点后面插入一个值为el2的节点
public boolean insertToList(int el1,int
el2){
//定义一个插入节点的方法，插入成功返回true，否则返回false
IntNode
pred,temp; //定义两个中间变量
if(isEmpty()){
//判断链表是否为空
return
false;
//如果链表为空就直接返回false
}
if(head.info==el1
head==tail){
//如果链表中只有一个节点，并且这个节点的值是el1
head=new
IntNode(el2,head);
//新建立一个节点
return
true;
}else if(head.info==el1){
IntNode t=new
IntNode(el2);
t.next=head;
head=t;
return
true;
}else{
for(pred=head,temp=head.next;temp!=null
temp.info!=el1;pred=pred.next,temp=temp.next);
if(temp!=null){
IntNode
a=new IntNode(el2);
pred.next=a;
a.next=temp;
return
true;
}else{
System.out.println(el1+"
NOT EXEISTS!");
return
false;
}
}
}
3.下面是测试代码
public static void main(String[] args){
IntSLList test=new
IntSLList();
//test.addToHead(7);
test.addToTail(7);
System.out.println(test.insertToList(7,5));
test.printAll();
System.out.println(test.isInList(123));
}
}
java打印链表的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于链表的输入输出JAVA、java打印链表的信息别忘了在本站进行查找喔。
发布于：2022-12-26，除非注明，否则均为原创文章，转载请注明出处。