Python笔记之 的链表基本操作

#!/usr/bin/python
# -*- coding: utf-8 -*-

# 链表的话就有data存放数据，next指向下一个data
class Node(object):  # 节点类
    def __init__(self, data):
        self.data = data
        self.pnext = None

    def __repr__(self):  # 用来打印节点
        return str(self.data)


class LinkTable(object):  # 链表类
    def __init__(self):
        self.head = None
        self.length = 0

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

    def append(self, node_data):  # 这是用来创建链表的,(在链表末添加对象)
        if isinstance(node_data, Node):
            pass
        else:
            node_data = Node(node_data)  # 把node_data封装成一个带有一个pnext=None的节点对象

        if self.isEmpty():  # 如果链表为空
            self.head = node_data
        else:
            node = self.head
            while node.pnext:  # 通过遍历找到最末端节点，最末端节点的pnext一定是None
                node = node.pnext
            node.pnext = node_data
        self.length += 1

    def insert(self, node_data, index):
        if type(index) is int:
            if isinstance(node_data, Node):
                pass
            else:
                node_data = Node(node_data)
            if self.isEmpty():
                self.head = node_data
                print u'此为空链表，只能插入在表头！'
                return
            elif index > self.length or index < 0:
                print u'索引越界！'
                return
            else:
                if index == 0:
                    node_data.pnext = self.head
                    self.head = node_data
                else:
                    i = 0
                    node = self.head
                    while i < index - 1:
                        node = node.pnext
                        i += 1
                    node_data.pnext = node.pnext
                    node.pnext = node_data
                self.length += 1
                return

        else:
            print u'索引值非整型数字！'
            return

    def delete(self, index):
        if type(index) is int:

            if self.isEmpty():
                print u'此为空链表，无法删除！'
                return
            elif index > self.length or index < 0:
                print u'索引越界！'
                return
            else:
                if index == 0:
                    self.head = self.head.pnext
                else:
                    i = 0
                    node = self.head
                    while i < index - 1:
                        node = node.pnext
                        i += 1
                    node.pnext = node.pnext.pnext
                self.length -= 1
            return
        else:
            print u'索引值非整型数字！'
            return

    def update(self, new_data, index):
        if type(index) is int:
            if isinstance(new_data, Node):
                pass
            else:
                new_data = Node(new_data)
            if self.isEmpty():
                print u'此为空链表，无法更新！'
                return
            elif index > self.length or index < 0:
                print u'索引越界！'
                return
            else:
                if index == 0:
                    new_data.pnext = self.head.pnext
                    self.head = new_data
                    return
                else:
                    i = 0
                    node = self.head
                    while i < index - 1:
                        node = node.pnext  # 找到需要更新点
                        i += 1
                    new_data.pnext = node.pnext.pnext
                    node.pnext = new_data
                    return
        else:
            print u'索引值非整型数字！'
            return

    def get_value(self, index):
        if type(index) is int:
            if self.isEmpty():
                print u'此为空链表，无法取值！'
                return
            elif index > self.length or index < 0:
                print u'索引越界！'
                return
            else:
                i = 0
                node = self.head
                while i < index:
                    node = node.pnext
                    i += 1
                if node:
                    return node.data
                else:
                    return

        else:
            print u'索引值非整型数字！'
            return

    def get_all_value(self):
        node = self.head
        while node:
            print node.data
            #yield node.data
            node = node.pnext

    def clear(self):
        '''
        # 就是重新初始化一下
        :return:
        '''
        self.head = None
        self.length = 0
        print u'链表已经清空！'

    def end_to_begin_linktable(self):  # 从头到尾打印链表
        if not self.isEmpty():
            result = []
            node = self.head
            while node:
                result.insert(0, node.data)
                node = node.pnext
            return result
        else:
            print u'此为空链表！'
            return []

    def from_end_k(self, k):  # 返回倒数第K个元素
        if not self.isEmpty():
            if k > self.length or k <= 0:
                print u'k值越界！'
                return
            else:
                i = 0
                node_1 = self.head
                node_2 = self.head
                while i < self.length:
                    if i > k - 1:
                        node_2 = node_2.pnext
                    node_1 = node_1.pnext
                    i += 1
                return node_2.data
        else:
            print u'此为空链表！'
            return

    def return_mid_elem(self):  # 一次遍历返回中间元素
        if not self.isEmpty():
            if self.length % 2 == 0:
                return
            else:
                node_1 = self.head
                node_2 = self.head
                while node_1.pnext:
                    node_1 = node_1.pnext
                    node_2 = node_2.pnext
                    if node_1:
                        node_1 = node_1.pnext
                return node_2.data
        else:
            print u'此为空链表！'
            return

    def delete_same_node(self):  # 集合法
        if self.isEmpty():
            print u'此为空链表，无法删除！'
            return
        else:
            data_set=set()
            node = self.head
            tmp = self.head
            while node:
                if node.data in data_set:
                    tmp.pnext = node.pnext
                    node = node.pnext
                else:
                    data_set.add(node.data)
                    tmp = node
                    node = node.pnext

    def delete_same_node_2(self):  # 双重遍历法
        if self.isEmpty():
            print u'此为空链表，无法删除！'
            return
        else:
            node_1 = self.head
            while node_1:
                node_2 = node_1.pnext
                tmp = node_1
                while node_2:
                    if node_2.data == node_1.data:
                        tmp.pnext = node_2.pnext
                        node_2 = node_2.pnext
                    else:
                        tmp = node_2
                        node_2 = node_2.pnext
                node_1 = node_1.pnext

    def reversal_linktable(self): #反转链表，指针方向改变(迭代的方式)
        if not self.isEmpty():
            node = self.head
            last = None
            while node:
                tmp = node.pnext
                node.pnext = last
                last = node
                node = tmp
            print last.data
        else:
            print u'此为空链表！'
            return

    def create_circle_linktable(self,sum_node,circle_node):  # 创建带环链表并查找环的入口
        '''
        :param sum_node: 总结点数
        :param circle_node: 环节点数
        :return: 入口节点位置
        '''
        self.head = Node(0)
        self.length += 1
        node = self.head
        tmp = self.head
        for i in range(1,sum_node):
            new_node = Node(i)
            node.pnext = new_node
            node = new_node
            if i == sum_node-circle_node:
                tmp = new_node
            self.length+=1
        node.pnext = tmp
        count_node_1 = self.head
        count_node_2 = self.head
        while count_node_1:
            count_node_1 = count_node_1.pnext.pnext
            count_node_2 = count_node_2.pnext
            if count_node_2 == count_node_1:
                print u'存在环!'
                break
        i = 1
        count_node_2 = count_node_2.pnext   #  找环节点的个数
        while count_node_1 != count_node_2:
            count_node_2 = count_node_2.pnext
            i +=1
        print u'环的节点数：',i

        find_node_1 = self.head
        find_node_2 = self.head
        j=0
        while j < i:
            find_node_1 = find_node_1.pnext
            j+=1
        k=0
        while find_node_1 != find_node_2:
            find_node_1 = find_node_1.pnext
            find_node_2 = find_node_2.pnext
            k+=1
        print u'入口节点为：',k

