第一部分顺序表和链表

算法编程解题思路：

给出算法的基本设计思想
根据设计思想，采用 Java 或者 python 语言描述算法，关键之处给出注释
说明时间复杂度和空间复杂度

一、顺序表

1、长度为 n 的顺序表 L，编写一个时间复杂度为 O(n)，空间复杂度为O(1) 的算法，该算法删除线性表中所有值为 x 的数据元素。

方法一：定义指针 index，遍历数组的元素，当元素的值不为 x 时，将当前元素前置到 index 位置上，同时 index 自增。

def function(nums, x):index = 0for i in range(0, len(nums)):if nums[i] != x:nums[index] = nums[i]index += 1print(nums[0: index])

方法二：定义变量 count，用于统计值为 x 的数量，遍历数组的元素，当元素的值不为 x，将下标为 i 的元素前置到 i - count 的位置。

def function(nums, x):count = 0for i in range(0, len(nums)):if nums[i] == x:count += 1else:nums[i - count] = nums[i]print(nums[0: len(nums) - count])

2、从顺序表中删除所有其值重复的元素，使表中所有元素的值均不相同

思路：定义指针 index，遍历数组的元素，当元素 nums[index] 不等于 nums[i] 时，说明 nums[index] 不需要被删除，所以，index 先自增，然后，将当前元素前置到 index 位置上。

举例说明：

def function(nums):index = 0for i in range(1, len(nums)):if nums[index] != nums[i]:index += 1nums[index] = nums[i]print(nums[0: index + 1])

3、线性表（a1, a2, a3, ……,an）中元素递增有序，且按顺序存储于计算机内。要求设计一算法完成用最少的时间在表中查找值为 x 的元素，若找到将其与后继元素位置想交换，若找不到将其插入表中，并使表中的元素仍然递增有序。

def function(nums, target):low = 0high = len(nums) - 1mid = 0while low <= high:mid = (low + high) // 2if nums[mid] == target:breakif nums[mid] < target:low = mid + 1else:high = mid - 1if nums[mid] == target and mid < len(nums) - 1:nums[mid], nums[mid+1] = nums[mid+1], nums[mid]if low > high:nums.append(0)for i in range(len(nums)-1, high, -1):nums[i] = nums[i-1]nums[low] = target

4、将 n（n > 0）个整数存放到一维数组 R 中。试设计一个在时间和空间两方面都尽可能高效的算法。将 R 中保存的序列循环左移 p （0<p<n）个位置。

def reverse(nums, start, end):while start < end:nums[start], nums[end] = nums[end], nums[start]start += 1end -= 1print(nums)def function(nums, p):reverse(nums, 0, p-1)reverse(nums, p, len(nums)-1)reverse(nums, 0, len(nums)-1)

5、一个长度为 L 的升序列 S，处在 1/2 个位置的数称为 S 的中位数。S1=（11, 13, 15, 17, 19），S2=（2, 4, 6, 8, 20），现在有两个等长的升序序列 A = (11, 13, 15, 17, 19) 和 B = (2, 4, 6, 8, 20)，试设计一个在时间和空间两个方面都尽可能高效的算法，找出两个序列 A 和 B 的中位数。

6、已知一个整数序列 A = (a0, a1, ……, an-1)，其中，0 <= ai < n。若某个元素的数量超过一半，则称之为主元素。请设计一个高效的算法，找出 A = (0, 5, 5, 3, 5, 7, 5, 5) 的主元素。

def function(nums):flag = nums[0]count = 1for i in range(1, len(nums)):flag = nums[i] if count == 0 else flagcount += 1 if flag == nums[i] else -1print(flag)

二、链表

引入头结点后，第一个结点的位置被存放在头结点的指针域中，有点如下：

在链表中的第一个位置和其他位置上的结点操作一致，无须进行特殊处理；
空链表和非空链表的处理一致。

尾插法建表

class ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextdef create_link_list(nums):head = ListNode(0)pointer = headfor i in nums:temp = ListNode(i)pointer.next = temppointer = pointer.nextreturn headcreate_link_list([1, 2, 3, 4, 5])

遍历链表

def print_link(head):pointer = head.nextwhile pointer is not None:print(pointer.val)pointer = pointer.next

1、头插法实现单链表反转或者就地逆置单链表

def function(head):pointer = head.nextp_index = ListNode(0)head = ListNode(0)while pointer is not None:p_index = pointerpointer = pointer.nextp_index.next = head.nexthead.next = p_index

2、设 head 为带头结点的单链表，编写算法实现从尾到头反向输出每个节点的值

def function(head):  # head 链表参照尾插法自己创建，输入列表，输出链表stack = Stack()  # Stack 是作者基于列表封装的类，实现了栈的功能pointer = head.nextwhile pointer is not None:stack.push(pointer.val)pointer = pointer.nextwhile not stack.is_empty():print(stack.pop())

3、有一个带头结点的单链表 head，涉及一个算法使其元素递增有序。

思路：插入排序法实现链表的排序

def function(head):pointer = head.nexthead = ListNode(0)while pointer is not None:p_index = pointerpointer = pointer.nexttemp_index = headwhile temp_index.next is not None and temp_index.next.val < p_index.val:temp_index = temp_index.nextp_index.next = temp_index.nexttemp_index.next = p_index

4、给定两个单链表，编写算法找出两个链表的公共结点。

思路：如果链表有公共结点，那么，两个链表从公共结点到尾结点一定是相同的，所以，先将其中较长的链表遍历至和较短的链表相同长度，然后，同时遍历并判断当前两个链表的结点是否相同。

def getIntersectionNode(headA, headB):countA = 0countB = 0index_A = headAwhile index_A is not None:countA += 1index_A = index_A.nextindex_B = headBwhile index_B is not None:countB += 1index_B = index_B.nextdistance = 0long_link = ListNode(0)short_link = ListNode(0)if countA - countB > 0:distance = countA - countBlong_link = headAshort_link = headBelse:distance = countB - countAlong_link = headBshort_link = headAfor i in range(0, distance):long_link = long_link.nextwhile long_link is not None:if long_link == short_link:return long_linklong_link = long_link.nextshort_link = short_link.nextreturn None

5、请你设计并实现一个满足 LRU（最近最少）使用约束的数据结构