数据结构之链表的实现

链表的概念：链表也是线性表的一种，链表的逻辑结构和物理结构并不相同，链表的元素包含指针和数据值。

链表的优点：链表易于删除和插入，时间复杂度是O(1）

　　　缺点：不利于查找，复杂度是O(n)

链表的java实现

节点类Node

package LinkList;
/*
* 首先定义node类
* node包含三个变量
* 1.获取和设置本节点数据
* 2.获取和设置下一个点的地址
* 3.获取和设置上个节点的地址*/

public class Node {
    public Object data;
    public Node next;
    public Node before;
    public Node() {

    }
    public Node(Object data){
        super();
        this.data = data;
    }

    public Object getData() {
        return data;
    }

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

    public Node getNext() {
        return next;
    }

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

    public Node getBefore() {
        return before;
    }

    public void setBefore(Node before) {
        this.before = before;
    }
}

链表实现类MyLinklist

package LinkList;


public class MyLinkList<E> {
    // 实例化根节点,头节点一般没有数据
    private Node root = new Node();
    private Node next;
    private Node last;
    private int size;

    // 获取size
    public int getSize(){
        return size;
    }

    // 增
    public void add(Object data){
        // 实例化下个节点
        next = new Node(data);
        if (size == 0){
            // 存入root的下个节点地址中存放next
            root.setNext(next);
            last = next;
            size++;
        }else {
            // 存入最后一个节点中,每次存入的next地址不同
            last.setNext(next);
            last = next;
            size++;
        }

    }

    // 查
    public Object searchByIndex(int index)throws Exception{
        if (index<0 || index>size-1){
            throw new Exception("查找节点不存在");

        }else{
            // 第0个节点
            Node indexNode = root.getNext();
            // 第index-1个节点
            for (int i =0;i<index;i++){
                indexNode = indexNode.getNext();
            }
            return indexNode.getData();
        }

    }

    // 改
    public void updateByIndex(int index,E e) throws Exception {
        if (index<0 || index>size-1){
            throw new Exception("更新节点节点不存在");
        }else{
            Node indexNode = root.getNext();
            for (int i =0;i<index;i++){
                indexNode = indexNode.getNext();
            }
            indexNode.setData(e);
        }
    }

    // 删
    public void deleteByIndex(int index) throws Exception {
        if (index<0 || index>size-1){
            throw new Exception("删除节点不存在");
        }else {
            Node indexNode = root.getNext();
            Node indexNodeNext = root.getNext();
            Node indexNodeBefore = root.getNext();
            // 删除是最后一个节点
            if (index == size -1){
                for (int i = 0;i<index-1;i++){
                    // 得到要删除节点的前一个的点
                    indexNodeBefore = indexNodeBefore.getNext();
                }
                indexNodeBefore.setNext(null);
                size--;
            }else if (index == 0){
                // 查找位置为第0个节点
                for (int i =0;i<1;i++){
                    // 获得第一个节点
                    indexNodeNext = indexNodeNext.getNext();
                }
                root.setNext(indexNodeNext);
                size--;


            }else {
                for (int i = 0;i<index-1;i++){
                    // 得到要删除节点的前一个的点
                    indexNodeBefore = indexNodeBefore.getNext();
                }
                for (int i = 0;i<index+1;i++){
                    // 得到要删除节点的后一个的点
                    indexNodeNext = indexNodeNext.getNext();
                }
                indexNodeBefore.setNext(indexNodeNext);
                size--;
            }

        }
    }

    // 插入
    public void insertData(int index,E e) throws Exception {
        if (index<0 || index>size){
            throw new Exception("插入节点不存在");
        }else {
            Node indexNode = new Node(e);
            Node indexNodeNext = root.getNext();
            Node indexNodeBefore = root.getNext();

            if (index == size ){
                // 加入是尾部
                add(e);
            }else if (index == 0){
                // 查找位置为第0个节点
                root.setNext(indexNode);
                indexNode.setNext(indexNodeNext);
                size++;

            }else {
                for (int i = 0;i<index-1;i++){
                    // 得到要删除节点的前一个的点
                    indexNodeBefore = indexNodeBefore.getNext();
                }
                for (int i = 0;i<index+1;i++){
                    // 得到要删除节点的后一个的点
                    indexNodeNext = indexNodeNext.getNext();
                }
                indexNodeBefore.setNext(indexNode);
                indexNode.setNext(indexNodeNext);
                size++;
            }

        }
    }

    // 添加循环列表，增删改查需要修改
    public void addCycleList(E e){
        // 实例化下个节点
        next = new Node(e);
        if (size == 0){
            // 存入root的下个节点地址中存放next
            root.setNext(next);
            last = next; // 只有一个节点不需要指向自己
            size++;
        }else {
            // 存入最后一个节点中,每次存入的next地址不同
            last.setNext(next);
            last = next;
            last.setNext(root.getNext()); // 指向第0个节点位置
            size++;
        }

    }

    // 添加循环列表，增删改查需要修改
    public void addDoubleOrientList(E e){
        // 实例化下个节点
        next = new Node(e);
        if (size == 0){
            // 存入root的下个节点地址中存放next
            root.setNext(next);
            last = next; // 只有一个节点不需要指向自己
            size++;
        }else {
            // 存入最后一个节点中,每次存入的next地址不同
            last.setNext(next);
            next.setBefore(last);
            last = next;
            size++;
        }

    }
}

测试类Test

public class Test {
    public static void main(String[] args) throws Exception {
        MyLinkList<Comparable> myLinkList= new MyLinkList<Comparable>();
        myLinkList.add(1);
        myLinkList.add(2);
        myLinkList.add(3);
//        myLinkList.updateByIndex(1,11);
//        System.out.println(myLinkList.searchByIndex(1));
//        myLinkList.deleteByIndex(1);
//        System.out.println(myLinkList.searchByIndex(1));
//        myLinkList.insertData(1,11);
//        System.out.println(myLinkList.searchByIndex(1));
//        System.out.println(myLinkList.getSize());
        myLinkList.deleteByIndex(2);
        System.out.println(myLinkList.searchByIndex(1));
    }
}

链表的python实现

class SingleNode(object):
    # 创建节点类
    def __init__(self,data):
        # 存放数据
        self.data = data
        # 下一个节点
        self.next = None



class SingleLinkList(object):
    def __init__(self):
        # 初始化头节点
        self.root = SingleNode(None)
        self.nextNode = None
        self.beforeNode = None
        self.lastNode = None
        self.size = 0

    # 查找长度
    def getSize(self):
        return self.size

    # 增
    def add(self,data):
        if self.size ==0:
            self.nextNode = SingleNode(data)
            self.root.next = self.nextNode
            self.lastNode = self.nextNode
            self.size+=1

        else:
            self.nextNode = SingleNode(data)
            self.lastNode.next = self.nextNode
            self.lastNode = self.nextNode
            self.size +=1
    # 删
    def removeByIndex(self,index):
        if index<0 or self.size-1<index:
            print("删除节点不存在")
        elif index == self.size-1:
            indexNodebefore = self.root.next
            for i in range(index-1):
                indexNodebefore = indexNodebefore.next
            indexNodebefore.next = None
            self.size -=1
        elif index == 0:
            indexNodeNext = self.root.next
            for i in range(index+1):
                indexNodeNext = indexNodeNext.next
            self.root.next = indexNodeNext
            self.size -=1
        else:
            indexNodebefore = self.root.next
            indexNodeNext = self.root.next
            for i in range(index - 1):
                indexNodebefore = indexNodebefore.next
            for i in range(index+1):
                indexNodeNext = indexNodeNext.next
            indexNodebefore.next = None
            indexNodebefore.next = indexNodeNext
            self.size -=1

    # 改
    def updataByIndex(self,index,data):
        if index < 0 or self.size - 1 < index:
            print("删除节点不存在")
        else:
            indexNode = self.root.next
            for i in range(index):
                indexNode = indexNode.next
            indexNode.data = data

    # 查
    def searchByIndex(self,index):
        if index < 0 or self.size - 1 < index:
            print("查找节点不存在")
        else:
            indexNode = self.root.next
            for i in range(index):
                indexNode = indexNode.next
            return indexNode.data

    # 插入
    def insertByIndex(self,index,data):
        if index<0 or self.size<index:
            print("插入节点不存在")
        elif index == self.size:
            SingleLinkList.add(data)
        elif index == 0:
            indexNode = SingleNode(data)
            indexNodeNext = self.root.next
            self.root.next = indexNode
            indexNode.next = indexNodeNext
            self.size +=1
        else:
            indexNode = SingleNode(data)
            indexNodebefore = self.root.next
            indexNodeNext = self.root.next
            for i in range(index - 1):
                indexNodebefore = indexNodebefore.next
            for i in range(index+1):
                indexNodeNext = indexNodeNext.next
            indexNodebefore.next = indexNode
            indexNode.next = indexNodeNext
            self.size +=1


list = SingleLinkList()
list.add(1)
list.add(2)
list.add(3)
print("====增======")
print(list.searchByIndex(0))
print(list.size)
print("====删======")
list.removeByIndex(0)
print(list.searchByIndex(0))
print(list.size)
print("====改======")
list.updataByIndex(0,20)
print(list.searchByIndex(0))
print(list.size)
print("====插入======")
list.insertByIndex(0,11)
print(list.searchByIndex(0))
print(list.size)