线性结构

lynn_1900

于 2020-06-21 11:24:35 发布

阅读量87

点赞数

分类专栏：数据结构文章标签：链表队列列表 stack

本文链接：https://blog.csdn.net/lynn_1900/article/details/106883161

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

1 线性结构
2 应用

1 线性结构

1.1 栈

# 创建栈
class Stack:
    def __init__(self):
        self.items = []
        
    def isEmpty(self):
        return self.items == []
        
    def push(self, item):
        return self.items.append(item)
        
    def pop(self):
        return self.items.pop()
        
    def top(self):
        return self.items[-1]
        
    def size(self):
        return len(self.items)

1.2 队列

# 创建队列——左边队尾,右边队首
class Queue():

    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

    def size(self):
        return len(self.items)

    def enqueue(self,item):
        return self.items.insert(0, item)

    def dequeue(self):
        return self.items.pop()

1.3 双端队列

# 定义双端队列——左边队尾，右边队首
class Deque:

    def __init__(self):
        self.items = []

    def isEmpty(self):
        return self.items == []

    def size(self):
        return len(self.items)

    def addRear(self, item):
        return self.items.insert(0, item)

    def addFront(self, item):
        return self.items.append(item)

    def removeRear(self):
        return self.items.pop(0)

    def removeFront(self):
        return self.items.pop()

1.4 链表

# 定义节点
class Node:
    def __init__(self, initdata):
        self.data = initdata
        self.next = None

    def getNode(self):
        return self.data

    def getNext(self):
        return self.next

    def setNode(self, newnode):
        self.data = newnode

    def setNext(self, newnext):
        self.next = newnext


class UnOrderedList:
	"""无序链表"""
    def __init__(self):
        self.head = None

    def isEmpty(self):
        return self.head == None

    def add(self, item):
        temp = Node(item)
        temp.setNext(self.head)
        self.head = temp

    def size(self):
        current = self.head
        count = 0
        while current != None:
            count += 1
            current = current.getNext()
        return count

    def search(self, item):
        current = self.head
        found = False
        while current != None and not found:
            if current == item:
                found = True
            else:
                current = current.getNext()
        return found

    def remove(self, item):
        current = self.head
        previous = None
        found = False
        while not found:
            if current.getData() == item:
                found = True
            else:
                current = current.getNext()
                previous = previous.getNext()
        if previous == None:  # 判断匹配的是不是第一个节点
            self.head = item.getNext()
        else:
            previous.setNext(item.getNext())

class OrderedList:
	"""有序链表"""
    def __init__(self):
        self.head = None

    # isEmpty、size、remove这些方法和节点的次序无关，所以和UnOrderedList一样
    def isEmpty(self):
        return self.head == None

    def size(self):
        current = self.head
        count = 0
        while current != None:
            count += 1
            current = current.getNext()
        return count

    def remove(self, item):
        current = self.head
        previous = None
        found = False
        while not found:
            if current.getData == item:
                found = True
            else:
                current = current.getNext()
                previous = previous.getNext()
        if previous == None:
            self.head = current.getNext()
        else:
            previous.setNext(current.getNext())
        return self

    def serach(self, item):
        current = self.head
        found = False
        stop = False
        while current != None and not found and not stop:
            if current.getData() == item:
                found = True
            elif current.getData() > item:
                stop = True
            else:
                current = current.getNext()
        return found

    def add(self, item):
        current = self.head
        previous = None
        stop = False
        while current != None and not stop:
            if current.getData() > item:
                stop = True
            else:
                current = current.getNext()
                previous = previous.getNext()
        temp = Node(item)
        temp.setNext(current)
        if previous == None:
            self.head = temp
        else:
            previous.setNext(temp)

2 应用

2.1 回文词

from myDeque import Deque

def palchecker(aString):
    chardeque = Deque()

    for ch in aString:
        chardeque.addRear(ch)

    stillEqual = True

    while chardeque.size() > 1:
        first = chardeque.removeFront()
        last = chardeque.removeRear()
        if first != last:
            stillEqual = False

    return stillEqual

2.2 热土豆问题

from myQueue import Queue

def hotPotato(nameList, num):

    simqueue = Queue()

    for name in nameList:
        simqueue.enqueue(name)

    while simqueue.size() > 1:
        for i in range(num):
            simqueue.enqueue(simqueue.dequeue())
        simqueue.dequeue()     # 拿到热土豆的人剔除

    return simqueue.dequeue()

print(hotPotato(['Bill','David','Susan','Jane','Kent','Brad'],7))

2.3 括号

from myStack import Stack

