数据结构与算法16-链表-查找和删除指定链结点-双端链表-有序链表

时间  2019-11-11
标签 数据 结构 算法 链表 查找 删除 指定 链结 双端 有序 栏目 应用数学 繁體版
原文   原文链接

为单链表设置查找和删除两个功能，其中值得注意的是删除花了很长时间去理解，因此将此部分的本身理解的注释写出，方便往后的复习。java

public Link delete(int key){
        Link current=first;//当前指针从first开始
        Link previous=first;//当前指针前一指针也从first开始
        while(current.iData!=key)//判断当前的链结点中的数据是不是关键字
            {
                    if(current.next==null)//若是当前链结点的下一结点为null
                        return null;//返回null
                    else
                    {
                        previous=current;//将当前链结点赋值给当前链结点的前一结点
                        current=current.next;//以前的当前链结点指向下一个结点
                    }
            }
            if(current==first)//若是当前链结点和first结点相同
                first=first.next;//first结点指向first结点指向结点的下一个结点
            else
                previous.next=current.next;//不然将当前结点指向当前结点的下一结点，也就是删除当前结点。
            return current;
        }

完整代码： 数组

class LinkListApp {

    /**
     * @param args
     */
    public static void main(String[] args) {

        LinkList thelist=new LinkList();
            thelist.insertFirst(22, 2.99);
            thelist.insertFirst(44, 4.99);
            thelist.insertFirst(66, 6.99);
            thelist.insertFirst(88, 8.99);
            thelist.displayList();

            Link f=thelist.find(44);
            if(f!=null)
                System.out.println("找到了关键值"+f.iData);
            else
                System.out.println("没有找到该值");

            Link d=thelist.delete(66);
            if(d!=null)
                System.out.println("已经删除该值"+d.iData);
            else
                System.out.println("没有删除");
            thelist.displayList();

    }

}
///////////////////////////////////////////////////////////////////////////////////////////
class Link{
    public int iData;
    public double dData;
    public Link next;

    public long LData;
//----------------------------------------------------------------------------------------
    public Link(int id,double d){
        this.iData=id;
        this.dData=d;
    }

    public Link(long d){
        LData=d;
    }
//----------------------------------------------------------------------------------------
    public void displayLink(){
        System.out.println("{"+this.iData+" "+this.dData+"}");
    }

    public void displayLongLink(){
        System.out.print(LData+" ");
    }
}
///////////////////////////////////////////////////////////////////////////////////////
    class LinkList{
        public Link first;
//------------------------------------------------------------------------------------------
    public LinkList(){
            first=null;
        }
//----------------------------------------------------------------------------------------
    public void insertFirst(int id,double dd){
        Link newLink=new Link(id,dd);
        newLink.next=first;
        first=newLink;
    }
//---------------------------------------------------------------------------------------
    public Link find(int key){
        Link current=first;
        while(current.iData!=key){
            if(current.next==null)
                return null;
            else
                current=current.next;
        }
        return current;
    }
//---------------------------------------------------------------------------------------
    public Link delete(int key){
        Link current=first;
        Link previous=first;
        while(current.iData!=key)
            {
                    if(current.next==null)
                        return null;
                    else
                    {
                        previous=current;
                        current=current.next;
                    }
            }
            if(current==first)
                first=first.next;
            else
                previous.next=current.next;
            return current;
        }
//----------------------------------------------------------------------------------------
    public void displayList(){
        System.out.println("List (first--->last): ");
        Link current=first;
        while(current!=null){
            current.displayLink();
            current=current.next;
        }
        System.out.println(" ");
    }
//----------------------------------------------------------------------------------------
}
List (first--->last): 
{88 8.99}
{66 6.99}
{44 4.99}
{22 2.99}
 
找到了关键值44
已经删除该值66
List (first--->last): 
{88 8.99}
{44 4.99}
{22 2.99}

双端链表 数据结构

有first和lastthis

first指向第一个链结点spa

last指向最后一个链结点指针

在双端链表中能够从first插入链结点，也能够从last插入链结点code

