大话数据结构用Java实现3-02

单链表

**单链表的存储分配方式：**单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素。
**单链表的时间性能：**单链表的插入和删除时间仅为O（1）。
**单链表的空间性能：**单链表不需要预分配存储空间，只要有就可以分配，元素个数也不受限制。

以下代码给出单链表的相关操作：

1、头插法和尾插法
2、遍历链表
3、获取链表的长度
4、在指定位置插入、删除元素
5、清空链表
6、判断链表是否为空
7、查找指定位置的元素值

package cn.hdu.table;

public class test {
    public static void main(String[] args) {
        LinkList linkList = new LinkList();
        linkList.creatListHead(linkList, 5);
        System.out.println("头插法--------------");
        linkList.traverse(linkList);
        System.out.println("");

        System.out.println("尾插法--------------");
        LinkList linkList2 = new LinkList();
        linkList2.creatListTail(linkList2, 5);
        linkList2.traverse(linkList2);
        System.out.println("");

        System.out.println("链表2长度：--------------");
        System.out.println(linkList2.getLengthList(linkList2));

        System.out.println("在链表2的3位置上插入100：--------------");
        linkList2.insertList(linkList2, 3, 100);
        linkList2.traverse(linkList2);
        System.out.println("");

        System.out.println("删除链表1号元素：--------------");
        linkList.deleteListElem(linkList, 1);
        linkList.traverse(linkList);
        System.out.println("");

        System.out.println("判断链表2是否为空：--------------");
        System.out.println(linkList2.elemptyList(linkList2));

        System.out.println("清空链表2：--------------");
        linkList2.clearList(linkList2);

        System.out.println("清空后的链表2：--------------");
        linkList2.traverse(linkList2);


        System.out.println("判断链表2是否为空：--------------");
        System.out.println(linkList2.elemptyList(linkList2));

        System.out.println("查找链表1的3位置的值：--------------");
        System.out.println(linkList.getElem(linkList, 2));

    }


    static class LinkList {
        int data;
        LinkList next;

        public void initLink(LinkList L) {
            L = new LinkList();
            L.next = null;
        }


        /*
        链表的创建（头插法），n表示插入的元素个数
         */
        public void creatListHead(LinkList L, int n) {
            initLink(L);//初始化一个空链表
            for (int i = 0; i < n; i++) {
                LinkList linkList = new LinkList();//new一个新的链表
                linkList.data = i;  //给数据域赋值
                linkList.next = L.next;
                L.next = linkList;   //插入到表头

            }

        }
        /*
        链表的创建（尾插法），n表示插入的元素个数
         */

        public void creatListTail(LinkList L, int n) {
            initLink(L);//初始化一个空链表
            LinkList P; //指向尾节点的变量
            P = L;
            for (int i = 0; i < n; i++) {
                LinkList linkList = new LinkList();//new一个新的链表
                linkList.data = i;  //给数据域赋值
                linkList.next = L.next;
                P.next = linkList;   //插入到表尾
                P = linkList;

            }
            P.next = null;

        }

        /*
        遍历链表
         */
        public void traverse(LinkList L) {
            LinkList linkList;   //定义一个结点变量
            linkList = L.next;    让P指向链表的第一个节点
            while (linkList != null) {    //判断条件
                System.out.print(linkList.data + " ");
                linkList = linkList.next;  //将P移动到上一位节点
            }
        }

        /*
            获取链表的长度
             */
        public int getLengthList(LinkList L) {
            int count = 0;
            LinkList P;  //定义一个结点变量
            P = L.next;   //让P指向链表的第一个节点
            while (P != null) {
                P = P.next;   将P移动到上一位节点
                count++;
            }
            return count;
        }
        /*
        链表的插入，n表示插入的位置
         */

        public void insertList(LinkList L, int i, int num) {
            LinkList P;   //定义一个节点变量P
            int count = 1;
            P = L;  //使P指向链表的头节点
            while (P.next != null && count < i) {
                P = P.next;  //将P节点下移一位
                ++count;
            }
            if (P == null || count > i) {
                System.out.println("找不到要插入的位置");
            }
            //若找不到插入的位置，则在最后一位插入元素
            LinkList linkList = new LinkList();
            linkList.data = num;
            linkList.next = P.next;  //将P的后继节点赋给linkList的后继
            P.next = linkList;   //将linkList赋给P的后继

        }
        /*
        链表的删除，n表示删除的位置
         */
        public void deleteListElem(LinkList L, int n) {
            LinkList P;
            int count = 1;
            P = L;
            while(P.next != null && count < n){
                P = P.next;
                ++count;
            }
            if(P == null || count >n){
                System.out.println("第i个节点不存在！");
            }else{
                System.out.println("查找成功并删除！");
                P.next = P.next.next;
            }


        }
            /*
               判断链表是否为空
                */
        public boolean elemptyList(LinkList L) {
            if(L.next != null){
                return false;
            }
            return true;

        }
            /*
               链表的清空
                */
        public void clearList(LinkList L) {
            LinkList P,Q;
            P = L.next;
            if(P != null){
                Q = P.next;  //调换
                P = null;    //清空
                P = Q;       //重新给P赋P.next的值，相当于将P移动到下一位
            }
            L.next = null;
        }

        /*
        查找链表某个位置的值,前提条件：这个数存在 查找特定的元素 ,
        查找第四个位置的值，并返回
     */
        public int getElem(LinkList L, int i) {
            LinkList P;
            int count = 1;
            P = L.next;
            while(P !=null){
                if(count == i){
                    return P.data;
            }else{
                    ++count;
                    P = P.next;
                }

            }
            return 0;

        }

    }
}

运行结果：

头插法--------------
4 3 2 1 0 
尾插法--------------
0 1 2 3 4 
链表2长度：--------------
5
在链表2的3位置上插入100：--------------
0 1 100 2 3 4 
删除链表1号元素：--------------
查找成功并删除！
3 2 1 0 
判断链表2是否为空：--------------
false
清空链表2：--------------
清空后的链表2：--------------
判断链表2是否为空：--------------
true
查找链表1的3位置的值：--------------
2
合并链表1和链表2：--------------