数据结构--链表

最新推荐文章于 2022-03-12 21:47:29 发布

bufengzj

最新推荐文章于 2022-03-12 21:47:29 发布

阅读量212

点赞数

分类专栏：数据结构 python

python 同时被 2 个专栏收录

28 篇文章

订阅专栏

数据结构

7 篇文章

订阅专栏

1. 链表的基本知识与python实现

[ 转载自： https://www.cnblogs.com/kumata/p/9147077.html ]

链表(Linked List)

很多的教材都是用C语言实现链表，因为c有指针，可以很方便的控制内存，很方便就实现链表，其他的语言，则没那么方便，由于python是动态语言，可以直接把对象赋值给新的变量，于是在python一切皆为对象的原理上实现链表的各项操作。

在实现链表python类的属性和方法操作之前，先整理一些链表的理论知识。

一、链表的基本结构

链表是通过一个个节点（Node）组成的，每个节点都包含了称为数据域(value)和指针域(next)的基本单元，它也是一种递归的数据结构。它能保持数据之间的逻辑顺序，但存储空间不必按照顺序存储。

链表的基本元素有：

节点：每个节点有两个部分，左边部分称为值域，用来存放用户数据；右边部分称为指针域，用来存放指向下一个元素的指针。
head:head节点永远指向第一个节点
tail: tail永远指向最后一个节点
None:链表中最后一个节点的指针域为None值

二、链表的种类以及和动态数组(Array List)的对比

三、单向链表属性与各类操作方法代码

#coding:utf-8
#先定一个node的类
class Node():                  #value + next
    def __init__ (self, value = None, next = None):
        self._value = value
        self._next = next

    def getValue(self):
        return self._value

    def getNext(self):
        return self._next

    def setValue(self,new_value):
        self._value = new_value

    def setNext(self,new_next):
        self._next = new_next

#实现Linked List及其各类操作方法
class LinkedList():
    def __init__(self):      #初始化链表为空表
        self._head = Node()
        self._tail = None
        self._length = 0

    #检测是否为空
    def isEmpty(self):
        return self._head == None

    #add在链表前端添加元素:O(1)
    def add(self,value):
        newnode = Node(value,None)    #create一个node（为了插进一个链表）
        newnode.setNext(self._head)
        self._head = newnode
        self._length=self._length+1

    #append在链表尾部添加元素:O(n)
    def append(self,value):
        newnode = Node(value)
        self._length = self._length + 1
        if self.isEmpty():
            self._head = newnode   #若为空表，将添加的元素设为第一个元素
        else:
            current = self._head
            while current.getNext() != None:
                current = current.getNext()   #遍历链表
            current.setNext(newnode)   #此时current为链表最后的元素

    #search检索元素是否在链表中
    def search(self,value):
        current=self._head
        foundvalue = False
        while current != None and not foundvalue:
            if current.getValue() == value:
                foundvalue = True
            else:
                current=current.getNext()
        return foundvalue

    #index索引元素在链表中的位置
    def index(self,value):
        current = self._head
        count = 0
        found = None
        while current != None and not found:
            count += 1
            if current.getValue()==value:
                found = True
            else:
                current=current.getNext()
        if found:
            return count
        else:
            raise ValueError ('%s is not in linkedlist'%value)

    #remove删除链表中的某项元素
    def remove(self,value):
        current = self._head
        self._length = self._length - 1
        pre = None
        while current!=None:
            if current.getValue() == value:
                if not pre:
                    self._head = current.getNext()
                else:
                    pre.setNext(current.getNext())
                break
            else:
                pre = current
                current = current.getNext()

    #insert链表中插入元素
    def insert(self,pos,value):
        self._length = self._length + 1
        if pos <= 1:
            self.add(value)
        elif pos > self.size():
            self.append(value)
        else:
            temp = Node(value)
            count = 1
            pre = None
            current = self._head
            while count < pos:
                count += 1
                pre = current
                current = current.getNext()
            pre.setNext(temp)
            temp.setNext(current)
#测试：
A=LinkedList()
A.add(4)
A.add(3)
A.append(5)
A.remove(5)
print(A._length)
print(A._head.getValue())

四、操作链表的原理知识

1.遍历链表

链表的基本操作：遍历next节点

在列表中查找一个元素
在列表中插入一个元素
从列表中删除一列元素

不可以用head来遍历列表

否则会丢失列表的一些节点
可以使用和head相同类型的索引变量：current

2.插入

3.删除

4.双向链表

5.循环链表

书籍资料：

1.《数据结构（Python语言描述）》

2. 链接：https://blog.youkuaiyun.com/su_bao/article/details/81065746

注意：

python一切皆为对象，那么对一个变量赋值4，那么4就有对应的变量地址

a=3
print(id(a))
print(id(3))

#输出：
10919392
10919392

所以python里的链表的next地址可以是 下一个变量。
python一切均为对象，对象便有 身份（id),值，类型

题目：

题目描述

输入一个链表，反转链表后，输出新链表的表头。

答案1：

思路很简单：1->2->3->4->5，遍历链表，把1的next置为None，2的next置为1，以此类推，5的next置为4。得到反转链表。需要考虑链表只有1个元素的情况。图中有具体的每步迭代的思路，最后输出pre而不是cur是因为最后一次迭代后cur已经指向None了，而pre是完整的反向链表。

来自：https://www.nowcoder.com/questionTerminal/75e878df47f24fdc9dc3e400ec6058ca