a graphical for double linked list

I made this today to print of a better graphical representation of my double linked list.
I was testing my push, 'append', add... whatever you want to call it,  and I thought, this is really hard to look at.  I really wish there was an easier way to look at this...  So I decided to make it easier to look at.    Here's a snippet of what I did and the results in the command prompt.

If the node fails, so will the output to command prompt.  I'm sure it needs more testing, but I'm pretty happy with it.  Try it out!



And here's my code so far:::
Update 12-5-17:
I realized I did not account for size 0, and 1 list,  fixed and updated:  Here's the graphical and code so far:

class DLLNode(object):
    # I changed the order so that it would be easier to visualize
    # and easier to keep track of.
    def __init__(self, prev, value, nxt):
        # the first node will have no next or previous
        self.value = value
        self.next = nxt
        # previous
        self.prev = prev

    def __repr__(self):
        nval = self.next and self.next.value or None
        pval = self.prev and self.prev.value or None
        ##  previous node,  assigned value, link to next node in list ##
        return f"[{repr(pval)}, {self.value}, {repr(nval)}]"

class DLList(object):
    def __init__(self):
        #  Ok  this needs to stay the same...
        #  end holds the last node
        self.end = None
        #  begin holds the first node.....
        self.begin = None


    def push(self, obj):
     

        # if there is an empty list create first node with no next or prev.

        if self.end == None and self.begin == None:

           newnode = DLLNode(None, obj, None)
           self.begin = newnode
           #  I want it to also print something off like 
           ##  ( (--) ,  1 , (--) )  ##  when it prints the list.....
           #  did this in 'my print out methods'  method: graphical()

         
        # if there is only a first node, create next node that links back and forward
        # set.begin node * CHECK ZED'S SOLUTION INTRO *
        elif self.end == None and self.begin != None:
            # get the address of the original node
            node = self.begin
            # create address for new node
            newnode = DLLNode(node, obj, None)
            self.end = newnode
            self.begin.next = self.end
       
        else:
         
            node = self.end
            newnode = DLLNode(node, obj, None)
            self.end.next = newnode
            self.end = newnode

        assert self.end != self.begin

   

 #################----------------------------------##############
#######                MY PRINT OUT METHODS             #########        
             ###( <--- previous, obj , next --->)###
           
    def graphical(self):
   
        ## None = (/)
        ## [ link = number in count ]
        ## OBJ = Data or Value?
        ## so, [  1 ,  DATA ,  (/)  ]

         length = self.count()
        node = self.begin
        if self.begin == None:
            print(" EMPTY ")
        elif self.begin != None and self.end == None:
            print("\n\n")
            # [(/), DATA, (/)]
            print(f"{node.value}=")
            print(f"[(/), DATA, (/)]")
        else:
            node = self.end
            if node:
                print("\n\n")
            while node:
                # example, length is 3 
                if node.next == None and node.prev != None:
                    # [ 2 , DATA , (/) ]
                    print(f"{node.value}=")
                    print(f"\t [ {length -1}, DATA , (/) ]")
                elif node.next != None and node.prev != None:
                    # [ 1 , DATA , 2]
                    print(f"{node.value}=")
                    print(f"\t [ {length -2}, DATA, {length -1}]")
                    length -= 1
                else:
                    # [ (/), DATA , 1]
                    print(f"{node.value}=")
                    print(f"\t [ (/), DATA, 1 ]")
                node = node.prev

     ########  <------   prev ---- end 
    def what_start(self):
        print(" back = ")
        node = self.end
        if node:
            print(node.next)
            while node:
            
                print(node)
                node = node.prev

     ########   begin ----->  next 
    def where_end(self):
        node = self.begin
        print(" front = ")
        if node:
            while node:
                print(node)
                node = node.next

 ###################      END my print outs    #################################

 ################################## count ######################################
    def count(self):
        count = 0
        node = self.begin
        while node:
            count +=1
            node = node.next
        return count
################################  END count ####################
#################### POP ##################################
    def pop(self):
        # Zed said it would be just like SLL.....
        # [ (/) , DATA , ---->] [<----, DATA, ---->] [<----, DATA, (/)]
        # [ (/) , DATA , ---->] [<----, DATA, (/) ] ....................
        # if list is empty:
        if self.begin == None:
            print(" Nothing to PoP! ")
            return None
        elif self.begin and not self.end:
            print(" That was a lonely little data...")
            carrots = self.begin.value
            self.begin = None
            return carrots
        else:
            carrots = self.end.value
            newEnd = self.end.prev
            self.end = newEnd
            if newEnd == self.begin:
                self.begin.next = None
                self.end = None
            newEnd.next = None
            return carrots

 ##########################   END POP ##############################

 #####################------------------------------------#######################
