leetcode刷题：剑指 Offer 06. 从尾到头打印链表 and 牛客网刷题：求二叉树的层序遍历 and 寻找第K大

剑指offer三种思路：1、栈存储输出 2、递归思想 3、链表反转

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
       vector<int> result;

        //栈方法
        // stack<ListNode*> s;
        // ListNode* node = head;
        // while( node != NULL )
        // {
        //     s.push(node);
        //     node = node->next;
        // }
        // while(!s.empty())
        // {
        //     result.push_back(s.top()->val);
        //     s.pop();
        // }

        //递归
        //digui(head,result);

        //反向链表
        ListNode* node = head;
        ListNode* H = new ListNode();
        H->next = NULL;
        ListNode* P = head;
        ListNode* fan_head;
        while(node!=NULL)
        {
            P = node->next;
            fan_head = node;
            node->next = H->next;
            H->next = node;
            node = P;
        }
        delete H;
        
        while (fan_head!=NULL)
        {
            result.push_back(fan_head->val);
            fan_head = fan_head->next;
        }
        return result;
    }

    void digui(ListNode* head,vector<int> &result)
    {
        if (head!=NULL)
        {
            digui(head->next,result);
            result.push_back(head->val);
        }
    }
};

思路：普通层序遍历只需要入队列出队列即可，但该题输出必须按照每层进行输出，所以需要加层数标识，我定义结构题，存储节点地址和层数信息。

class Solution {
public:
    /**
     *
     * @param root TreeNode类
     * @return int整型vector<vector<>>
     */struct node_struct
     {
         int level;
         TreeNode* newnode;
     };
    vector<vector<int> > levelOrder(TreeNode* root) {
        // write code here
        if (root == NULL)
            return {};
        vector<vector<int> > result;
        vector<int> row;
        queue<node_struct> q;
        node_struct nodestruct;
        nodestruct.level = 0;
        nodestruct.newnode = root;
        q.push(nodestruct);
        TreeNode* node;
        int level_num = 0;
        int level_old = 0;
        while (!q.empty())
        {
            node = q.front().newnode;
            level_num = q.front().level;
            q.pop();
            if (level_num!=level_old) //换层了
            {
                result.push_back(row);
                row.clear();
                level_old = level_num;
                row.push_back(node->val);
            }
            else
                row.push_back(node->val);
            //result[level_num].push_back(root->val);
             
            if (node->left!=NULL)
            {
                node_struct m;
                m.level = level_num+1;
                m.newnode = node->left;
                q.push(m);
            }
            if (node->right!=NULL)
            {
                node_struct m;
                m.level = level_num+1;
                m.newnode = node->right;
                q.push(m);
            }
        }
        result.push_back(row);
        return result;
    }
     
};

思路：利用快排算法从大到小排序后，取出K-1序号的数即为第k大的数。
改进版：

class Solution {
public:
    int findKth(vector<int> a, int n, int K) {
        // write code here
        quicksort(a,0,n-1);
        if (K<=n)
            return a[K-1];
        else
            return 0;
    }
    void quicksort(vector<int> &a,int low,int high)
    {
        int mid;
        if (low<high)
        {
            mid = findmid(a,low,high);

            quicksort(a,low,mid-1);
            quicksort(a,mid+1,high);
        }
    }
    int findmid(vector<int> &a,int low,int high)
    {
        int temp = a[low];
        while(low<high)
        {
            while(low<high &&  a[high]<= temp)
                high--;
            if (low<high)
            {
                a[low] = a[high];
                low++;
            }
            while (low<high && a[low] >= temp)
                low++;
             if (low<high)
            {
                a[high] = a[low];
                high--;
            }
        }
        a[low] = temp;
        return low;
    }
};