class Link
{
	public long dData;
	public Link next;
	public Link(long d)
	{
		dData = d;
	}
	public void displayLink()
	{
		System.out.println(dData + " ");
	}
}
class firstLastList {
	private Link first;
	private Link last;
	public firstLastList()
	{
		first = null;
		last = null;
	}
	public boolean isEmpty()
	{
		return first == null;
	}
	//从first插入
	public void insertFirst(long dd)
	{
		Link newLink = new Link(dd);
		if(isEmpty())				//若是链表为空
		last = newLink;				//last指向新插入的链结点
		newLink.next = first;		//新插入节点指向first
		first = newLink;			//first指向新插入链结点

	}
	public void insertLast(long dd)
	{
		Link newLink = new Link(dd);		
		if(isEmpty())				//若是链表为空
			first = newLink;		//first指向新插入链结点
		else
			last.next = newLink;	//原来最后的链结点指向新插入的链结点
		 	last = newLink;			//last指向新插入的链结点
	}
	public long deleteFirst()
	{
		long temp = first.dData;	//将first的数据存入变量temp中
		if(first.next == null)		//若是只有两个结点
			last = null;			//last指向null
		first = first.next;			//first指针指向要删除链结点的后一结点
		return temp;
	}
	public void displayList()
	{
		System.out.println("list ");
		Link current = first;
		while(current != null)
		{
			current.displayLink();
			current = current.next;
		}
		System.out.println(" ");
	}
}
class firstLastApp{
	public static void main(String[] args)
	{
		firstLastList thelist = new firstLastList();
		thelist.insertFirst(22);
		thelist.insertFirst(44);
		thelist.insertFirst(66);
		thelist.insertLast(11);
		thelist.insertLast(33);
		thelist.insertLast(55);
		thelist.displayList();
		thelist.deleteFirst();
		thelist.deleteFirst();
		thelist.displayList();
	}
}
list 
66 
44 
22 
11 
33 
55 
 
list 
22 
11 
33 
55

链表的效率：队列

在表头插入和删除的速度很快，仅须要改变一两个引用值，因此花费O（1）内存

查找，删除和在指定链结点后面插入都须要搜索链表中的一半链结点。须要O（N）次比较。rem

链表比数组优越的另外一个重要方面是链表须要多少内存就能够用多少内存，而且能够拓展到全部可用内存。

