数据结构--链表（java）

于 2015-11-16 19:16:06 发布
阅读量516 收藏
点赞数
分类专栏： 数据结构 文章标签： java 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/c601097836/article/details/49863439
版权

链表是这样一种数据结构，其中各个对象按现行顺序排列。
数组的线性顺序是由数组下标决定的，然而与数组不同的是，链表的顺序是由各个对象的指针决定的。

链表为动态集合提供了一种简单而灵活的表示方法。

但是在java里面没有指针概念，那么我们怎么来设计链表这种数据结构呢？？

首先我们用一个Node类来表示一个节点，整个链表是由多个Node对象链接起来的。

class Node {
    private int data;
    private Node next;

    public Node(int data) {
        this.data = data;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }


}

然后我们有一个LinkedList类管理这些节点。管理包括，插入节点，删除节点，搜索节点等等。

class SingleLink {
    private Node root;
    private int count;

    public void insert(int k) {

    }

    public void delete(int k){

    }
    public Node search(int k){

        return null;
    }

    public void sort(){

    }


    public void print() {

    }

    public int size() {
        return count;
    }

    public boolean isEmpty() {
        return count == 0;
    }

    public void clean() {
        this.root = null;
        this.count = 0;
    }

    public Node get(int index) {

     return null
    }
}

然后我们就可以在我们的 测试类或者需要使用链表的地方，新建一个链表，然后调用链表的操作，如下：

package com.zq.linkedlist;

/**
 * Created by zhengshouzi on 2015/10/1.
 */
public class LinkedTest {
    public static void main(String[] args) {

        SingleLink singleLink = new SingleLink();

        singleLink.insert(10);
        singleLink.insert(20);
        singleLink.insert(21);
        singleLink.insert(4);

        singleLink.print();

        System.out.println("----------------after sort -----------------");
        singleLink.sort();
        singleLink.print();

        singleLink.search(10);
        singleLink.delete(10);
        singleLink.print();
        singleLink.search(10);

        singleLink.min(singleLink.getRoot());

        System.out.println("size = " + singleLink.size());
        System.out.println("enpty = " + singleLink.isEmpty());


        System.out.println("------------------------------双向链表--------------------------------------");
        DoubleLink doubleLink = new DoubleLink();
        doubleLink.insert(30);
        doubleLink.insert(20);
        doubleLink.insert(21);
        doubleLink.insert(89);
        doubleLink.insert(8);

        doubleLink.print();

        System.out.println("----------------after sort -----------------");
        doubleLink.sort();
        doubleLink.print();

        doubleLink.search(10);
        doubleLink.delete(10);
        doubleLink.print();
        doubleLink.search(10);

        doubleLink.min(doubleLink.getRoot());

        System.out.println("size = " + doubleLink.size());
        System.out.println("enpty = " + doubleLink.isEmpty());
    }
}

//单向链表
class SingleLink {
    private Node root;
    private int count;

    public Node getRoot() {
        return root;
    }

    public void setRoot(Node root) {
        this.root = root;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public void insert(int data) {
        Node node = new Node(data);
        System.out.println("插入数据：" + data);
        if (root != null) {
            this.root.addNode(node);
        } else {
            this.root = node;
        }
        this.count++;
    }

    public void delete(int k) {
        //先查找到这个Node
        Node currentNode = root;
        Node lastNode = currentNode;
        while (currentNode != null && currentNode.getData() != k) {
            lastNode = currentNode;
            currentNode = currentNode.getNext();
        }

        if (currentNode == root) {
            //要删除的元素是第一个，或者链表为空
            if (currentNode == null) {
                System.out.println("链表为空");
            } else {
                //要删除的是第一个
                root = root.getNext();
                System.out.println("删除表头：" + k);
                count--;
            }
        } else {
            //断开连接
            System.out.println("删除：" + k);
            lastNode.setNext(currentNode.getNext());
            count--;
        }
    }

    public Node search(int k) {

        Node currentNode = root;
        while (currentNode != null && currentNode.getData() != k) {
            currentNode = currentNode.getNext();
        }
        if (currentNode != null) {
            System.out.println("找到：" + k);
        } else {
            System.out.println("没有 " + k + " 数据");
        }
        return currentNode;
    }

    //排序，默认从小到大排列
    public void sort() {

        Node node = root;

        for (int i = 1; i <= count; i++) {

            Node tempRoot = this.getRoot();
            int j = i;
            while (j > 1) {
                tempRoot = tempRoot.getNext();
                j--;
            }
            Node minNode = min(tempRoot);

            //交换节点值
            int temp = tempRoot.getData();
            tempRoot.setData(minNode.getData());
            minNode.setData(temp);
        }
    }

    public Node min(Node root) {
        Node node = root;

        if (root != null) {
            int min = root.getData();
            while (root != null) {
                if (root.getData() < min) {
                    min = root.getData();
                    node = root;
                }
                root = root.getNext();
            }
           // System.out.println("min = " + min);
        }
        return node;
    }

    public void print() {
        System.out.print("输出数据：");
        if (this.root != null) {
            this.root.printNode();
        }
        System.out.println();
    }

    public int size() {
        return count;
    }

    public boolean isEmpty() {
        return count == 0;
    }

    public void clean() {
        this.root = null;
        this.count = 0;
        System.out.println("清空链表");
    }

    public Node get(int index) {

        Node currentNode = root;
        if (index <= count && index > 0) {
            index--;
            while (currentNode != null && index > 0) {
                currentNode = currentNode.getNext();
                index--;
            }
        }
        return currentNode;
    }

    private class Node {
        private int data;
        private Node next;

        public Node(int data) {
            this.data = data;
        }

        public int getData() {
            return data;
        }

        public void setData(int data) {
            this.data = data;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }

        public void addNode(Node newNode) {
            if (this.next == null) {
                this.next = newNode;
            } else {
                this.next.addNode(newNode);
            }
        }

        public void printNode() {
            System.out.print(this.getData() + " ");
            if (this.next != null) {
                this.next.printNode();
            }
        }

    }
}


//双向链表
class DoubleLink {
    private Node root;
    private int count;

