python实现数组

$$python实现数组$$

一个数据结构的定义基本架构就是：成员构造、增、删、改、查、返回大小、是否为空

难点

---

1.构造成员

    def __init__(self, capacity=100):
        self._capacity = capacity
        self._size = 0
        self._data = [None] * self._capacity

2.增

    def add(self, index, elem):
        for i in range(self._size-1,index-1):
            self._data[i+1] = self._data[i]
        self._data[index] = elem
        self._size += 1

    def add(self, index, elem):
        if index < 0 or index > self._size:  # 插入的位置无效
            raise Exception('Add Filed. Require 0 <= index <= self._size')
        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

3.删

    def remove(self, index):
        ret = self._data[index]
        for i in range(index,self._size-1):
            self._data[i] = self._data[i+1]
        self._size -= 1
        self._data[self._size] = None
        return ret

    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

---

练习三部曲之一

class Array:
    def __init__(self, capacity=100):
        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 0 <= index <= self._size')
        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 = Array()
        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, Arrayay 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, Arrayay 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 printArray(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):
        self._capacity = new_capacity
        new_Array = Array(new_capacity)
        for i in range(self._size):
            new_Array.addLast(self._data[i])
		self._data = new_Array._data

if __name__ == "__main__":
    array = Array()
    # addLast
    array.addLast(1)
    array.addLast(2)
    array.addLast(3)
    array.addLast(4)
    array.addLast(5)
    # addFirst
    array.addFirst(6)
    # add
    array.add(1,100)
    # get
    print(array.get(1))
    # getFirst
    print(array.getFirst())
    # getLast
    print(array.getLast())
    # set
    array.set(1,1000)
    print(array[1])
    # contains
    print(array.contains(1000))
    # find
    print(array.find(1000))
    # printArray
    array.printArray()
    print(array[0])

练习三部曲之二

class Array:
    # 1.成员构造
    def __init__(self, capacity=10):
        pass
    
    # 2.魔法方法
    def __getitem__(self, item):
        pass

    # 3.返回大小
    def getSize(self):
        pass

    def getCapacity(self):
        pass

    # 4.判空
    def isEmpty(self):
        pass

    # 5.增
    def add(self, index, elem):
        pass

    def addLast(self, elem):
        pass

    def addFirst(self, elem):
        pass
    # 6.删
    def remove(self, index):
        pass

    def removeFirst(self):
        pass

    def removeLast(self):
        pass

    def removeElement(self, elem):
        pass

    def removeAllElement(self, elem):
        pass

    def get_Max_index(self):
        pass

    def removeMax(self):
        pass

    def get_Min_index(self):
        pass

    def removeMin(self):
        pass
    # 7.改
    def set(self, index, elem):
        pass

    # 8.查
    def get(self, index):
        pass

    def getFirst(self):
        pass

    def getLast(self):
        pass

    def contains(self, elem):
        pass

    def find(self, elem):
        pass

    def findAll(self, elem):
        pass

    # 9.附加函数
    def swap(self, index1, index2):
        pass

    def printArr(self):
        pass

    def _resize(self, new_capacity):
        pass

练习三部曲之三

class Array:
	pass
    # 1.成员构造
    # 2.魔法方法
    # 3.返回大小
    # 4.判空
    # 5.增
    # 6.删
    # 7.改
    # 8.查
    # 9.附加函数

最新默写之作

class Array:
    # 1.成员构造
    def __init__(self,capacity=100):
        self._capacity = capacity
        self._size = 0
        self._data = [None]*self._capacity

    # 2.魔法方法
    def __getitem__(self, item):
        return self._data[item]

    # 3.返回大小
    def getSize(self):
        return self._size

    # 4.判空
    def isEmpty(self):
        return self._size == 0

    # 5.增
    def add(self,index,elem):
        if index < 0 or index > self._size:
            raise Exception("Index is Illegal!")
        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 addFirst(self,elem):
        self.add(0,elem)

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

    # 6.删
    def remove(self,index):
        for i in range(index,self._size-1):
            self._data[i] = self._data[i+1]
        self._size -= 1
        self._data[self._size] = None
        if self._size and self._size == self._capacity/4:
            self._resize(self._capacity/2)

    def removeFirst(self):
        self.remove(0)

    def removeLast(self):
        self.remove(self._size-1)

    # 7.改
    def set(self,index,elem):
        if index < 0 or index > self._size:
            self._data[index] = elem

    # 8.查
    def get(self, index):
        if index < 0 or index > self._size - 1:
            raise Exception("Index is Illegal!")
        return self._data[index]

    def getFirst(self):
        return self._data[0]

    def getLast(self):
        return self._data[self._size - 1]

    def find(self, elem):
        for i in range(self._size):
            if self._data[i] == elem:
                return i
        return -1

    def findAll(self, elem):
        res = Array()
        for i in range(self._size):
            if self._data[i] == elem:
                res.addLast(i)
        return res

    def get_Max_index(self):
        max_Number_index = 0
        for i in range(1,self._size):
            if self._data[i] > self._data[max_Number_index]:
                max_Number_index = i
        return max_Number_index
    
    def removeMax(self):
        self.remove(self.get_Max_index())
        
    # 9.附加函数
    def _resize(self,new_capacity):
        self._capacity = new_capacity
        newArray = Array(new_capacity)
        for i in range(self._size):
            newArray._data[i] = self._data[i]
        self._data = newArray._data