【基本题型】数据结构中基础题型

【正在持续更新中······，LODING······】

 

 

 

 

 

---

*  复杂链表复制

        输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。

解题思路：
*1、遍历链表，复制每个结点，如复制结点A得到A1，将结点A1插到结点A后面；
*2、重新遍历链表，复制老结点的随机指针给新结点，如A1.random = A.random.next;
*3、拆分链表，将链表拆分为原链表和复制后的链表

//复制节点部分。复制并链入原节点后。
RandomListNode pNode = pHead;
while(pNode!=null){
    RandomListNode newNode = new RandomListNode(pNode.label);
  //RandomListNode newNode = pNode;//若替换成本句后，编译不通过，提示超时或复杂度过大。！。

    newNode.next = pNode.next;
    pNode.next = newNode;
    pNode = newNode.next;
}

---

*  线索二叉树

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

解题思路 - -：

1、有右子树的，那么下个结点就是右子树最左边的点；（eg：D，B，E，A，C，G） 
2、没有右子树的，也可以分成两类，
a)是父节点左孩子（eg：N，I，L） ，那么父节点就是下一个节点 ； 
b)是父节点的右孩子（eg：H，J，K，M）找他的父节点的父节点的父节点...直到当前结点是其父节点的左孩子位置。如果没有eg：M，那么他就是尾节点。

public class Solution {
    TreeLinkNode GetNext(TreeLinkNode node)
    {
        if(node==null) return null;
        if(node.right!=null){    //如果有右子树，则找右子树的最左节点
            node = node.right;
            while(node.left!=null) node = node.left;
            return node;
        }
        while(node.next!=null){ //没右子树，则找第一个当前节点是父节点左孩子的节点
            if(node.next.left==node) return node.next;
            node = node.next;
        }
        return null;   //退到了根节点仍没找到，则返回null
    }
}

---

*  路径问题（二叉树路径节点和）

输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)

转变成---目标值与路径节点 差值为零时 ，即可满足所求路径。

//全局变量两个：
    ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
    ArrayList path = new ArrayList();
//递归方法：
    public void find(TreeNode root, int sum){
        if(root == null) return;
        path.add(root.val);
        if(root.left==null && root.right==null && sum==root.val) res.add(new ArrayList<Integer>(path));
        else{
            if(root.left!=null) find(root.left, sum-root.val);
            if(root.right!=null) find(root.right, sum-root.val);
        }
        path.remove(path.size()-1);
    }

---

*  判断整数数组，是否为【二叉排序树的后序遍历】结果

 

解法其一：
while(--size)
{
    while(sequence[i++]<sequence[size]);
    while(sequence[i++]>sequence[size]);

    if(i<size)return false;
    i=0;
}
return true;

解法其二：
    public boolean verifyBST(int[] arr, int start, int end){
        if(end<=start) return true;
        int i,j;
        for(i=start;i<end; i++){
            if(arr[i]>arr[end]) break;
        }
        for(j=i; j<end; j++){
            if(arr[j]<arr[end]) return false;
        }
        return verifyBST(arr, 0, i-1) && verifyBST(arr, i, end-1);
    }

---

*  打印矩阵  --  （由外而内，顺时针）

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字

    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        if(matrix==null || matrix.length==0) return result;
        int top,bottom,left,right;
        top   = 0;
        left  = 0;
        bottom  = matrix.length - 1;
        right   = matrix[0].length-1;
        while(left<=right && top<=bottom){
            if(top<=bottom){
                for(int i=left; i<=right; i++){
                    result.add(matrix[top][i]);
                }top++;
            }
            if(left<=right){
                for(int j=top; j<=bottom; j++){
                    result.add(matrix[j][right]);
                }right--;
            }
            if(top<=bottom){
                for(int k=right; k>=left; k--){
                    result.add(matrix[bottom][k]);
                }bottom--;
            }
            if(left<=right){
                for(int l=bottom; l>=top; l--){
                    result.add(matrix[l][left]);
                }left++;
            }
        }
        return result;
    }

---

*  求base的exponent次方。

给定一个double类型的浮点数base和int类型的整数exponent。

如下代码中，就不用分别考虑exponent的正负情况了！！！牛。

while(exponent!=0){ 
    if((exponent&1)==1) 
        res*=curr;
    curr*=curr;// 翻倍
    exponent>>=1;// 右移一位
}

---

*  求二进制中 1 的个数

--也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0.那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。
 

while(n!=0){     count++;    n = n&(n-1);        }

---

*  用两个栈实现一个队列的功能?要求给出算法和思路!

<分析>：

入队：将元素进栈A

出队：判断栈B是否为空，如果为空，则将栈A中所有元素pop，并push进栈B，栈B出栈；

 如果不为空，栈B直接出栈。

---

*  用两个队列实现一个栈的功能?要求给出算法和思路!

<分析>：

入栈：将元素进队列A

出栈：判断队列A中元素的个数是否为1，如果等于1，则出队列，否则将队列A中的元素   以此出队列并放入队列B，直到队列A中的元素留下一个，然后队列A出队列，再把   队列B中的元素出队列以此放入队列A中。

---