    public Node getRoot() {
        return root;
    }

    public void setRoot(Node root) {
        this.root = root;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public void insert(int data) {
        Node node = new Node(data);
        System.out.println("插入数据：" + data);
        if (root != null) {
            this.root.addNode(node);
        } else {
            this.root = node;
        }
        this.count++;
    }

    public void delete(int k) {
        //先查找到这个Node
        Node currentNode = root;

        while (currentNode != null && currentNode.getData() != k) {
            currentNode = currentNode.getNext();
        }

        if (currentNode == root) {
            //要删除的元素是第一个，或者链表为空
            if (currentNode == null) {
                System.out.println("链表为空");
            } else {
                //要删除的是第一个
                root = root.getNext();
                System.out.println("删除表头：" + k);
                count--;
            }
        } else {
            if (currentNode == null) {
                System.out.println("没有 "+k+" 数据");
            } else {
                //断开连接
                System.out.println("删除：" + k);
                currentNode.getPrior().setNext(currentNode.getNext());
                currentNode.getNext().setPrior(currentNode.getPrior());
                count--;
            }

        }
    }

    public Node search(int k) {

        Node currentNode = root;
        while (currentNode != null && currentNode.getData() != k) {
            currentNode = currentNode.getNext();
        }
        if (currentNode != null) {
            System.out.println("找到：" + k);
        } else {
            System.out.println("没有 " + k + " 数据");
        }
        return currentNode;
    }

    //排序，默认从小到大排列
    public void sort() {

        Node node = root;

        for (int i = 1; i <= count; i++) {

            Node tempRoot = this.getRoot();
            int j = i;
            while (j > 1) {
                tempRoot = tempRoot.getNext();
                j--;
            }
            Node minNode = min(tempRoot);

            //交换节点值
            int temp = tempRoot.getData();
            tempRoot.setData(minNode.getData());
            minNode.setData(temp);
        }
    }

    public Node min(Node root) {
        Node node = root;

        if (root != null) {
            int min = root.getData();
            while (root != null) {
                if (root.getData() < min) {
                    min = root.getData();
                    node = root;
                }
                root = root.getNext();
            }
            //System.out.println("min = " + min);
        }
        return node;
    }

    public void print() {
        System.out.print("输出数据：");
        if (this.root != null) {
            this.root.printNode();
        }
        System.out.println();
    }

    public int size() {
        return count;
    }

    public boolean isEmpty() {
        return count == 0;
    }

    public void clean() {
        this.root = null;
        this.count = 0;
        System.out.println("清空链表");
    }

    public Node get(int index) {

        Node currentNode = root;
        if (index <= count && index > 0) {
            index--;
            while (currentNode != null && index > 0) {
                currentNode = currentNode.getNext();
                index--;
            }
        }
        return currentNode;
    }

    private class Node {
        private int data;
        private Node prior;
        private Node next;

        public Node getPrior() {
            return prior;
        }

        public void setPrior(Node prior) {
            this.prior = prior;
        }

        public Node(int data) {
            this.data = data;
        }

        public int getData() {
            return data;
        }

        public void setData(int data) {
            this.data = data;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }

        public void addNode(Node newNode) {
            if (this.next == null) {
                newNode.setPrior(this);
                this.next = newNode;
            } else {
                this.next.addNode(newNode);
            }
        }

        public void printNode() {
            System.out.print(this.getData() + " ");
            if (this.next != null) {
                this.next.printNode();
            }
        }

    }

}

这里写图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值