JAVA链表实现与链表的逆序

1.链表

        链表有单链表还有双向链表,在java中每个节点都是一个类,这里声明了内部类,为了方便插入和删除,有时会在,链表的表头加上哨兵(形成有哨兵的循环或双向循环链表),这样的插入删除就不用考虑当插入删除的元素在边界的情况,方便,至于哨兵你可能觉得没什么用,其实他可以存储链表的许多信息,比如你每次查找一个元素,在无哨兵时,使用P!=null,使用哨兵,可以存储要查找的元素,退出时,就要判断是不是哨兵。

2.链表的实现与逆序

  若想代码写得快,必须清楚每次交换插入,产生的状态和性质。在写代码时,一个节点指错了下一个节点,导致调了好长时间,一定要想清楚每次变换的状态结果。下面使用了两种方法实现,链表的逆序,这两个思路都是插入排序的思想,只是迭代反向不同。

思路一:从第n-1个元素开始向前迭代,一次插入到链表结尾,在为双向链表并且含有尾节点时,时间复杂度为:n,在当链表为 n的平方。因为还要查找节点。

思路二:从第2-n个节点一次向后迭代,插入到head节点位置,一次向后就能每次使用next保存下一次要插入的元素,一路走来,不用查找节点。

同样的思路不同的方向,向前面插向后面插,双向思考

代码如下:

class List<T> {
	private static class Node<T>{
		private T key;
		Node<T> next;
		public Node(T key,Node<T> next)
		{
			this.key=key;
			this.next=next;
		}
	}
	private int size;
	private Node<T> head;
	public List(){
		size=0;
		head=null;
	}
	public int size()
	{
		return size;
	}
	public boolean isEmpty()
	{
		if(size==0)
			return true;
		else
			return false;
	}
	public void insert(T key)
	{
		head=new Node<T>(key,head);
		size++;
	}
	public T front()
	{
		return  head.key;
	}
	public T get(int index)
	{
		if(index>=size||index<0)
			return null;
		int i=0;
		Node<T>p=head;
		while(i++<index)
			p=p.next;
		return p.key;
	}
	public T delete(){
		T x=head.key;
		head = head.next;
		size--;
		return x;
	}
	public void delete(T key){
		Node<T>node=searchNode(key);
		if(node==null)
			return ;
		
		if(size==1)
			head=null;
		else
		{
		    Node<T>pre=head;
		    while(pre.next!=null&&pre.next!=node)
			pre=pre.next;
		    pre.next=node.next;
		}
		size--;
	}
	public Node<T> searchNode(T key)
	{
		Node<T> p= head;
		int i=0;
		while(p!=null&&p.key!=key)
			p=p.next;
		return p;
	}
	public int searchIndex(T x)
	{
		Node<T> p= head;
		int i=0;
		
		while(p!=null&&p.key!=x)
		{
			i++;
			p=p.next;
			
		}
		if(p!=null)
		return i;
		return -1;
	}
	public Node<T> getNode(int index)
	{
		if(index<0&&index>=size)
			return null;
		int i=0;
		Node<T>p=head;
		while(i++<index)
			p=p.next;
		return p;
	}
	/**
	 * 求链表的逆序  注意一定要链接节点时 连接对
	 * 思路一:这个比较麻烦:是把前面的元素从后向前一次放在链表结尾
	 * 还要查找元素节点,查找过程为n所以时间复杂度已经为 :n的平方 了
	 */
	public void reverse(){
		if(size<=1)
			return ;
		int i=size-2;
		Node<T>tail=getNode(size-1);
		while(i>=0)
		{
             Node<T>e=getNode(i);
             if(e!=head)
             {
            	 Node<T>pre=getNode(i-1);
                 tail.next=e;
                 pre.next=e.next;
                 tail=e;
                 tail.next=null;
             }
             else 
             {
            	 tail.next=head;
            	 tail=head;
            	 head=head.next;
            	 tail.next=null;
             }
             i--;
		}
	}
	
	/**
	 * 思路二: 从后面像最前面插入,插入排序的思想
	 */
	public void reverse2()
	{
		if(size<=1)
			return ;
		int i=1;
		Node<T>pre,insertNode,next;
		pre=head;
		next=head.next;//每个要插入元素的头结点都是最初的头结点
		while(i++<size)
		{
			insertNode=next;
			if(next.next!=null)
			next=next.next;
            pre.next=insertNode.next;  			
			insertNode.next=head;
			head=insertNode;
		}
		
	}
/* 思路三 :借助辅助空间,丛原链表拿出 重新构建  简单
 Node* reverse(Node* head)
{
    Node* current = head;
    Node* reversList = null;
     
    while(current)
    {
           /*将当前节点取出原链表迅速改变current(即current取出!!!注
                意这是 一个赋值操作,赋值完后current改变了,p还是没变!!!)*/
        Node *p = current;  
        current = current->next; 
 
        p->next = reversList;        
        reverseList = p;
    }
 
    return reverseList;
}*/
 /*使用java的值传递,是复制了一份引用的副本,不是原来的引用
	 * ,虽然指向相同,这样是不能把链表转换为逆序的
	 * public void swap(Node<T>head)
	
	{
		if(head.next!=null)
		{
			Node<T>p=head;
			swap(p.next);
			T key=head.key;
			while(p!=null)
				p=p.next;
			p.next=head;
			head=p.next;
		}
		
	}*/
}
public class SingleList {
    public static  void main(String args[])
    {
    	List<Integer> list=new List<Integer>();
    	list.insert(1);
    	list.insert(2);
    	list.insert(3);
    	list.insert(4);
    	list.insert(5);
    	list.reverse2();
    	System.out.println(list.get(0)+" "+list.get(1)+" "+list.get(2)+" "+list.get(3)+" "+list.get(4)+" ");
    }
}



阅读更多
想对作者说点什么? 我来说一句

java实现的单链表逆序显示

2008年10月30日 4KB 下载

没有更多推荐了,返回首页

不良信息举报

JAVA链表实现与链表的逆序

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