Ⅰ 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;
}