#################     -- GET --   and it's   _invariant       #######################
####################-------------------------------------########################
   
    def get(self, index):
     
        length = self.count()     
        count = 0
        if length == 0:
            # for testing, None works better then "Empty list!"
            return(None)
        elif index > (length):
            # now I know what this message is all about.
            # the index is greater then the length of the list
            # remember index starts at 0
            return(" index out of range! ")
        else:
            node = self.begin
            while node:
               
                if count == index:
                    return(node.value)
                else:
                    node = node.next
                   
                count += 1
           
    def _get(self, index):
        length = self.count()     
       
        if length == 0:
            # for testing, None works better then "Empty list!"
            return(None)

        elif index > (length):
            # now I know what this message is all about.
            # the index is greater then the length of the list
            # remember index starts at 0
            return(" index out of range! ")

        elif length == 1:
            # when there are 0, or 1 item's on the list, else loop won't work.
            if index == 0:
                node = self.begin
                return(node.value)
         

        else:
            node = self.end
            #  [(/)(0)DATA -->][<---(1)DATA--->][<---(2)DATA--->][<---(3)DATA (/) ]
            # length    1                           2                             3                            4
            while node:
               
                if length == index + 1:
                    return(node.value)
                else:
                    node = node.prev
                   
                length -= 1

 ########################## END GET###############################
       


       

Comments

Post a Comment

Popular posts from this blog

JavaScript Ascii animation with while loops and console.log

I was working on figuring out while loops for an exercise in LearnJavaScriptTheHardWay  by Zed Shaw,  and I decided to do this: The red text console.logs were for debugging, and will take over the animation if the comments are removed. The bold red number is the point at which the loop stops.  My CPU didn't have too much trouble with that large number, but I'd recommend dialing it down if your CPU is slow. Also if your CPU is really fast, you'll have to change the pause to something much lower to see the animation better.  That too is in a loop, so the more that pause happens, the more loops your CPU is running.   Link: https://stackoverflow.com/questions/9006988/node-js-on-windows-how-to-clear-console To clear screen as described in link above, uncomment the bold purple comment I tried to comment the code to help learners see what I did,  any comments or suggestions, feel free to drop em in!                      ex16_ASCII.js //Trying to make a comma
Read more

playing with trigonometry sin in pygame

Image
Ok I am so far from understanding, so don't take this as any kind of math lesson. Also, every time I thought I knew what I was doing.... pygame would show me differently. Still a work in progress, but for now, something to play with. Update: SinWaveTime class added to produce that particular weaving effect Tinkering with the different sin wave variables: I wrote this piece separate from my 3D experiment to see how to manipulate the sin wave. While trying to use time as the factor to move my pygame draw circle on the x-axis, i got this crazy little doo-dad : I don't think it's drawing two circles at once, but if I figure out what the heck it's doing I'll let you know.  Or hey if you know, drop a comment.  I don't know if my comments are just not working, or no one wants to. So, here's some pygame code to play with the sin wave.  Alter the different variables to see it in action. picture of SinWave.move_with_time() see changes, SinWaveTime c
Read more

playing with color in powershell python

Here's a bit I'm working on.  I've discovered I love doing Ascii.  Examples of how to use the color changing escape.  I got a table from StackOverflow: https://stackoverflow.com/questions/287871/print-in-terminal-with-colors-using-python the charts are way at the bottom. So far accurate for me.  def prettyjunk ( self ): # 1 is bold, 0 is plain, 2 is dull text_red = ' \x1b [1;31;40m' stop_color = ' \x1b [0m' text_blue = ' \x1b [1;34;40m' text_green = ' \x1b [1;32;40m' text_purple = ' \x1b [1;35;40m' text_lightblue = ' \x1b [1;36;40m' text_white = ' \x1b [1;37;40m' a_green_at = ( f " { text_green } @ { stop_color } " ) a_red_at = ( f " { text_red } @ { stop_color } " ) print ( f " { text_red } This should be Red. { stop_color } " ) print ( f "
Read more