# 检查括号是否匹配
# 依次检查符号串，如果是左括号：则放进栈里；如果是右括号：检查栈顶是否为相应的左括号，如果是则消掉。
def checker(symbolString):
    s = Stack()
    dict = {'(': ')', '[': ']', '{': '}'}
    for symbol in symbolString:
        if symbol in dict.keys():
            s.push(symbol)
        else:
            if (not s.isEmpty()) and dict[s.top()] == symbol:
                s.pop()
            else:
                return False
    if s.isEmpty():
        return True
    else:
        return False

2.4 进制转换

from myStack import Stack

# 十进制转换为二进制
# 233 / 2 = 116...1，116 / 2 = 58...0，58 / 2 = 29...0，29 / 2 = 14...1，
# 14 / 2 = 7...0，7 / 2 = 3...1，3 / 2 = 1...1，1 / 2 =0...1
# 因此 233(十进制) = 11101001(二进制)(余数反转)
# 1 * 2^7 + 1 * 2^6 + 1 * 2^5 + 0 * 2^4 + 1 * 2^3 + 0 * 2^2 + 0 * 2^1 + 1 * 2^0 = 233
# 因此 11101001(二进制) = 233(十进制)
def ten2two(num):
    remainder = Stack()
    while num:
        remainder.push(num % 2)
        num = num // 2
    result = ''
    while not remainder.isEmpty():
        result = result + str(remainder.pop())
    print(result)

# 十进制转换为八进制
def ten2eight(num):
    remainder = Stack()
    while num:
        remainder.push(num % 8)
        num = num // 8
    result = ''
    while not remainder.isEmpty():
        result = result + str(remainder.pop())
    print(result)

# 十进制转换为16进制
def ten2sixteen(num):
    index = '0123456789ABCDEF'
    remainder = Stack()
    while num:
        remainder.push(num % 16)
        num = num // 16
    result = ''
    while not remainder.isEmpty():
        result = result + index[remainder.pop()]
    print(result)

2.5 表达式转换

from myStack import Stack

# 中缀表达式转后缀表达式
# 从左到右扫描中缀表达式
# 如果是操作数，则直接添加到后缀表达式列表的末尾
# 如果是左括号，则压入栈顶
# 如果是右括号，则反复弹出栈顶操作符，加入到输出列表末尾，直到碰到左括号，
# 如果是操作符，则压入栈顶
#   但在压入之前要比较其与栈顶操作符的优先级，
#   如果栈顶高于或等于就要反复弹出栈顶操作符，加入到输出列表末尾，
#   直到栈顶优先级低于它。
def infixToPostfix(infixexpr):
    tokenList = list(infixexpr)
    prec = {"(": 1, "+": 2, "-": 2, "*": 3, "/": 3}
    opStack = Stack()
    postfixList = []
    for token in tokenList:
        if token in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' or token in '0123456789':
            postfixList.append(token)
        elif token == '(':
            opStack.push(token)
        elif token == ')':
            while opStack.top() != '(':
                postfixList.append(opStack.pop())
            opStack.pop()
        else:
            while (not opStack.isEmpty()) and prec[opStack.top()] >= prec[token]:
                postfixList.append(opStack.pop())
            opStack.push(token)
    while not opStack.isEmpty():
        postfixList.append(opStack.pop())
    return ''.join(postfixList)

# 后缀表达式求值
# 从左到右扫描后缀表达式
# 如果是一个操作数，转化为int，压入栈顶
# 如果是一个操作符，就开始求值，从栈顶弹出两个数，先弹出的是右操作数，后弹出的是左操作数，计算结果
# 扫描结束，栈内只剩一个值就是后缀表达式的计算结果
def postfixEval(postfixexpr):
    operandStack = Stack()
    tokenList = list(postfixexpr)
    for token in tokenList:
        if token in '0123456789':
            operandStack.push(int(token))
        else:
            operand2 = operandStack.pop()
            operand1 = operandStack.pop()
            result = doMath(token, operand1, operand2)
            operandStack.push(result)
    return operandStack.pop()

def doMath(op, op1, op2):
    if op == '+':
        return op1 + op2
    elif op == '-':
        return op1 - op2
    elif op == '*':
        return op1 * op2
    elif op == '/':
        return op1 / op2

lynn_1900

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线性结构

文章目录1 线性结构1.1 栈1.2 队列1.3 双端队列1.4 链表2 应用2.1 回文词2.2 热土豆问题2.3 括号2.4 进制转换2.5 表达式转换1 线性结构1.1 栈# 创建栈class Stack: def __init__(self): self.items = [] def isEmpty(self): return self.items == [] def push(self, item)
复制链接

扫一扫