數據結構與算法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教程