单向链表java
㈠ java中单向链表用的多吗
java中单向链表用的多.
这是我写的一个差不多，你看一下吧：
package com.test.list;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class LinkedList {
public static void main(String[] args) {
MyList l = new MyList();
MyListNode node = l.createList();
l.printNode(node);
//l.searchNode(node, 4);
//node = l.insertNode(node, 3, "g");
//l.printNode(node);
node = l.deleteNode(node, "d");
l.printNode(node);
}
}
class MyListNode {
public String data;
public MyListNode nextNode;
}
class MyList {
public MyListNode createList() {
MyListNode node = new MyListNode();
MyListNode q ,p;
q = new MyListNode();
q = node;
while (true) {
String s = null;
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("请输入节点数据：");
s = br.readLine();
if (s.equals("0")) {
break;
} else {
p = new MyListNode();
p.data = s;
p.nextNode = null;
q.nextNode = p;
q = p;
}
} catch (Exception e) {
e.printStackTrace();
}
}
return node;
}
public void printNode(MyListNode node) {
MyListNode p = node.nextNode;
while (p!= null) {
System.out.print(" "+p.data);
p = p.nextNode;
}
}
public void searchNode(MyListNode node, int i){
MyListNode p = node.nextNode;
int j = 1;
while (p != null && j<i) {
p = p.nextNode;
j++;
}
if( p == null || j>i) {
System.out.println("error");
}
System.out.println(" --"+p.data+"--");
}
public MyListNode insertNode(MyListNode node, int i ,String s) {
MyListNode p = node.nextNode;
int j = 1;
while (p != null && j<i-1) {
p = p.nextNode;
j++;
}
if( p == null || j>i-1) {
System.out.println("error");
}
MyListNode n = new MyListNode();
n.data = s;
n.nextNode = p.nextNode;
p.nextNode = n;
return node;
}
public MyListNode deleteNode(MyListNode node ,String s) {
MyListNode p = node;
while(p.nextNode != null && !p.nextNode.data.equals(s)) {
p = p.nextNode;
}
p.nextNode = p.nextNode.nextNode;
return node;
}
}
/*逆位序创建
public MyListNode createList() {
MyListNode node = new MyListNode();
node.nextNode = null;
while(true) {
String s = null;
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("请输入节点数据：");
s = br.readLine();
if(s.equals("0")) {
break;
}else {
MyListNode n = new MyListNode();
n.data = s;
n.nextNode = node.nextNode;
node.nextNode = n;
}
} catch (Exception e) {
e.printStackTrace();
}
}
return node;
}
*/
㈡ Java单向链表代码。
这是我写的一个差不多，你看一下吧：
package com.test.list;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class LinkedList {
public static void main(String[] args) {
MyList l = new MyList();
MyListNode node = l.createList();
l.printNode(node);
//l.searchNode(node, 4);
//node = l.insertNode(node, 3, "g");
//l.printNode(node);
node = l.deleteNode(node, "d");
l.printNode(node);
}
}
class MyListNode {
public String data;
public MyListNode nextNode;
}
class MyList {
public MyListNode createList() {
MyListNode node = new MyListNode();
MyListNode q ,p;
q = new MyListNode();
q = node;
while (true) {
String s = null;
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("请输入节点数据：");
s = br.readLine();
if (s.equals("0")) {
break;
} else {
p = new MyListNode();
p.data = s;
p.nextNode = null;
q.nextNode = p;
q = p;
}
} catch (Exception e) {
e.printStackTrace();
}
}
return node;
}
public void printNode(MyListNode node) {
MyListNode p = node.nextNode;
while (p!= null) {
System.out.print(" "+p.data);
p = p.nextNode;
}
}
public void searchNode(MyListNode node, int i){
MyListNode p = node.nextNode;
int j = 1;
while (p != null && j<i) {
p = p.nextNode;
j++;
}
if( p == null || j>i) {
System.out.println("error");
}
System.out.println(" --"+p.data+"--");
}
public MyListNode insertNode(MyListNode node, int i ,String s) {
MyListNode p = node.nextNode;
int j = 1;
while (p != null && j<i-1) {
p = p.nextNode;
j++;
}
if( p == null || j>i-1) {
System.out.println("error");
}
MyListNode n = new MyListNode();
n.data = s;
n.nextNode = p.nextNode;
p.nextNode = n;
return node;
}
public MyListNode deleteNode(MyListNode node ,String s) {
MyListNode p = node;
while(p.nextNode != null && !p.nextNode.data.equals(s)) {
p = p.nextNode;
}
p.nextNode = p.nextNode.nextNode;
return node;
}
}
/*逆位序创建
public MyListNode createList() {
MyListNode node = new MyListNode();
node.nextNode = null;
while(true) {
String s = null;
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("请输入节点数据：");
s = br.readLine();
if(s.equals("0")) {
break;
}else {
MyListNode n = new MyListNode();
n.data = s;
n.nextNode = node.nextNode;
node.nextNode = n;
}
} catch (Exception e) {
e.printStackTrace();
}
}
return node;
}
*/
㈢ java 什么是单向链表 和 双向链表
链表是类似一种数据结构的东西，就是分别存放有地址以及数据单项链表一般是上一个存放地址的地方存放下一个节点的地址，而双向的就是有两个存放地址的地方，分别存上一个以及下一个的地址。大概是这样子
㈣ java数据结构单链表
你的问题很好理解。但是你的代码问题严重。
1、你想用java代码实现还是c代码实现？从你的代码看是c语言
2、第一段代码中的结构体nod是不是应该写成Node？
3、inset函数中，链表L是有变化的，所以要用指针。结点s是不改变的，所以不应该用指针
4、既然s不是用指针，后面的s->next自然也不能这么写了。
㈤ Java单链表的问题
class Node{ private Object data; private Node next; Node (){} Node (Object data) { this.setData(data); this.setNext(null); } public void setData(Object data){ this.data = data; } public void setNext(Node next){ this.next = next; } public Object getData(){ return this.data; } public Node getNext(){ return this.next; } public String printNode(){ return "节点内的内容为："+this.getData(); } public boolean equals(Node node){ if(this.getData().equals(node.getData())) return true; else return false; } } class SingleLink{ private Node root; private int size; SingleLink() { this.setSize(); } public void setSize(){ if(this.root==null) { size = 0; } Node temp; temp = this.root; while(temp!=null){ size++; temp = temp.getNext(); } } public int getSize(){ return this.size; } public Node addNode(Node newNode){ if(this.root == null){ this.root = newNode; size++; return this.root; } Node temp = this.root; while(temp.getNext()!=null){ temp = temp.getNext(); } temp.setNext(newNode); size++; return this.root; } public void print(){ if(this.root == null ){ System.out.println("链表不存在！"); } int count=0; Node temp; temp = this.root; while(temp!=null) { System.out.print("第"+(++count)+"个"+temp.printNode()+"->"); temp=temp.getNext(); } System.out.println(); } public boolean search(Object data){ if(this.root == null ){ System.out.println("链表不存在！"); return false; } boolean flag = false; Node temp; temp=this.root; while(temp!=null){ if(temp.getData().equals(data)){ flag = true; break; } temp = temp.getNext(); } return flag; } public void deleteNode(Object data){ if(this.root == null ){ System.out.println("链表不存在！"); } Node temp; temp=this.root; while(temp!=null){ if(temp.getNext().getData().equals(data)){ break; } temp = temp.getNext(); } if(temp==null){ System.out.println("未找到节点！"); } else { temp.setNext(temp.getNext().getNext()); } } } public class LinkDemo{ public static void main(String args[]){ Node node依 = new Node("第依个节点"); Node node贰 = new Node("第贰个节点"); Node node三 = new Node("第三个节点"); Node node四 = new Node("第四个节点"); Node node5 = new Node("第5个节点"); Node node陆 = new Node("第陆个节点"); SingleLink singleLink = new SingleLink(); //System.out.println(singleLink.getSize()); singleLink.addNode(node依); singleLink.addNode(node贰); singleLink.addNode(node三); singleLink.addNode(node四); singleLink.addNode(node5); singleLink.addNode(node陆); //System.out.println(singleLink.getSize()); //singleLink.print(); if(singleLink.search("第漆个节点")) { System.out.println("节点存在！"); } else{ System.out.println("节点不存在！"); } singleLink.deleteNode("第贰个节点"); singleLink.print();
㈥ java单向链表基础知识~~求通俗解答
话说...通俗解答啊...给你个比喻吧...
自行车都骑过吧...自行车的齿轮用的链子看过吧...
如果你拆开过应该发现其实是一节一节组成的,也就是说这一节一节的单个的组成链子的东西是组成车链的基本元素
然后再对应回去...这个一个个一节的东西就是链表中的一个个节点,需要注意的是,链表中的一个个节点可以是一个个对象,而对象又可以是别的数组或者什么东西.
至于单向链表就是你把那个车链子弄断,然后如果你向着一个方向一直前进移动,总会有尽头,这两个指针就是头指针和终结指针.
然后链表分三种,单向链表,双向链表和循环链表
在单向链表中,你只能从一个节点到下一个节点,因为它只包含一个指向下个节点的指针和一个对象.你可以把节点理解为一个对象,它包含的信息有1个指针(指向下个节点的地址),一个指针的值,就是一个对象.
双向链表是单向链表的加强版,它含有2个指针(比单向链表多一个),一个指向上一个节点的地址,另一个指向下一个节点的地址,所以它能够双向移动读取.
循环链表是双向链表的加强版,双向链表的所有节点是一条线的线性排列,然后你将头节点的上一个节点的指针指向终结节点,然后将终结节点的下一个节点的指针指向头节点,就相当于你将一个断开的车链重新修好了,不过这里的连接是靠指针的指向而已,然后它就成一条线变成了一个圆,然后这就是循环链表了...
还有什么不懂的可以问我
㈦ 用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 单向链表为什么是无序的
我刚看了IT黑马的同一个教学视频，我当时也没看懂，不过我现在有了一点猜想。
我想你的疑惑是单链表理论上明明是可以做到有序的（比如用C++，程序员来安排每个节点的指针），但为什么这里说单链是无序的呢？我觉得这有可能和这个类的底层实现机制有关系。
例如在插入的时候，JVM优先考虑的是存储空间上的顺序以提高执行效率，所以这条链的顺序可能是节点在堆内存上的顺序，所以对于它存储的信息或是存入的先后而言就是无序的了。至于双链表为什么有序，则可能是因为设计者认为已经用一条链保证了链表结构和执行效率，那么第二条链就没有必要按部就班的成为第一条链的反向，而可以被用来记录你要的顺序，因此双向链表是有序的。
其实我也不知道我的猜想是否正确，我没有看过这两个类的实现代码，不过既然大家都这么说，那咱们这么记就行了，毕竟封装性么，少操一点心也没什么不好。
但我还是觉得奇怪，毕竟要实现一个有序单链也不怎么费劲。
㈨ java单向链表
java.util.Linkedlist是双向链表，当然也就包括了单链表的功能，你可以去看他怎么写的啊
public class SingleLinkedList<E> {
private Entry<E> first, last;
private int size = 0;
public void add(E element) {
Entry<E> newEntry = new Entry<E>(element, null);
if (first == null) {
first = last = newEntry;
} else {
last.next = newEntry;
last = newEntry;
}
++size;
}
public E get(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = first;
for (int i = 0; i < index; ++i)
e = e.next;
return e.data;
}
private static class Entry<E> {
Entry(E data, Entry<E> next) {
this.data = data;
this.next = next;
}
E data;
Entry<E> next;
}
}