【数据结构】数组和链表_1,2天

【数组】

实现一个支持动态扩容的数组

class Arr:
	def __init__(self, capacity=10):
        self._capacity = capacity
        self._size = 0                                  
        self._data = [None] * self._capacity    
 
    def __getitem__(self, item):

        return self._data[item]
 
    def getSize(self):

        return self._size
 
    def getCapacity(self):

        return self._capacity
 
    def isEmpty(self):

        return self._size == 0
 
    def add(self, index, elem):

        if index < 0 or index > self._size:     
            raise Exception('Add Filed. Require
        if self._size == self._capacity:        
            self._resize(self._capacity * 2)    
 
        for i in range(self._size - 1, index - 1, -1):  
            self._data[i + 1] = self._data[i]
        self._data[index] = elem       
        self._size += 1                 
 
    def addLast(self, elem):

        self.add(self._size, elem) 
 
    def addFirst(self, elem):

        self.add(0, elem)   
 
    def get(self, index):

        if index < 0 or index >= self._size:       
            raise Exception('Get failed. Index is illegal.')
        return self._data[index]
 
    def getFirst(self):

        return self.get(0)     
 
    def getLast(self):

        return self.get(self._size - 1)  
 
    def set(self, index, elem):
        if index < 0 or index >= self._size:       
            raise Exception('Sat failed. Index is illegal.')
        self._data[index] = elem
 
    def contains(self, elem):
        for i in range(self._size):        
            if self._data[i] == elem:
                return True                
        return False                     
 
    def find(self, elem):
        for i in range(self._size):         
            if self._data[i] == elem:
                return i                   
        return -1                          
 
    def findAll(self, elem):

        ret_list = Arr()               
        for i in range(self._size):     
            if self._data[i] == elem:
                ret_list.addLast(i)    
        return ret_list
 
    def remove(self, index):
        if index < 0 or index >= self._size:    
            raise Exception('Remove failed.Require 0 <= index < self._size')
        ret = self._data[index]                
        for i in range(index + 1, self._size): 
            self._data[i - 1] = self._data[i]
        self._size -= 1         
        self._data[self._size] = None   
 
        if self._size and self._capacity // self._size == 4:   
            self._resize(self._capacity // 2)
        return ret
 
    def removeFirst(self):

        return self.remove(0)   
 
    def removeLast(self):

        return self.remove(self._size - 1)      
 
    def removeElement(self, elem):

        index = self.find(elem)        
        if index != -1:               
            self.remove(index)          
 
    def removeAllElement(self, elem):
        while True:
            index = self.find(elem)     
            if index != -1:             
                self.remove(index)
            else:
                break
 
    def get_Max_index(self):

        if self.isEmpty():
            raise Exception('Error, array is Empty!')
        max_elem_index = 0   
        for i in range(1, self.getSize()):   
            if self._data[i] > self._data[max_elem_index]:  
                max_elem_index = i    
        return max_elem_index   
 
    def removeMax(self):

        return self.remove(self.get_Max_index())   
 
    def get_Min_index(self):
        if self.isEmpty():
            raise Exception('Error, array is Empty!')
        min_elem_index = 0   
        for i in range(1, self.getSize()):   
            if self._data[i] < self._data[min_elem_index]:  
                min_elem_index = i    
        return min_elem_index    
 
    def removeMin(self):

        return self.remove(self.get_Min_index())
 
    def swap(self, index1, index2):

        if index1 < 0 or index2 < 0 or index1 >= self._size or index2 >= self._size:        
            raise Exception('Index is illegal')
        self._data[index1], self._data[index2] = self._data[index2], self._data[index1]   
 
    def printArr(self):

        for i in range(self._size):
            print(self._data[i], end='  ')
        print('\nSize: %d-----Capacity: %d' % (self.getSize(), self.getCapacity()))
 
    def _resize(self, new_capacity):

        new_arr = Arr(new_capacity)         
        for i in range(self._size):
            new_arr.addLast(self._data[i])  
        self._capacity = new_capacity      
        self._data = new_arr._data          

• 实现一个大小固定的有序数组，支持动态增删改操作

class MyArray:
    """A simple wrapper around List.
    You cannot have -1 in the array.
    """
 
    def __init__(self, capacity: int):
        self._data = []
        self._capacity = capacity
 
    def __getitem__(self, position: int) -> object:
        return self._data[position]
 
    def __setitem__(self, index: int, value: object):
        self._data[index] = value
 
    def __len__(self) -> int:
        return len(self._data)
 
    def __iter__(self):
        for item in self._data:
            yield item
 
    def find(self, index: int) -> object:
        try:
            return self._data[index]
        except IndexError:
            return None
 
    def delete(self, index: int) -> bool:
        try:
            self._data.pop(index)
            return True
        except IndexError:
            return False
 
    def insert(self, index: int, value: int) -> bool:
        if len(self) >= self._capacity:
            return False
        else:
            return self._data.insert(index, value)
 
    def print_all(self):
        for item in self:
            print(item)
 
 
def test_myarray():
    array = MyArray(5)
    array.insert(0, 3)
    array.insert(0, 4)
    array.insert(1, 5)
    array.insert(3, 9)
    array.insert(3, 10)
    assert array.insert(0, 100) is False
    assert len(array) == 5
    assert array.find(1) == 5
    assert array.delete(4) is True
    array.print_all()

• 实现两个有序数组合并为一个有序数组
  def merge_sort(a, b):
  ret = []
  i = j = 0
  while len(a) >= i + 1 and len(b) >= j + 1:
  if a[i] <= b[j]:
  ret.append(a[i])
  i += 1
  else:
  ret.append(b[j])
  j += 1
  if len(a) > i:
  ret += a[i:]
  if len(b) > j:
  ret += b[j:]
  return ret

if name == ‘main’:
a = [1,3,4,6,7,78,97,190]
b = [2,5,6,8,10,12,14,16,18]
print(merge_sort(a, b))

Three Sum（求三数之和）
class Solution(object):
def threeSum(self, nums):
“”"
:type nums: List[int]
:rtype: List[List[int]]
“”"
nums.sort()
result = []
lenn = len(nums)
for i in range(lenn-2):
if i > 0 and nums[i] == nums[i-1]:
continue
l, r = i+1, lenn - 1
while l < r:
s = nums[i] + nums[l] + nums[r]
if s < 0:
l += 1
elif s > 0:
r -= 1
else:
result.append([nums[i], nums[l], nums[r]])
while l < r and nums[l] == nums[l+1]:
l += 1
while l < r and nums[r] == nums[r-1]:
r -= 1
l, r = l+1, r-1
return result

Majority Element（求众数）

class Solution(object):
    def majorityElement(self, nums):
        res=set(nums)
        n=len(nums)/2
        for item in res:
            if(nums.count(item)>n):
                return item

Missing Positive（求缺失的第一个正数）

class Solution:
    def firstMissingPositive(self, nums):
 
        n, i = len(nums), 0
        if n == 0: 
            return 1
 
        while i < n:
            w = nums[i] - 1  
            if 0 < nums[i] <= n and nums[i] != nums[w]:  
                nums[i], nums[w] = nums[w], nums[i]       
            else:
                i += 1  
 
        for i in range(n):  
            if i + 1 != nums[i]:
                return i + 1
        return n + 1
 
if __name__ == '__main__':
    nums = [7, 8, 9, 11, 12]
    solu = Solution()
    print(solu.firstMissingPositive(nums))

【链表】

• 实现单链表、循环链表、双向链表，支持增删操作
  单链表

class Node(object):
    def __init__(self, elem):
        self.elem = elem
        self.next = None
 
 
class SingleLinkList(object):
    def __init__(self, node=None):
      
        self.__head = node
 
    def is_empty(self):
        return self.__head is None
 
    def length(self):
        cur = self.__head
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count
 
    def travel(self):
        cur = self.__head
        while cur != None:
            print(cur.elem, end=" ")
            cur = cur.next
        print("")
 
    def add(self, item):
        node = Node(item)
        node.next = self.__head
        self.__head = node
 
    def append(self, item):
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next
            cur.next = node
 
    def insert(self, pos, item):
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            pre = self.__head
            count = 0
            while count < (pos-1):
                count += 1
                pre = pre.next
            node.next = pre.next
            pre.next = node
 
    def remove(self, item):
        pre = self.__head
 
        if pre == None:
            return False
        elif pre.elem == item:
            self.__head = pre.next
            return True
        else:
            while pre.next != None:
                if pre.next.elem == item:
                    pre.next = pre.next.next
                    return True
                else:
                    pre = pre.next
            return False

单向循环链表

class Node(object):
    def __init__(self, elem):
        self.elem = elem
        self.next = None
 
 
class SingleLinkList(object):
    def __init__(self, node=None):
        self.__head = node
        if node != None:
            node.next = node
 
    def is_empty(self):
        return self.__head is None
 
    def length(self):
        if self.is_empty():
            return 0
        cur = self.__head
        count = 1
        while cur.next != self.__head:
            count += 1
            cur = cur.next
        return count
 
    def travel(self):
        cur = self.__head
        if cur == None:
            return
        else:
            while cur.next != self.__head:
                print(cur.elem, end=" ")
                cur = cur.next
            print(cur.elem)
 
    def add(self, item):
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = self.__head
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            node.next = self.__head
            self.__head = node
            cur.next = node
 
    def append(self, item):
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            cur.next = node
            node.next = self.__head
 
    def insert(self, pos, item):
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            pre = self.__head
            count = 0
            while count < (pos-1):
                count += 1
                pre = pre.next
            node.next = pre.next
            pre.next = node
 
    def remove(self, item):
        pre = self.__head
        cur = self.__head
        if cur == None:
            return False
        elif cur.elem == item:
            # 判断是不是只有一个节点
            if cur.next == self.__head:
                self.__head = None
                return True
            else:
                while pre.next != self.__head:
                    pre = pre.next
                self.__head = cur.next
                pre.next = self.__head
                return True
        else:
            while pre.next != self.__head:
                if pre.next.elem == item:
                    pre.next = pre.next.next
                    return True
                else:
                    pre = pre.next
            return False
 
    def search(self, item):
        cur = self.__head
        if self.__head == None:
            return False
        elif cur.elem == item:
            return True
        else:
            while cur.next != self.__head:
                if cur.elem == item:
                    return True
                else:
                    cur = cur.next
            if cur.elem == item:
                return True
        return False

单链表反转

class Node(object):
    def __init__(self, data, next=None):
        self.val = data
        self.next = next
 
def fun4(head):
    if head == None:
        return None
    L,M,R = None,None,head
    while R.next != None:
        L = M
        M = R
        R = R.next
        M.next = L
    R.next = M
    return R

链表中间点

class Solution:
    def middleNode(self, head):
        p=head
        count=0
        while p:
            count+=1
            p=p.next
        i=0
        p=head
        while i<count//2:
            p=p.next
            i+=1
        return p

双链表

class Node(object):
 
    def __init__(self, item):
        self.elem = item
        self.next = None
        self.prev = None
 
 
class DoubleLinkList(object):
 
    def __init__(self, node=None):
        self.__head = node
 
    def is_empty(self):

        return self.__head is None
 
    def length(self):

        cur = self.__head
        counter = 0
        while cur != None:
            counter += 1
            cur = cur.next
        return counter
 
    def append(self, item):
        node = Node(item)
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next
            cur.next = node
            node.prev = cur
 
    def add(self, item):
        node = Node(item)
        node.next = self.__head
        self.__head = node
        node.next.prev = node
 
    def insert(self, pos, item):
        if pos <= 0:
            self.add()
        elif pos > (self.length()-1):
            self.append()
        else:
            cur = self.__head
            counter = 0
            while counter != pos:
                counter += 1
                cur = cur.next
            node = Node(item)
            node.prev = cur.prev
            cur.prev.next = node
            node.next = cur
            cur.prev = node
 
    def travel(self):
        cur = self.__head
        while cur != None:
            print(cur.elem, end=" ")
            cur = cur.next
        print("")
 
    def remove(self, item):
        cur = self.__head
        while cur != None:
            if cur.elem == item:

                if cur == self.__head:
                    self.__head = cur.next
                    if cur.next != None:
                        cur.next.prev = None
                else:
                    cur.prev.next = cur.next
                    if cur.next != None:
                        cur.next.prev = cur.prev
                return True
            else:
                cur = cur.next
        return False
 
    def search(self, item):
 
        cur = self.__head
        while cur != None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False

Linked List Cycle I（环形链表）

class Solution(object):
    def hasCycle(self, head):
        fast = slow = head 
        while fast and fast.next: 
            fast = fast.next.next
            slow = slow.next
            if slow == fast: 
                return True
        return False

Merge k Sorted Lists（合并 k 个排序链表）

class Solution(object):
    def mergeKLists(self, lists):
 
        heap = []
        for l in lists:
            if l != None:
                heap.append((l.val,l))
        heapq.heapify(heap) 
        dummy = ListNode(0)
        cur = dummy
        while heap:
            _,h = heapq.heappop(heap)
            cur.next = h
            cur = cur.next
            if h.next:
                heapq.heappush(heap,(h.next.val,h.next)) 
        return dummy.next