中考信息技术python,python中考加分吗

大家好，小编来为大家解答以下问题，中考信息技术python，python中考加分吗，现在让我们一起来看看吧！

1.判断奇偶数

1. 奇数：a%2==1                偶数：a%2==0
2. 奇数：a&1==1                 偶数：a&1==0

2.链表中倒数第k个节点

     双指针法

3.反转链表

1. 三指针滑动pPrev -> pNode -> pNext;

pNext=pNode->next;
pNode->next=pPrev;
pPrev=pNode;
pNode=pNext;;

      2.新建一个链表，每次在新的头节点位置插入元素‘

4.从尾到头打印链表

       使用堆栈完成

5.斐波那契数列，跳台阶，变态跳台阶

1. 递归法：f(n)=f(n-1)+f(n-2)
2. 迭代法

class Solution:
    def Fibonacci(self, n):
        # write code here
        if n<=1:
            return n
        one=0
        two=1
        for i in range(1,n):
            res=one+two
            one=two
            two=res
        return res

6.二维列表旋转(逆时针旋转90度)

def turn(matrix):
    rows=len(matrix)
    cols=len(matrix[0])
    result=[]
    for i in range(cols):
        temp=[]
        for j in  range(rows):
            temp.appen(matrix[j][i])
        result.append(temp)
    result.reverse()
    return result

7.重建二叉树

8.栈混洗

1. 设置一个空栈来模拟整个出栈和入栈的过程
2. 利用栈混洗的i,j,k定理，即对于1<=i<=j<=k<=n，若[...，k，...，i...，j...>，则必然不是栈混洗

9.从上往下打印二叉树(二叉树的层次遍历)

用一个queue来实现

C++

class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        vector<int> res;
        if(root==NULL)
        {
            return res;
        }
        TreeNode* pNode;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            pNode=q.front();
            q.pop();
            res.push_back(pNode->val);
            if(pNode->left!=NULL)
            {
                q.push(pNode->left);
            }
            if(pNode->right!=NULL)
            {
                q.push(pNode->right);
            }
        }
        return res;
    }
};

python

class Solution:
    # 返回从上到下每个节点值列表，例：[1,2,3]
    def PrintFromTopToBottom(self, root):
        # write code here
        queue=[]
        result=[]
        if(root==None):
            return result
        queue.append(root);
        while queue:
            node=queue.pop(0)
            result.append(node.val)
            if(node.left!=None):
                queue.append(node.left)
            if(node.right!=None):
                queue.append(node.right)
        return result
            

10.二叉搜索树的后续遍历序列

11.二叉树中和为某一值的路径

递归的思路，用二维数组res存储所有符合的路径，一维数组path存储每一条路径，最后再按照path的长度大小排序

class Solution:
    # 返回二维列表，内部每个列表表示找到的路径
    def __init__(self):
        self.result=[]
        self.path=[]
    def FindPath(self, root, expectNumber):
        # write code here
        if root==None:
            return []
        self.path.append(root)
        if root.val==expectNumber and root.left==None and root.right==None:
            self.result.append([node.val for node in self.path])
        else:
            self.FindPath(root.left,expectNumber-root.val)
            self.FindPath(root.right,expectNumber-root.val)
        self.path.pop()
        
        return self.result

12.复杂链表的复制

13.字符串的排列(即为全排列的代码实现)

14.数组中出现次数超过一半的数字

  1.先对数组排序，然后遍历计数

C++

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        int len=numbers.size();
        if(len==0)
        {
            return 0;
        }
        else if(len==1)
        {
            return numbers[0];
        }
        sort(numbers.begin(),numbers.end());
        int count=1;
        int res=0;
        for(int i=0;i<len-1;i++)
        {
            if(numbers[i]==numbers[i+1])
            {
                count++;
            }
            else
            {
                count=1;
            }
            if(count>len/2)
            {
                res=numbers[i];
                break;
            }
        }
        return res;
    }
};

  2.利用python中的字典实现

python:

# -*- coding:utf-8 -*-
class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        dict = {}
        for i in numbers:
            if not dict.has_key(i):
                dict[i] = 1
            else:
                dict[i] = dict[i] + 1
            if dict[i] > len(numbers)/2:
                return i
        return 0

 3.快排，如果该数出现次数超过数组长度的一半，那么，排序之后，他应该位于数组的中间

  4.python的count计数方法

# -*- coding:utf-8 -*-
class Solution:
    def MoreThanHalfNum_Solution(self, numbers):
        # write code here
        for num in numbers:
            if numbers.count(num)>(len(numbers)/2):
                return num
        return 0

  5.利用map容器

C++

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        int n = numbers.size();
        //map 记录出现次数
        map<int, int> m;
        int count;
        for (int i = 0; i < n; i++) {
            count = ++m[numbers[i]];
            if (count > n/2) return numbers[i];
        }
        return 0;
    }
};