def sort_two_linktable(linktable_1,linktable_2): # 合并两个有序链表(递增)
    if linktable_1.isEmpty() and not linktable_2.isEmpty():
        return linktable_2
    elif linktable_2.isEmpty() and not linktable_1.isEmpty():
        return linktable_1
    elif linktable_2.isEmpty() and linktable_1.isEmpty():
        return
    else:
        new_linktable = LinkTable()
        node_1 = linktable_1.head
        node_2 = linktable_2.head
        for i in range(linktable_1.length+linktable_2.length+1):
            if node_1 and node_2:
                if node_1.data <= node_2.data:
                    new_linktable.append(node_1.data)
                    node_1 = node_1.pnext
                else:
                    new_linktable.append(node_2.data)
                    node_2 = node_2.pnext
            elif node_1 and not node_2:
                new_linktable.append(node_1.data)
                node_1 = node_1.pnext
            elif not node_1 and node_2:
                new_linktable.append(node_2.data)
                node_2 = node_2.pnext
            else:
                return new_linktable
def punlic_node(linktable_1,linktable_2): #两个链表的公共节点
    linktable_1 = LinkTable()
    linktable_2 = LinkTable()
    if linktable_1.length == linktable_2.length:
        node_1 = linktable_1.head
        node_2 = linktable_2.head
        while node_1:
            if node_1 == node_2:
                return node_1
            else:
                node_1 = node_1.pnext
                node_2 = node_2.pnext
        return None
    else:
        node_1 = linktable_1.head
        node_2 = linktable_2.head  # 是稍长的链表
        while node_2:
            node_1 = node_1.pnext
            node_2 = node_2.pnext
            if not node_1:
                node_1 = linktable_2.head
        node_2 = linktable_1.head
        while node_1:
            if node_1 == node_2:
                return node_1
            else:
                node_1 = node_1.pnext
                node_2 = node_2.pnext
        return None

test_lt = LinkTable()

test_lt.create_circle_linktable(150,23)