[GeneralAlgorithm] Double-linked List Algorithm 双链表算法 (in Python)

Double-linked List Algorithm (in Python)

简易双链表算法，部分功能待补充。

class DLinkedListNode:
    def __init__(self, initData=None, initNext=None, initPrevious=None):
        self.data = initData
        self.next = initNext
        self.previous = initPrevious

        if initNext is not None:
            self.next.previous = self
        if initPrevious is not None:
            self.previous.next = self

    def getData(self):
        return self.data

    def setData(self, newData):
        self.data = newData

    def getNext(self):
        return self.next

    def getPrevious(self):
        return self.previous

    def setNext(self, newNext):
        self.next = newNext

    def setPrevious(self, newPrevious):
        self.previous = newPrevious


class DLinkedList:
    def __init__(self):
        self.__head = None
        self.__tail = None
        self.__size = 0

    def search(self, item):
        current = self.__head
        found = False
        while current is not None and not found:
            if current.getData() == item:
                found = True
            else:
                current = current.getNext()
        return found

    def index(self, item):
        current = self.__head
        found = False
        index = 0
        while current is not None and not found:
            if current.getData() == item:
                found = True
            else:
                current = current.getNext()
                index = index + 1
        if not found:
            index = -1
        return index

    def insert(self, pos, item):
        assert 0 <= pos
        if pos == 0:  
            self.add(item)
        elif pos > self.__size - 1:  
            self.append(item)
        else:
            index = 0
            current = self.__head
            newNode = DLinkedListNode(item)

            while index < pos - 1:
                index += 1
                current = current.getNext()
            newNode.setNext(current.getNext())
            newNode.setPrevious(current)
            current.getNext().setPrevious(newNode)
            current.setNext(newNode)
            self.__size += 1

    def searchLarger(self, item):
        index = 0
        current = self.__head
        if current.getData() > item:
            return index
        while index < self.__size:
            current = current.getNext()
            index += 1
            if int(current.getData()) > item:
                return index

    def getSize(self):
        return self.__size

    def getItem(self, pos):
        assert isinstance(pos, int)
        if self.__size < pos:
            raise Exception
        if pos > 0:
            current = self.__head
            index = 0
            while index != pos:
                current = current.getNext()
                index += 1
            return current.getData()
        elif pos == 0:
            current = self.__head
            return current.getData()
        else:
            pos_opp = abs(pos)
            current = self.__tail
            index = 1
            while index != pos_opp:
                current = current.getPrevious()
                index += 1
            return current.getData()

    def __str__(self):
        expression_list = []
        index = 0
        current = self.__head
        expression_list.append(str(self.__head.getData()))
        while index != (self.__size - 1):
            current = current.getNext()
            expression_list.append(str(current.getData()))
            index += 1
        string = ' '
        expression_str = string.join(expression_list)
        return expression_str

    def add(self, item):
        temp = DLinkedListNode(item, self.__head)
        if self.__head is None:
            self.__tail = temp
        else:
            self.__head.setPrevious(temp)
        self.__head = temp
        self.__size += 1

    def append(self, item):
        temp = DLinkedListNode(item)
        if self.__head is None:
            self.__head = temp
        else:
            self.__tail.setNext(temp)
            temp.setPrevious(self.__tail)
        self.__tail = temp
        self.__size += 1

    def remove(self, item):
        pass

    def pop(self):
        pass

    def pop_pos(self, pos=None):
        pass