链表与数组之间的相互转换

数组是一种连续的数据结构，而链表是一种离散的数据结构，链表与数组如何转换呢？

1、数组转换成链表：

root=new LinkNode(s[0]);//生成链表的根节点，并将数组的第一个元素的值赋给链表的根节点
LinkNode other=root;//生成另一个节点，并让other指向root节点，other在此作为一个临时变量，other和root指向同一地址 
                   for(int i=1;i<s.length;i++){//由于已给root赋值，所以i从1开始
                            LinkNode temp=new LinkNode(s[i]);//每循环一次生成一个新的节点,并给当前节点赋值
                            other.setNext(temp);//将other的下一个节点指向生成的新的节点
                            other = temp;//将other指向最后一个节点(other的下一个节点)     
                   }

链表与数组之间的相互转换

具体代码实现如下：

/**
 * 将数组转换成链表输出
 * @author zr
 *
 */
public class Test2 {
	private static LinkNode root;
	

	/**
	 * 程序入口处
	 * @param args
	 */
	public static void main(String[] args) {
		Test2 t2=new Test2();
		String [] s=new String[]{"a1","a2","a3","a4"};
		root=t2.LinkList(s);
		t2.printLinkList(root);
	}
	
	/**
	 * 创建一个链表
	 * @param s 一个字符串
	 * @return 返回链表根节点
	 */
	public LinkNode LinkList(String [] s){
		root=new LinkNode(s[0]);//生成链表的根节点，并将数组的第一个元素的值赋给链表的根节点
		LinkNode other=root;//生成另一个节点，并让other指向root节点，other在此作为一个临时变量，相当于指针
		for(int i=1;i<s.length;i++){//由于已给root赋值，所以i从1开始
			LinkNode temp=new LinkNode(s[i]);//每循环一次生成一个新的节点,并给当前节点赋值
			other.setNext(temp);//将other的下一个节点指向生成的新的节点
			other = temp;//将other指向最后一个节点(other的下一个节点)	other=other.getNext();
			
		}
		return root;
	}
	
	/**
	 * 遍历一个链表
	 * @param root
	 */
	public void printLinkList(LinkNode root){
		if(root!=null){
			Object data=root.getObj();//获得根节点的值
			String s=(String)data;//将data强制转型为String类型
			System.out.println(s);
			LinkNode temp2=root.getNext();//将根节点的下一个节点赋给temp2
			printLinkList(temp2);//递归
		}
	}

}

结果为：

a1
a2
a3
a4

2、链表转换成数组：

int size=LinkListSize(lr);//获得链表的长度

Object [] obj=new Object[size];

obj[0]=lr.getObj();//将根节点的值赋给数组的第一个元素

LinkNode tem=lr;

for(int i=1;i<size;i++){

        LinkNode tem1=tem.getNext();

        obj[i]=tem1.getObj();

        tem=tem1;

}

链表与数组之间的相互转换

具体代码实现如下：

/**
 * 把链表转换成数组
 * @author zr
 *
 */
public class Test3 {
	private int size=1;
	private int count;
	private static LinkNode root;
	static Test3 t3=new Test3();
	
	public static void main(String [] args){
		root=t3.createLinkList();//取得创建好的链表
		System.out.println("需要转换的链表为：");
		t3.printLinkList(root);//打印出链表
		t3.LinkList_Array(root);
	}

	/**
	 * 将一个链表转换成数组
	 * @param root 链表的根节点
	 */
	public void LinkList_Array(LinkNode lr){

		int size=LinkListSize(lr);//获得链表的长度
		Object [] obj=new Object[size];
		obj[0]=lr.getObj();//将根节点的值赋给数组的第一个元素
		LinkNode tem=lr;
		for(int i=1;i<size;i++){
			
			LinkNode tem1=tem.getNext();
			obj[i]=tem1.getObj();
			tem=tem1;
		}	
		System.out.println("该链表转换成数组为：");
		printArray(obj);
	}
	
	/**
	 * 遍历数组
	 * @param obj 被遍历的数组
	 */
	public void printArray(Object[] obj){
		for(int i=0;i<obj.length;i++){
			System.out.println(i+" "+obj[i]);
		}
	}
	
	/**
	 * 创建一个链表
	 * @return 返回链表根节点
	 */
	public LinkNode createLinkList(){
		root=new LinkNode("根节点");
		LinkNode n1=new LinkNode("节点1");
		LinkNode n2=new LinkNode("节点2");
		LinkNode n3=new LinkNode("节点3");
		LinkNode n4=new LinkNode("节点4");
		root.setNext(n1);
		n1.setNext(n2);
		n2.setNext(n3);
		n3.setNext(n4);
		return root;
		
	}
	
	/**
	 * 遍历链表
	 * @param root 链表的根节点
	 */
	public void printLinkList(LinkNode root){
		if(root!=null){
			count++;
			Object obj=root.getObj();
			System.out.println(count+"  "+obj);
			LinkNode temp=root.getNext();
			printLinkList(temp);
		}
	}
	
	public int LinkListSize(LinkNode root){
		LinkNode tem=root;//tem1指向root节点
		
		while(tem.getNext()!=null){
			size++;
			LinkNode tem1=tem.getNext();//tem1指向tem的下一个节点
			tem=tem1;//将tem指向tem1
		}
		return size;
		
	}
	
	
}

结果为：

需要转换的链表为：
1 根节点
2 节点1
3 节点2
4 节点3
5 节点4
该链表转换成数组为：
0 根节点
1 节点1
2 节点2
3 节点3
4 节点4

链表与数组之间的相互转换

相关推荐