Ⅰ java实现单链表的反转 java实现两个无序单链表合并成一个有序的单链表谁能给个效率较高的代码，谢谢！
单链表的反转，参考下吧
static Node reverse(Node x) {
Note t, y = x, r = null;
while(y != null) {
t = y.next; y.next = r; r = y; y = t;
}
return r;
}
Ⅱ java中如何创建一个链表望能给我详细的代码。加点注释。谢谢
//如果感兴趣的话，可以把下面的改成泛型的也就是这样的
//一个学生的类
public class Stu(){
String name;
int age;
public Stu(String name,int age){
this.name=name;
this.age=age;
}
}
//创建两个学生的对像
Stu stu1=new Stu("weiwie",24);
Stu stu2=new Stu("xiaoqiang",25);
//创建集合类,存放的是Stu对像,这样的声明只能存Stu对像
List <Stu> list=new ArrayList<Stu>();
//存数据
list.add(stu1);
list.add(stu2);
//遍历
for(int i=0;i<list.size();i++){
//向下转型方便了,取出来的就是Stu对像
Stu stu=list.get(i);
}
List list=new ArrayList();
list.add("对像");
遍历
for(int i=0;i<list.size();i++){
//需要强转
String str=(String)list.get(i);
得到你存放的数据
}
Map map=new HashMap();
//存值
map.put("one","对像");
//取值
String str=(String)map.get("one");
Set set=new HashSet();
//存值
set.add("对像");
//需要用这个对像遍历
Iterator iter=set.iterator();
while(iter.hasNext()){
//取值
String Str=(String)iter.next();
}
Ⅲ java 链表的输出问题
几位的回答都比较清楚了，我想另外说点问题
你本就不应该加入‘表尾’这个属性，在数据结构中链表的特点就是能用一个地址带一个长串数据链的，不用这个属性的话思路会更加清晰。我也用java模拟过一些基本数据结构：
public class MyNode<T> {
public T value;
public MyNode<T> next;
public MyNode() {
}
public MyNode(T value) {
this.value = value;
}
public MyNode(MyNode<T> t) {
this.value = t.value;
this.next = t.next;
}
public void connect(MyNode<T> t){
this.next = t;
}
@Override
public String toString() {
return null==value?"":value+"->";
}
}
在这个节点定义的基础上的链表定义：
public class MyLinkList<T>{
public MyNode<T> next;
public MyLinkList() {
this.next = new MyNode<T>();
}
public MyLinkList(T[] tList) {
if(tList.length==0)return;
next = new MyNode<T>(tList[0]);
MyNode<T> temp = next;
for (int i = 1; i < tList.length; i++) {
temp.connect(new MyNode<T>(tList[i]));
temp = temp.next;
}
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
MyNode<T> t = next;
while (null != t) {
sb.append(t);
t = t.next;
}
return sb.toString();
}
}
然后是相关的操作类：
public class LinkListAction {
MyLinkList<Comparable> list;
public LinkListAction(MyLinkList<Comparable> list) {
this.list = list;
}
/**
* 头插法建立单链表(数组)
* */
public void createFromHead(Comparable...objects){
MyNode<Comparable> start;
for (int i = 0; i < objects.length; i++) {
start = new MyNode<Comparable>(objects[i]);
start.next = list.next;
list.next = start;
}
}
/**
* 尾插法建立单链表(数组)
* */
public void createFromTail(Comparable...objects){
MyNode<Comparable> start;
MyNode<Comparable> end = list.next;
for (int i = 0; i < objects.length; i++) {
start = new MyNode<Comparable>(objects[i]);
end.next = start;
end = start;
}
end.next = null;
}
/**
* 在单链表中查找第i个结点
* */
public MyNode<Comparable> get(int i){
if(i < 0)return null;
MyNode<Comparable> node = list.next;
int index = 0;
while (node != null && index < i) {
node = node.next;
index++;
}
return node;
}
/**
* 在单链表中的按值查找
* */
public MyNode<Comparable> locate(Comparable obj){
if(null == obj)return new MyNode<Comparable>();
MyNode<Comparable> node = list.next;
while (node != null && !obj.equals(node.value)) {
node = node.next;
}
return node;
}
/**
* 求单链表的长度
* */
public int getLength(){
int length = 0;
MyNode<Comparable> node = list.next;
while(null != (node = node.next)){
length++;
}
return length;
}
/**
* 单链表的插入操作(按位置)
* */
public void insert(Comparable obj,int location){
int length = 0;
MyNode<Comparable> node = list.next;
while(node!=null && location != length++){node = node.next;}
if(null == node)throw new RuntimeException("插入位置有误！");
MyNode<Comparable> inserter = new MyNode<Comparable>(obj);
inserter.next = node.next;
node.next = inserter;
}
/**
* 删除数据
* */
public Comparable delete(int i){
int length = 0;
MyNode<Comparable> 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 MyLinkList<Comparable> mergeLinkList(MyLinkList<Comparable> la,MyLinkList<Comparable> lb){
MyLinkList<Comparable> lc = new MyLinkList<Comparable>();
MyNode<Comparable> pc = lc.next;
MyNode<Comparable> pa = la.next.next;
MyNode<Comparable> 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) {
MyLinkList<Comparable> list1 = new MyLinkList<Comparable>();
MyLinkList<Comparable> list2 = new MyLinkList<Comparable>();
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作业不会做呀 大神救救我呀 题目：从键盘或者TXT文本中输入一组任意数据，建立一带头结点的有序链表
不好意思，可能我比较愚钝，没有明白你的意思。
Ⅳ JAVA中链表有什么用
java中的List接口 中有两个实现类：ArrayList和LinkedList。前者是使用数组实现，用索引来取数据是它的优势。后者是用双向链表实现，在插入和删除操作上占优势。具体实现已经封装好了，不用操心过多，具体动作都有具体的方法。
Ⅵ 如何用java设计一个有序单链表类
class SortedLink{
public Node head;
public int add(Node assigned , Node input){
Node temp=head;
while(temp.next!=null){
if(temp==assigned) {
Node t=assigned.next;
assigned.next=input;
input.next=t;
return 1;
}
temp=temp.next;
}
return 0;
}
public int remove(Node assigned){
Node temp1=head;
Node temp2=head.next;
while(temp2.next!=null){
if(temp2==assigned) {
temp1.next=temp2.next;
temp2.dispose();
return 1;
}
temp1=temp2;
temp2=temp2.next;
}
return 0;
}
}
Node是一个类，就自己实现吧……
Ⅶ 实现两个链表的合并，使用java语言编写一程序，将A表和B表归并成一个新的递增有序的单链表C，值
importjava.util.Collections;
importjava.util.LinkedList;
importjava.util.List;
publicclassTestMouse1{
publicstaticvoidmain(String[]agse){
List<Integer>list1=newLinkedList<Integer>();
Collections.addAll(list1,30,41,15,12,56,80);
List<Integer>list2=newLinkedList<Integer>();
Collections.addAll(list2,23,56,78,23,12,33,79,90,55);
test1(list1,list2);
}
publicstaticvoidtest1(List<Integer>list1,List<Integer>list2){
list1.removeAll(list2);//list1中删除和list2中交集的元素
list2.addAll(list1);//合并
Collections.sort(list2);
for(Integerinteger:list2){
System.out.print(integer+"");
}
}
}
请采纳
Ⅷ 用java实现一个基于有序链表的优先级队列。队列的删除操作应该删除最小关键字的链结点
class NodeLink
{
int key ;
char * next;
}
指针后移 找key的最小值 即可 找到删除
Ⅸ java 创建方法合并两个有序链表成一个新的有序链表 代码
public static SortedList mergeList(SortedList list1, SortedList list2){
Link current = list2.first;
while(current != null){
list1.insert(current.dData);
current = current.next;
}
return list1;
}