​​剑指Offer_编程题​​

13、调整数组顺序使奇数位于偶数前面

时间限制：1秒 空间限制：32768K 热度指数：544200

本题知识点： ​​数组​​

题目描述：

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

思路：emm直接用了两个数组保存奇数偶数，然后在赋值回去。

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        vector<int> odd,even;
        int len=array.size();
        for(int i=0;i<len;i++){
            if(array[i]%2==0) even.push_back(array[i]);
            else odd.push_back(array[i]);
        }
        array=odd;
        len=even.size();
        for(int i=0;i<len;i++)
            array.push_back(even[i]);
    }
};

 

14、链表中倒数第K个节点

时间限制：1秒 空间限制：32768K 热度指数：758129

本题知识点： ​​链表​​

题目描述：

输入一个链表，输出该链表中倒数第k个结点。

思路：遍历节点个数，在遍历一次输出倒数第k个也就是正数第n-k个

class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        ListNode *p;
        int cnt=1,i=1;
        for(p=pListHead;p!=NULL;p=p->next) cnt++;
        cnt=cnt-k;
        for(p=pListHead;p!=NULL&&i<=cnt;p=p->next,i++){
            if(i==cnt) return p;
        }
        return NULL;
    }
};

 

15、反转链表

时间限制：1秒 空间限制：32768K 热度指数：550368

本题知识点： ​​链表​​

题目描述：

输入一个链表，反转链表后，输出新链表的表头。

思路：错了好些次！！然后知道了自己错在哪儿了！利用栈的特性保存节点。直接弹出的节点是由next指向的！两种方法，思想都是一样的，就是处理方式不同。

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        stack<int> s;
        for(ListNode *p=pHead;p!=NULL;p=p->next){
            s.push(p->val);
        }
        ListNode *head,*p;
        head=p=NULL;
        if(!s.empty()){
            int u=s.top();s.pop();
            p=new ListNode(u);
        }
        head=p;
        while(!s.empty()){
            int u=s.top();s.pop();
            p->next=new ListNode(u);
            p=p->next;
        }
        return head;
    }
};
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        stack<ListNode*> s;
        for(ListNode *p=pHead;p!=NULL;p=p->next){
            s.push(p);
        }
        ListNode *head,*tail;
        head=tail=NULL;
        if(!s.empty()){
            head=s.top();s.pop();
            tail=head;
            tail->next=head->next=NULL;
        }
        while(!s.empty()){
             ListNode *u=s.top();s.pop();
             u->next=NULL;
             tail->next=u;
             tail=tail->next;
        }
        return head;
    }
};

 

16、合并两个排序的链表

时间限制：1秒 空间限制：32768K 热度指数：530643

本题知识点： ​​链表​​

题目描述：

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

思路：（我又错了好多次，与很多细节没想到，没去考虑）1.两个链表为空的时候，2.分别为空的时候

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        ListNode *pHead3;
        ListNode *p1,*p2,*p3;
        pHead3=p3=NULL;
        p1=pHead1;
        p2=pHead2;
        if((p1!=NULL&&p2!=NULL&&p1->val<=p2->val)||(p1!=NULL&&p2==NULL)){
            pHead3=new ListNode(p1->val);
            p3=pHead3;
            p1=p1->next;
        }
        else if((p1!=NULL&&p2!=NULL&&p1->val>p2->val)||(p1==NULL&&p2!=NULL)){
            pHead3=new ListNode(p2->val);
            p3=pHead3;
            p2=p2->next;
        }
        while(p1!=NULL&&p2!=NULL){
            if(p1->val<=p2->val){
                p3->next=new ListNode(p1->val);
                p3=p3->next;
                p1=p1->next;
            }
            else{
                p3->next=new ListNode(p2->val);
                p3=p3->next;
                p2=p2->next;
            }
        }
        while(p1!=NULL){
            p3->next=new ListNode(p1->val);//p3->next=NULL;
            p3=p3->next;
            p1=p1->next;
        }
        while(p2!=NULL){
            p3->next=new ListNode(p2->val);//p3->next=NULL;
            p3=p3->next;
            p2=p2->next;
        }
        return pHead3;
    }
};