劍指offer習題:DAY 1

輸入一個鏈表，按鏈表從尾到頭的順序返回一個ArrayList。

有三種思路，第一就是利用棧先入後出的特性完成，第二就是存下來然後進行數組翻轉，第三是利用遞歸。

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    
    vector<int> value;
    vector<int> printListFromTailToHead(ListNode* head) {
     /*   
        //棧的思路,先進後出
        vector<int> value;
        stack<int> st;
        ListNode* p=head;
        
        while(p!=NULL)
        {
            st.push(p->val);
            p=p->next;
        }
        while(!st.empty())
        {
            value.push_back(st.top());
            st.pop();
        }
        return value;
*/
        
/*
        //向量數組翻轉
        vector<int> value;
        ListNode*　p=head;
        while(p!=NULL)
        {
            value.push_back(p->val);
            p=p->next;
        }
        
        int i=0,j=value.size()-1;
        int tmp;
        while(i<j)
        {
            tmp=value[i];
            value[i]=value[j];
            value[j]=tmp;
            i++;
            j--;
        }    
        
        return value;
        
        */
        
        //遞歸
        ListNode* p=head;
        if(p!=NULL)
        {
            if(p->next!=NULL){
                printListFromTailToHead(p->next);
            }
            value.push_back(p->val);
        }
        return value;
    }
};

題目描述

輸入一個鏈表，輸出該鏈表中倒數第k個結點。

解題思路：運用快慢指針

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
    
        if(pListHead==NULL||k==0)
            return NULL;
        //運用快慢指針的方法,若求倒數第三個結點，快指針和慢指針相差兩個位置
        ListNode* fast=pListHead,*slow=pListHead;
        for(unsigned int i=1;i<k;i++)
        {
            if(fast->next!=NULL)
                fast=fast->next;
            else return NULL;
        }
        while(fast->next!=NULL)
        {
            slow=slow->next;
            fast=fast->next;
        
        }
        
        return slow;
    }
};

題目描述

調整數組順序使奇數位於偶數前面。輸入一個整數數組，實現一個函數來調整該數組中數字的順序，使得所有的奇數位於數組的前半部分，所有的偶數位於數組的後半部分，並保證奇數和奇數，偶數和偶數之間的相對位置不變。

解題思路：冒泡法

class Solution {
public:
    void reOrderArray(vector<int> &array) {
        
        //奇數在前，偶數在後
        int sum=array.size();
        //冒泡法
        int tmp;
        while(sum)
        {
            for(int i=0,j=1;i<sum-1,j<sum;i++,j++)
            {
                if(array[i]%2==0&&array[j]%2!=0)
                {
                    tmp=array[i];
                    array[i]=array[j];
                    array[j]=tmp;
                }
            }
            sum--;
        }
    }
};

*題目描述

輸入一個鏈表，反轉鏈表後，輸出新鏈表的表頭。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
 /*       ListNode* pre=NULL;
        ListNode* pnext=NULL;
        
        while(pHead!=NULL)
        {
            pnext=pHead->next;
            pHead->next=pre;
            pre=pHead;
            pHead=pnext;
        }
        
        return pre;
      */
        //如果鏈表爲空或者鏈表中只有一個元素
        if(pHead==NULL||pHead->next==NULL) return pHead;
          
        //先反轉後面的鏈表，走到鏈表的末端結點
        ListNode* pReverseNode=ReverseList(pHead->next);
          
        //再將當前節點設置爲後面節點的後續節點
        pHead->next->next=pHead;
        pHead->next=NULL;
          
        return pReverseNode;
    }
};

題目描述

輸入兩個單調遞增的鏈表，輸出兩個鏈表合成後的鏈表，當然我們需要合成後的鏈表滿足單調不減規則。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        if(pHead1==NULL)
            return pHead2;
        if(pHead2==NULL)
            return pHead1;
        ListNode* p=NULL;

        if(pHead1->val>pHead2->val)
        {
            p=pHead2;
            p->next=Merge(pHead1,pHead2->next);
        }
        else
        {
            p=pHead1;
            p->next=Merge(pHead1->next,pHead2);
        }

        return p;

    }
};