ADT(抽象数据类型）：是考虑数据结构的一种方式，着重于它作了什么，而忽略它是怎么作的。

链表实现栈

import java.util.LinkedList;

class Link
{
	public long dData;
	public Link next;
	public Link(long d)
	{
		dData = d;
	}
	public void displayLink()
	{
		System.out.println(dData + " ");
	}
}
class LinkList {
	private Link first;
	
	public LinkList()
	{
		first = null;
	}
	public boolean isEmpty()
	{
		return first == null;
	}
	//从first插入
	public void insertFirst(long dd)
	{
		Link newLink = new Link(dd);		
		newLink.next = first;		
		first = newLink;			
	}
	/*public void insertLast(long dd)
	{
		Link newLink = new Link(dd);		
		if(isEmpty())				//若是链表为空
			first = newLink;		//first指向新插入链结点
		else
			last.next = newLink;	//原来最后的链结点指向新插入的链结点
		 	last = newLink;			//last指向新插入的链结点
	}*/
	public long deleteFirst()
	{
		Link temp = first;	//将first的数据存入变量temp中
			first = first.next;//first指针指向要删除链结点的后一结点
		return temp.dData;
	}
	public void displayList()
	{
		//System.out.println("list ");
		Link current = first;
		while(current != null)
		{
			current.displayLink();
			current = current.next;
		}
		System.out.println(" ");
	}
}
class LinkStack
{
	private LinkList theList;
	public LinkStack()
	{
		theList = new LinkList();
	}
	public void push(long j)
	{
		theList.insertFirst(j);
	}
	public long pop()
	{
		return theList.deleteFirst();
	}
	public boolean isEmpty()
	{
		return (theList.isEmpty());
	}
	public void dispayStack()
	{
		System.out.println("stack: ");
		theList.displayList();
	}
}
/*class firstLastApp{
	public static void main(String[] args)
	{
		firstLastList thelist = new firstLastList();
		thelist.insertFirst(22);
		thelist.insertFirst(44);
		thelist.insertFirst(66);
		thelist.insertLast(11);
		thelist.insertLast(33);
		thelist.insertLast(55);
		thelist.displayList();
		thelist.deleteFirst();
		thelist.deleteFirst();
		thelist.displayList();
	}
}*/
class LinkStackApp{
	public static void main(String[] args)
	{
		LinkStack theStack = new LinkStack();
		theStack.push(20);
		theStack.push(40);
		theStack.dispayStack();
		theStack.push(60);
		theStack.push(80);
		theStack.dispayStack();
		theStack.pop();
		theStack.pop();
		theStack.dispayStack();
	}
}
stack: 
40 
20 
 
stack: 
80 
60 
40 
20 
 
stack: 
40 
20

用双端链表实现队列 

class Link
{
	public long dData;
	public Link next;
	public Link(long d)
	{
		dData = d;
	}
	public void displayLink()
	{
		System.out.println(dData + " ");
	}
}
class firstLastList {
	private Link first;
	private Link last;
	public firstLastList()
	{
		first = null;
		last = null;
	}
	public boolean isEmpty()
	{
		return first == null;
	}
	//从first插入
	public void insertFirst(long dd)
	{
		Link newLink = new Link(dd);
		if(isEmpty())				//若是链表为空
		last = newLink;				//last指向新插入的链结点
		newLink.next = first;		//新插入节点指向first
		first = newLink;			//first指向新插入链结点

	}
	public void insertLast(long dd)
	{
		Link newLink = new Link(dd);		
		if(isEmpty())				//若是链表为空
			first = newLink;		//first指向新插入链结点
		else
			last.next = newLink;	//原来最后的链结点指向新插入的链结点
		 	last = newLink;			//last指向新插入的链结点
	}
	public long deleteFirst()
	{
		long temp = first.dData;	//将first的数据存入变量temp中
		if(first.next == null)		//若是只有两个结点
			last = null;			//last指向null
		first = first.next;			//first指针指向要删除链结点的后一jie'd
		return temp;
	}
	public void displayList()
	{
		System.out.println("list ");
		Link current = first;
		while(current != null)
		{
			current.displayLink();
			current = current.next;
		}
		System.out.println(" ");
	}
}
class LinkQueue
{
	private firstLastList theList;
	public LinkQueue()
	{
		theList = new firstLastList();
	}
	public boolean isEmpty()
	{
		return theList.isEmpty();
	}
	public void insert(long j)
	{
		theList.insertLast(j);
	}
	public long remove()
	{
		return theList.deleteFirst();
	}
	public void displayQueue()
	{
		System.out.println("que");
		theList.displayList();
	}
	
}
class LinkQueueApp
{
	public static void main(String[] args)
	{
		LinkQueue theQueue = new LinkQueue();
		theQueue.insert(20);
		theQueue.insert(40);
		theQueue.displayQueue();
		theQueue.insert(60);
		theQueue.insert(80);
		theQueue.displayQueue();
		theQueue.remove();
		theQueue.remove();
		theQueue.displayQueue();
	}
}

有序链表

将插入的数据遍历比较已存在链结点的数据，并插入在一个合适的地方，使其成为一个有序链表。 

class Link
{
	public long  ddata;
	public Link next;
	public Link(long dd)
	{
		ddata = dd;
	}
	public void displayLink()
	{
		System.out.println(ddata + " ");
		
	}
}
class SortedList
{
	private Link first;
	public SortedList()
	{
		first = null;
	}
	public boolean Empty()
	{
		return (first == null);
	}
	public void insert(long key)
	{
		Link newLink = new Link(key);
		Link previous = null;
		Link current = first;
		while(current !=null&&key>current.ddata)
		{
			previous = current;
			current = current.next;
		}
		if(previous == null)
		
			first = newLink;
		else
			previous.next = newLink;
			newLink.next = current;
		
	}
	public Link remove()
	{
		Link temp = first;
		first = first.next;
		return temp;
	}
	public void displayList()
	{
		System.out.println("link");
		Link currrent = first;
		while(currrent != null)
		{
			currrent.displayLink();
			currrent = currrent.next;
		}
		System.out.println(" ");
	}
}
class SortedListApp
{
	public static void main(String[] args)
	{
		SortedList theSortedList = new SortedList();
		theSortedList.insert(6);
		theSortedList.insert(4);
		theSortedList.displayList();
		theSortedList.insert(1);
		theSortedList.insert(5);
		theSortedList.insert(9);
		theSortedList.displayList();
		theSortedList.remove();
		theSortedList.displayList();
	}
}
link
4 
6 
 
link
1 
4 
5 
6 
9 
 
link
4 
5 
6 
9
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程