• 数据结构:单链表


    单链表的实现:

    分为java和python两种代码:

    Python代码如下:

    # -*- coding: utf-8 -*-
    
    '''
    利用python实现单向链表,单向链表由数据部分和下节点地址两部分组成
        对于单向链表,首先要对每个链表元素创建一个类,属性包含数据部分和下节点地址部分。
        然后再创建一个类来表示单向链表,单项列表主要包含,初始化,判断是否为空,追加节点,删除节点,插入节点,更新节点,
        根据索引值获取数据项,根据数据项获取索引值,清空链表操作。
    '''
    
    # 定义单链表的节点Node类
    class Node(object):
        def __init__(self, data, next=None):
            self.data = data
            self.next = next
        def __repr__(self):
            # 覆写了object中的__repr__,直接输出Node类对象即为调用了这个函数
            return str(self.data)
    
    # 定义单链表类SingleChainTable
    class SingleChainTable(object):
        def __init__(self):
            self.head = None
            self. length = 0
        
        def isEmpty(self):
            if self.length == 0:
                return True
            else:
                return False
    
        def append(self, dataOrNode):
            item = None
            # isinstance用来判断dataOrNode是否属于Node对象
            # 如果是,直接接到链表末尾,如果不是,将其构建为一个节点接到链表末尾
            if isinstance(dataOrNode, Node):
                item = dataOrNode
            else:
                item = Node(dataOrNode)
    
            # 首先要判断链表是否为空,如果为空,则直接把item赋给head
            # 否则,遍历链表找到最后一个节点
            if self.head == None:
                self.head = item
                self.length += 1
            else:
                node = self.head
                while node.next:
                    node = node.next
                node.next = item
                self.length += 1
    
        # 根据索引值来删除链表,首先要判断链表是否为空,索引值是否超出链表范围
        # 如果以上两种情况都没出现,则查找索引值所对应的节点
        # 如果index所指的是头节点,则直接将头节点head更改为原头节点的下一个节点,并将长度减去1即可。
        # 如果index不是头节点,则需要遍历链表,找到index所对应的节点和其前一个节点,将前一个节点的next赋值为其后一个节点
        def delete(self, index):
            if self.isEmpty():
                print('the single chain table is empty.')
                return
            if index < 0 or index >= self.length:
                print('error: out of index.')
                return
            
            if index = 0:
                self.head = self.head.next
                self.length -= 1
                return
            
            j = 0
            node = self.head
            preNode  = self.head
            while node.next and j < index:
                preNode = node
                node = node.next
                j += 1
    
            if j == index:
                preNode.next = node.next
                self.length -= 1
                return
    
        # 这里将插入理解为在某个索引值所对应的节点之前插入,因此需要找到index对应节点和其前一个节点
        # 根据索引值插入节点,因此该函数需要一个索引值index,还需要一个节点对象dataOrNode
        # 因为有索引值,所以链表为空,不能插入,index也不能超过链表范围
        # 首先判断index是否为0,为0,直接把数据作为表头,否则遍历寻找index所对用节点
        def insert(self, index, dataOrNode):
            if self.isEmpty():
                print('the single chain table is empty.')
                return
            if index < 0 or index >= self.length:
                print('error: out of index.')
                return
            
            item = None
            if isinstance(dataOrNode, Node):
                item = dataOrNode
            else:
                item = Node(dataOrNode)
    
            if index == 0:
                item.next = self.head
                self.head = item
                self.length += 1
                return
    
            j = 0
            preNode = self.head
            node = self.head
            while node.next and j < index:
                preNode = node
                node = node.next
                j += 1
            
            if j == index:
                preNode.next = item
                item.next = node
                self.length += 1
                return
    
        # 更新索引值所对应节点的数据项
        # 拥有索引值index,因此需要判断
        def updata(self, index, data):
            if self.isEmpty():
                print('the single chain table is empty.')
                return
            if index < 0 or index >= self.length:
                print('error: out of index.')
                return
            
            j = 0 
            node = self.head
            while node.next and j < index:
                node = node.next
                j += 1
    
            if j == index:
                node.data = data
                return 
    
        # 根据索引值获取数据项
        # 判断index
        def getItem(self, index):
            if self.isEmpty():
                print('the single chain table is empty.')
                return
            if index < 0 or index >= self.length:
                print('error: out of index.')
                return
            
            j = 0
            node = self.head
            while node.next and j < index:
                node = node.next
                j += 1
            
            if j == index:
                return node.data
    
        # 判断数据项data是否在链表中,并返回index值
        def getIndex(self, data):
            if self.isEmpty():
                print('the single chain table is empty.')
                return
    
            j = 0
            node = self.head
            while node:
                if node.data = data:
                    return j
                else:
                    node = node.next
                    j += 1
    
            if j == length:
                print('%s not found' % data)
                return
    
        def clear(self):
            self.head = None
            self.length = 0

    Java代码如下:

    public class SingleChainTable2 {
    
        private Node head;
        private int length;
        
        public SingleChainTable2() {
            this.head = null;
            this.length = 0;
        }
        
        public boolean isEmpty(){
            if(this.length == 0){
                return true;
            }else{
                return false;
            }
        }
        
        public void append(Object dataOrNode){
            Node item = null;
            if(dataOrNode instanceof Node){
                item = (Node)dataOrNode;
            }else{
                item = new Node(Integer.parseInt(dataOrNode.toString()));
            }
            if(this.isEmpty()){
                this.head = item;
                this.length++;
            }else{
                Node node = this.head;
                while(node.getNext() != null){
                    node = node.getNext();
                }
                node.setNext(item);
                this.length++;
            }
            
        }
        
        public void delete(int index){
            if(this.isEmpty()){
                System.out.println("the single chain table is empty.");
            }
            if(index < 0 || index >= this.length){
                System.out.println("error: out of index.");
            }
            
            if(index == 0){
                this.head = this.head.getNext();
                this.length--;
            }
            
            int j = 0;
            Node preNode = this.head;
            Node node = this.head;
            while(node.getNext() != null && j < index){
                preNode = node;
                node = node.getNext();
                j++;
            }
            if(j == index){
                preNode.setNext(node.getNext());
                this.length--;
            }    
        }
        
        public void insert(int index, Object dataOrNode){
            if(this.isEmpty()){
                System.out.println("the single chain table is empty.");
            }
            if(index < 0 || index >= this.length){
                System.out.println("error: out of index.");
            }
            
            Node item = null;
            if(dataOrNode instanceof Node){
                item = (Node)dataOrNode;
            }else{
                item = new Node(Integer.parseInt(dataOrNode.toString()));
            }
            
            if(index == 0){
                item.setNext(this.head);
                this.head = item;
                this.length++;
            }
            
            int j = 0;
            Node preNode = this.head;
            Node node = this.head;
            while(node.getNext() != null && j < index){
                preNode = node;
                node = node.getNext();
                j++;
            }
            if(j == index){
                preNode.setNext(item);
                item.setNext(node);
                this.length++;
            }
        }
        
        public void update(int index, int data){
            if(this.isEmpty()){
                System.out.println("the single chain table is empty.");
            }
            if(index < 0 || index >= this.length){
                System.out.println("error: out of index.");
            }
            
            int j = 0;
            Node node = this.head;
            while(node.getNext() != null && j < index){
                node = node.getNext();
                j++;
            }
            if(j == index){
                node.setData(data);
            }
        }
        
        public int getItem(int index){
            if(this.isEmpty()){
                System.out.println("the single chain table is empty.");
                return -11111;
            }
            if(index < 0 || index >= this.length){
                System.out.println("error: out of index.");
                return -11111;
            }
            
            int j = 0;
            Node node = this.head;
            while(node.getNext() != null && j < index){
                node = node.getNext();
                j++;
            }
            return node.getData();
        }
        
        public int getIndex(int data){
            if(this.isEmpty()){
                System.out.println("the single chain table is empty.");
                return -1111;
            }
            
            int j = 0;
            Node node = this.head;
            while(node != null){
                if(node.getData() == data){
                    return j; 
                }else{
                    node = node.getNext();
                    j++;
                }
            }
            if(j == length){
                System.out.println(data + "not found.");
            }
            return -1111;
        }
        
        public void clear(){
            this.head = null;
            this.length = 0;
        }
    }
    
    class Node extends Object{
        private int data;
        private Node next;
        
        public void setData(int data){
            this.data = data;
        }
        public void setNext(Node next){
            this.next = next;
        }
        public int getData(){
            return this.data;
        }
        public Node getNext(){
            return this.next;
        }
        
        
        public Node(int data){
            this.data = data;
            this.next = null;
        }
        public String toString(){
            return "" + this.data;
        }
    }

    Java和Python基本是一样的,只是语法上的不同,还有要注意,java中本类用this关键字,而python的本类用self关键字。

     

  • 相关阅读:
    HQL语句中类的别名语法以及作用?
    C#面向对象
    c#异步编程一
    c#接口
    c#Socket通信基本使用
    c#FTP基本使用
    c#XML的基本使用
    c#装箱与拆箱
    c#数组与集合
    c#中for与foreach的使用
  • 原文地址:https://www.cnblogs.com/kkkwoniu/p/7920746.html
Copyright © 2020-2023  润新知