数据结构是计算机科学必须掌握的一门学问，之前很多的教材都是用C语言实现链表，因为c有指针，可以很方便的控制内存，很方便就实现链表，其他的语言，则没那么方便，有很多都是用模拟链表，不过这次，我不是用模拟链表来实现，因为python是动态语言，可以直接把对象赋值给新的变量。

好了，在说我用python实现前，先简单说说链表吧。在我们存储一大波数据时，我们很多时候是使用数组，但是当我们执行插入操作的时候就是非常麻烦，看下面的例子，有一堆数据1,2,3,5,6,7我们要在3和5之间插入4,如果用数组，我们会怎么做？当然是将5之后的数据往后退一位，然后再插入4,这样非常麻烦，但是如果用链表，我就直接在3和5之间插入4就行，听着就很方便。

那么链表的结构是怎么样的呢？顾名思义，链表当然像锁链一样，由一节节节点连在一起，组成一条数据链。

链表的节点的结构如下：

data为自定义的数据，next为下一个节点的地址。

链表的结构为，head保存首位节点的地址：

接下来我们来用python实现链表

python实现链表

首先，定义节点类Node：

class Node:
    '''
    data: 节点保存的数据
    _next: 保存下一个节点对象
    '''
    def __init__(self, data, pnext=None):
        self.data = data
        self._next = pnext

    def __repr__(self):
        '''
        用来定义Node的字符输出，
        print为输出data
        '''
        return str(self.data)

然后，定义链表类：

链表要包括：

属性：

链表头：head

链表长度：length

方法：

判断是否为空: isEmpty()

def isEmpty(self):
    return (self.length == 0

增加一个节点(在链表尾添加): append()

def append(self, dataOrNode):
    item = None
    if isinstance(dataOrNode, Node):
        item = dataOrNode
    else:
        item = Node(dataOrNode)

    if not self.head:
        self.head = item
        self.length += 1

    else:
        node = self.head
        while node._next:
            node = node._next
        node._next = item
        self.length += 1

删除一个节点: delete()

#删除一个节点之后记得要把链表长度减一
def delete(self, index):
    if self.isEmpty():
        print "this 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

    #prev为保存前导节点
    #node为保存当前节点
    #当j与index相等时就
    #相当于找到要删除的节点
    j = 0
    node = self.head
    prev = self.head
    while node._next and j < index:
        prev = node
        node = node._next
        j += 1

    if j == index:
        prev._next = node._next
        self.length -= 1

修改一个节点: update()

def update(self, index, data):
    if self.isEmpty() or 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

查找一个节点: getItem()

def getItem(self, index):
    if self.isEmpty() or 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

    return node.data

查找一个节点的索引: getIndex()

def getIndex(self, data):
    j = 0
    if self.isEmpty():
        print "this chain table is empty"
        return
    node = self.head
    while node:
        if node.data == data:
            return j
        node = node._next
        j += 1

    if j == self.length:
        print "%s not found" % str(data)
        return

插入一个节点: insert()

def insert(self, index, dataOrNode):
    if self.isEmpty():
        print "this chain tabale 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
    node = self.head
    prev = self.head
    while node._next and j < index:
        prev = node
        node = node._next
        j += 1

    if j == index:
        item._next = node
        prev._next = item
        self.length += 1

清空链表: clear()

def clear(self):
    self.head = None
    self.length = 0

以上就是链表类的要实现的方法。

执行的结果：

接下来是完整代码：

  1 # -*- coding:utf8 -*-
  2 #/usr/bin/env python
  3 
  4 class Node(object):
  5     def __init__(self, data, pnext = None):
  6         self.data = data
  7         self._next = pnext
  8 
  9     def __repr__(self):
 10         return str(self.data)
 11 
 12 class ChainTable(object):
 13     def __init__(self):
 14         self.head = None
 15         self.length = 0
 16 
 17     def isEmpty(self):
 18         return (self.length == 0)
 19 
 20     def append(self, dataOrNode):
 21         item = None
 22         if isinstance(dataOrNode, Node):
 23             item = dataOrNode
 24         else:
 25             item = Node(dataOrNode)
 26 
 27         if not self.head:
 28             self.head = item
 29             self.length += 1
 30 
 31         else:
 32             node = self.head
 33             while node._next:
 34                 node = node._next
 35             node._next = item
 36             self.length += 1
 37 
 38     def delete(self, index):
 39         if self.isEmpty():
 40             print "this chain table is empty."
 41             return
 42 
 43         if index < 0 or index >= self.length:
 44             print 'error: out of index'
 45             return
 46 
 47         if index == 0:
 48             self.head = self.head._next
 49             self.length -= 1
 50             return
 51 
 52         j = 0
 53         node = self.head
 54         prev = self.head
 55         while node._next and j < index:
 56             prev = node
 57             node = node._next
 58             j += 1
 59 
 60         if j == index:
 61             prev._next = node._next
 62             self.length -= 1
 63 
 64     def insert(self, index, dataOrNode):
 65         if self.isEmpty():
 66             print "this chain tabale is empty"
 67             return
 68 
 69         if index < 0 or index >= self.length:
 70             print "error: out of index"
 71             return
 72 
 73         item = None
 74         if isinstance(dataOrNode, Node):
 75             item = dataOrNode
 76         else:
 77             item = Node(dataOrNode)
 78 
 79         if index == 0:
 80             item._next = self.head
 81             self.head = item
 82             self.length += 1
 83             return
 84 
 85         j = 0
 86         node = self.head
 87         prev = self.head
 88         while node._next and j < index:
 89             prev = node
 90             node = node._next
 91             j += 1
 92 
 93         if j == index:
 94             item._next = node
 95             prev._next = item
 96             self.length += 1
 97 
 98     def update(self, index, data):
 99         if self.isEmpty() or index < 0 or index >= self.length:
100             print 'error: out of index'
101             return
102         j = 0
103         node = self.head
104         while node._next and j < index:
105             node = node._next
106             j += 1
107 
108         if j == index:
109             node.data = data
110 
111     def getItem(self, index):
112         if self.isEmpty() or index < 0 or index >= self.length:
113             print "error: out of index"
114             return
115         j = 0
116         node = self.head
117         while node._next and j < index:
118             node = node._next
119             j += 1
120 
121         return node.data
122 
123 
124     def getIndex(self, data):
125         j = 0
126         if self.isEmpty():
127             print "this chain table is empty"
128             return
129         node = self.head
130         while node:
131             if node.data == data:
132                 return j
133             node = node._next
134             j += 1
135 
136         if j == self.length:
137             print "%s not found" % str(data)
138             return
139 
140     def clear(self):
141         self.head = None
142         self.length = 0
143 
144     def __repr__(self):
145         if self.isEmpty():
146             return "empty chain table"
147         node = self.head
148         nlist = ''
149         while node:
150             nlist += str(node.data) + ' '
151             node = node._next
152         return nlist
153 
154     def __getitem__(self, ind):
155         if self.isEmpty() or ind < 0 or ind >= self.length:
156             print "error: out of index"
157             return
158         return self.getItem(ind)
159 
160     def __setitem__(self, ind, val):
161         if self.isEmpty() or ind < 0 or ind >= self.length:
162             print "error: out of index"
163             return
164         self.update(ind, val)
165 
166     def __len__(self):
167         return self.length

python链表

作者：陈栋权

时间：2016/09/19

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，

且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。

如有特别用途，请与我联系邮箱：kingchen.gd@foxmail.com

最后有兴趣的同学可以关注我的微信公众号，可以随时及时方便看我的文章。*^_^*

扫码关注或者搜索微信号：King_diary