Python 데이터 구조 와 알고리즘 의 링크 정의 와 용법 인 스 턴 스 상세 설명[단일 링크,순환 링크]

본 논문 의 사례 는 Python 데이터 구조 와 알고리즘 의 링크 정의 와 용법 을 서술 하 였 다.여러분 께 참고 하도록 공유 하 겠 습 니 다.구체 적 으로 는 다음 과 같 습 니 다.
본문 은 모두 에 게 설명 할 것 이다.
(1)링크 노드 의 정의 부터 유형 적 인 방식 으로 대상 을 대상 으로 하 는 사상 으로 링크 디자인 을 한다.
(2)링크 클래스 삽입 과 삭제 등 구성원 함수 가 실 현 될 때 고려 해 야 할 경계 조건,
prepend(머리 삽입),pop(머리 삭제),append(꼬리 삽입),poplast(끝 부분 삭제)
2.1 삽입:
에 어 링크
링크 길이 1
끝까지 삽입
2.2 삭제
에 어 링크
링크 길이 1
끝 요소 삭제
(3)단일 체인 테이블 에서 단일 체인 테이블 로 의 변형:
꼬리 노드 가 있 는 싱글 체인 시트
순환 싱글 체인 테이블
더 블 링크
1.링크 노드 의 정의

class LNode:
 def __init__(self, elem, next_=None):
  self.elem = elem
  self.next = next_

2.싱글 체인 시트 의 실현
삽입,삭제 의 실현 과 고려 해 야 할 경계 조건 을 중점적으로 이해 합 니 다.

class LinkedListUnderflow(ValueError):
 pass
class LList:
 def __init__(self):
  self._head = None
 def is_empty(self):
  return self._head is None
 def prepend(self, elem):
  self._head = LNode(elem, self._head)
 def pop(self):
  if self._head is None:
   raise LinkedListUnderflow('in pop')
  e = self._head.elem
  self._head = self._head.next
  return e
 def append(self, elem):
  if self._head is None:
   self._head = LNode(elem)
   return
  p = self._head
  while p.next is not None:
   p = p.next
  p.next = LNode(elem)
 def pop_last(self):
  if self._head is None:
   raise LinkedListUnderflow('in pop_last')
  p = self._head
  if p.next is None:
   e = p.elem
   self._head = None
   return e
  while p.next.next is not None:
   p = p.next
  e = p.next.elem
  p.next = None
  return e

간단 한 요약:
(0)p.next.next 에 접근 할 수 있 는 전 제 는 p.next 가 비어 있 지 않다 는 것 이다.
(1)꼬리 부분 을 삽입 합 니 다.만약 에 링크 가 비어 있 지 않 으 면 꼬리 부분 노드 의 지침 만 바 꿔 야 합 니 다.
(2)꼬리 부분 을 삭제 합 니 다.링크 길이 가 비어 있 지 않 으 면 마지막 두 번 째 노드 의 지침 만 바 꿔 야 합 니 다.
싱글 체인 시트 의 간단 한 변형:꼬리 노드 를 가 진 싱글 체인 시트

class LList1(LList):
 def __init__(self):
  LList.__init__(self)
  self._rear = None
 ...

우 리 는 머리 삽입,꼬리 삽입,꼬리 삭제 만 다시 써 야 합 니 다.

def prepend(self, elem):
 if self._head is None:
  self._head = LNode(elem)
  self._rear = self._head
 else:
  self._head = LNode(elem, self._head)
def append(self, elem):
 if self._head is None:
  self._head = LNode(elem)
  self._rear = self._head
 else:
  self._rear.next = LNode(elem)
  self._rear = self._rear.next
def pop_last(self):
 if self._head is None:
  raise LinkedListUnderflow('in pop_last')
 p = self._head
 if p.next is None:
  e = p.elem
  self._head = None
  return e
 while p.next.next is not None:
  p = p.next
 e = p.next.elem
 self._rear = p
 p.next = None
 return e

싱글 체인 시트 의 변형:순환 싱글 체인 시트

class LCList:
 def __init__(self):
  self._rear = None
 def prepend(self, elem):
  if self._rear is None:
   self._rear = LNode(elem)
   self._rear.next = self._rear
  else:
   self._rear.next = LNode(elem, self._rear.next)
 def append(self, elem):
  self.prepend(elem)
  self_rear = self._rear.next
 def pop(self):
  if self._rear is None:
   raise LinkedListUnderflow('in pop')
  p = self._rear.next
  if p is None:
   self._rear = None
  else:
   self._rear.next = p.next
  return p.elem
 def printall(self):
  if self._rear is None:
   raise ...
  p = self._rear.next
  while True:
   print(p.elem)
   if p is self._rear:
    break
   p = p.next

더 많은 파 이 썬 관련 내용 은 본 사이트 의 주 제 를 볼 수 있 습 니 다.
본 논문 에서 말 한 것 이 여러분 의 Python 프로 그래 밍 에 도움 이 되 기 를 바 랍 니 다.