数据结构(java版)学习笔记(三)——线性表之单链表

单链表的优点:

  1. 长度不固定,可以任意增删。

单链表的缺点:

  1. 存储密度小,因为每个数据元素,都需要额外存储一个指向下一元素的指针(双链表则需要两个指针)。

  2. 要访问特定元素,只能从链表头开始,遍历到该元素,时间复杂度为 $O(n)$。在特定的数据元素之后插入或删除元素,不涉及到其他元素的移动,因此时间复杂度为 $O(1)$。双链表还允许在特定的数据元素之前插入或删除元素。

  3. 存储空间不连续,数据元素之间使用指针相连,每个数据元素只能访问周围的一个元素(根据单链表还是双链表有所不同)。

单链表基本运算:

 

1.插入算法(核心)

插入算法是单链表的核心算法,掌握了这个,后面的头插法,尾插法都是so easy

下图就是显示了如何将p结点插入到q的后面

2.删除算法

删除算法其实很简单

下图是删除某个结点的后继的图示

 

3.建立单链表的两种方法

头插法和尾插法

使用头插法创建出的单链表是逆序的, 使用尾插法创建出的单链表则是顺序的,一般都是采用此尾插法来建立单链表

头插法简单来说,就是每次插入的结点都是在头结点的后继

尾插法则是每次插入的结点都是在链表的末尾结点的后继

4.查找算法

查找算法的关键在于结束条件

下列代码中的t!=null则是结束的条件

 

     Lnode t = h.next;
        while(t!=null){
            if(t.data==x){
                System.out.println("找到");
                return t;
            }
            t = t.next;
        }
        return null;

 

 

 

 

单链表的实现:

import java.util.Scanner;


public class LinkedList  implements ListIntf{
    Lnode h =null;
    public static String toucha = "头插法";
    public static String weicha = "尾插法";
    
    public LinkedList(String s){
        //如果参数是头插法则使用头插法创建单链表,不是则使用尾插法
        if(s.equals(toucha)){
            h=new Lnode();
            h.data = 'f';
            h.next = null;
            Lnode p;
            Scanner scanner = new Scanner(System.in);
            String str = scanner.nextLine();
            for(int i=0;i<str.length();i++){
                
                p = new Lnode();
                p.data = str.charAt(i);
                
                p.next = h.next;
                h.next = p;
            }
            scanner.close();
        }else{
            h=new Lnode();
            h.data = 'f';
            h.next = null;
            
            Lnode p,t;
            t=h; //t用来代替头结点,同时,也就是
            Scanner scanner = new Scanner(System.in);
            String str = scanner.nextLine();
            for(int i=0;i<str.length();i++){
                
                p = new Lnode();
                p.data = str.charAt(i); //接收String中的char
                
                p.next = t.next;//此条语句与p.next =null 等同
                t.next = p;
                t = p; // t结点一直指向链表的末尾
                
                
            }
            scanner.close();
        }
    }
    public void display(){
        Lnode p = h.next;
        while(p!=null){
            System.out.println(p.data);
            p = p.next;
        }
        
    }
    /**
     * 设置头结点
     * @param _h
     */
    public void setH(Lnode _h){
        h=_h;
    }
    /**
     * 
     * @param p 结点
     * @param x 某个结点的值为x
     * 将值为x的结点插入到p结点的后面
     */
    public void insertElementAfter(Lnode p,char x){
        Lnode t = new Lnode(x);
        t.next = p.next; //这里容易忘记
        p.next=t;                            
    }
    /**
     * 
     * @param x 
     * @return 查找到值为x的结点
     */
    public Lnode search(char x){
        Lnode t = h.next;
        while(t!=null){
            if(t.data==x){
                System.out.println("找到");
                return t;
            }
            t = t.next;
        }
        return null;
    }
    @Override
    public int size() {
        int i =0;
        Lnode t = h.next;
        while(t!=null){
            i++;
            t = t.next; 
        }
        return i;
    }

    @Override
    public void clear() {
        h.next = null;
        
    }

    @Override
    public boolean isEmpty() {
        if(h.next==null){
            return false;
        }else{
            return true;
        }
    }
    /**
     * 
     * @param i 需要找到的第i个结点
     * @return 第i个结点
     */
    public Lnode getLnode(int i){
        Lnode t = h; //从头结点算起,j就是从0开始
        int j =0;
        while(j<i){
            t = t.next;
            j++;
        }
        if(t==null){
            return null;
        }else{
            return t;    
        }
    }
    
    @Override
    public String get(int i) {
        //取得第i个结点的值
        Lnode t = h; //从头结点算起,j就是从0开始
        int j =0;
        while(j<i){
            t = t.next;
            j++;
        }
        //或者从第一个结点开始
        /*Lnode t = h.next; 
        int j =1;
        while(j<i){
            t = t.next;
            j++;
        }*/
        //这里需要加一个溢出处理
        if(t==null){
            return null;
        }else{
            return String.valueOf(t.data);    
        }
        
    }

    @Override
    public int indexOf(String s) {
        //单链表不需要复写此方法
        return 0;
    }

    @Override
    public String getPre(String s) {
        //单链表不需要复写此方法
        return null;
    }

    @Override
    public String getNext(String s) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void insertElementAt(String s, int i) {
        // TODO Auto-generated method stub
        
    }

    @Override
    public String remove(int i) {
        //先找到第i个结点,之后再将其移出,斌返回其的数值
        Lnode t = getLnode(i);
        Lnode q = getLnode(i-1); //q为t的前趋
        q.next = t.next;
    
        return String.valueOf(t.data);
    }

    @Override
    public String remove(String s) {
        // TODO Auto-generated method stub
        return null;
    }
    

}

 补充一下:

在Java实现字符窗口的输入时,很多人更喜欢选择使用扫描器Scanner,它操作起来比较简单。在编程的过程中,我发现用Scanner实现字符串的输入有两种方法,一种是next(),另一种是nextLine(),这两种有以下区别:

    next()一定要读取到有效字符后才可以结束输入,对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符,next()方法会自动将其去掉,只有在输入有效字符之后,next()方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。

     简单地说,next()查找并返回来自此扫描器的下一个完整标记。完整标记的前后是与分隔模式匹配的输入信息,所以next方法不能得到带空格的字符串。

    nextLine()方法的结束符只是Enter键,即nextLine()方法返回的是Enter键之前的所有字符,它是可以得到带空格的字符串的。

posted @ 2018-08-05 14:04  Stars-one  阅读(681)  评论(0编辑  收藏