python实现无序链表

unorderedlist.py

# -*- coding: utf-8 -*-
from termcolor import colored
import logging

logging.basicConfig(
    filename="myLink.log",
    level=logging.DEBUG,
    format="%(asctime)s:%(levelname)s:%(message)s"
    )


class Node:
    def __init__(self,val):
        self.__val=val
        logging.debug("self.__val={}".format(self.__val))
    
        self.__next=None
        logging.debug("self.__next={}".format(self.__next))
     
    def get_val(self):
        return self.__val
    
    def get_next(self):
        return self.__next
    
    def set_val(self,newval):
        self.__val=newval
        
                
    def set_next(self,newnext):
        self.__next=newnext
        logging.debug("newnext={}".format(newnext))

class UnorderedList:
    def __init__(self):
        self.__head=None
        logging.debug("self.____head={}".format(self.__head))
        
    def show(self):
        temp=[]
        cur_ptr=self.__head
        while cur_ptr is not None:
            temp.append(cur_ptr.get_val())
            cur_ptr=cur_ptr.get_next()
        #temp.reverse()
        print(temp)
        
    def is_empty(self):
        return self.__head==None
    
    def add(self,item):
        temp=Node(item)
        logging.debug("temp={}".format(temp))
        
        temp.set_next(self.__head)
        
        self.__head=temp
       
    def length(self):
        current_ptr=self.__head
        logging.debug("current_ptr={}".format(current_ptr))
        
        count=0
        while current_ptr is not None:
            count+=1
            current_ptr=current_ptr.get_next()
            logging.debug("current_ptr={}".format(current_ptr))
        return count
    
    def search(self,item):
        cur_ptr=self.__head
        found=False
        while cur_ptr is not None:
            if cur_ptr.get_val()==item:
                return True
            cur_ptr=cur_ptr.get_next()
        return found
    
    def remove(self,item):
        cur_ptr=self.__head
        prev_ptr=None
     
        while cur_ptr is not None:
            if cur_ptr.get_val()==item:
                break
            else:
                prev_ptr=cur_ptr
                cur_ptr=cur_ptr.get_next()
        if prev_ptr==None:
            self.__head=cur_ptr.get_next()
        elif cur_ptr==None:
            print(colored('There is no item in list, ignored.','cyan'))
        else:
            prev_ptr.set_next(cur_ptr.get_next())
            
   
    def append(self,item):
        temp=Node(item)
        cur_ptr=self.__head
        if cur_ptr is None:
            self.__head=temp
        else:
            while cur_ptr.get_next() is not None:
                cur_ptr=cur_ptr.get_next()
            cur_ptr.set_next(temp)
        

    def insert(self,item,pos=0):
        length=self.length()
        if pos<0:pos=0
        elif pos>length:pos=length
        else:pos=pos
        
        temp=Node(item)
        
        prev_ptr=None
        cur_ptr=self.__head
        count=0
        
        if pos==0 or cur_ptr is None:
            self.add(item)
        elif pos==length:
            self.append(item)
        else:
            while count<pos:
                prev_ptr=cur_ptr
                cur_ptr=cur_ptr.get_next()
                count+=1
            prev_ptr.set_next(temp)
            temp.set_next(cur_ptr)
            
        
        
    def index(self,item):
        cur_ptr=self.__head
        logging.debug("index:cur_ptr={}".format(cur_ptr))
        count=0
        while cur_ptr is not None:
            if cur_ptr.get_val() == item: 
                return count
            else:
                cur_ptr=cur_ptr.get_next()
                count+=1
        print('There is no item in list, system will return -1.')
        return -1

    def pop(self,pos=float('inf')):
        if self.length()==0:
            print("There are nothing in list can be popped, Return.")
            return 0
        length=self.length()-1
        cur_ptr=self.__head
        prev_pre=None
        count=0
        if pos<0:pos=0
        if pos>length:pos=length
        
        if pos==0:self.__head=cur_ptr.get_next()
        elif pos==length:
            while cur_ptr.get_next() is not None:
                prev_ptr=cur_ptr
                cur_ptr=cur_ptr.get_next()
            prev_ptr.set_next(None)
        else:
            while count<pos:
                prev_ptr=cur_ptr
                cur_ptr=cur_ptr.get_next()
                count+=1
            prev_ptr.set_next(cur_ptr.get_next())
            
    def get_head(self):
        return self.__head

test_unorderedlist.py
这个还没完成，可以手动测试，通过。

# -*- coding: utf-8 -*-

from myLink import UnorderedList

a=UnorderedList()

def is_equal(alink,alist):
    if alink.length()!=len(alist):
        return False
    else:
        cur_ptr=alink.get_head()
        for i in range(len(alist)):
            if cur_ptr.get_val()!=alist[i]:
                return False
            else:
                cur_ptr=cur_ptr.get_next()
    return True

def clear_list(alink):
    length=alink.length()
    for i in range(length):
        alink.pop()
    alink.show()
    
def add_list(alink):
    for i in range(6):
        alink.append(i)
    alink.show()
    
    
def tested_length(alink):
    clear_list(alink)
    if alink.length()!=0:
        print("length func failed.")
        return False
    add_list(alink)
    if alink.length()!=6:
        print("length func failed.")
        return False 
    print("length func tested.")
    return True

def tested_is_empty(alink):
    clear_list(alink)
    if alink.is_empty() is not True:
        print("is_empty func failed.")
        return False
    add_list(alink)
    if alink.length() is not False:
        print("is_empty func failed.")
        return False 
    print("is_empty func tested.")
    return True

def tested_add(alink):
    clear_list(alink)
    
    if not is_equal(alink):
        print("length func failed.")
        return False
    add_list(alink)
    if alink.length()!=6:
        print("length func failed.")
        return False 
    print("length func tested.")
    return True