數據結構算法練習（一）

目錄

• 數組 棧 隊列 鏈表

數組 棧 隊列 鏈表

1. 定義數組類實現動態定義長度，添加，插入，編輯，查詢，搜索，排序

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class ArrayClass:
    '數組類'         #類文檔字符串

    # 數組聲明
    def __init__(self,len=10):
        self.len = len
        self.size=0
        self.arr = [0 for i in range(len)]

    # 數組長度
    def count(self):
        return self.len

    # 數組添加
    def add(self,value):
        self.arr[self.size] = value
        self.size +=1
        return self.arr

    # 數組插入
    def insert(self,index,value):
        for i in reversed(range(self.len)):
            if(i>=index and i!=(self.len-1) ):
                self.arr[i+1] = self.arr[i]
        self.arr[index] = value
        self.size +=1
        return self.arr

    # 數組編輯
    def set(self,index,value):
        self.arr[index]=value;
        return self.arr[index]

    # 數組查詢
    def select(self,index=False):
        if(index and index>=self.len):
            return False
        if(index):
            return self.arr[index]
        return self.arr

    # 數組檢索
    def check(self,value):
        index = ''
        for i in range(self.len):
            if(self.arr[i]==value):
                index=index+str(i)+' '
        if(index==''):
            return False
        return index

    # 數組排序
    def sort(self,way='asc'):
        if way=='asc':
            for i in range(0,self.len):
                min = self.arr[i]
                for j in range(i+1,self.len):
                    if(self.arr[j]<min):
                        min = self.arr[j];
                        self.arr[j] = self.arr[i]
                        self.arr[i] = min
        else:
            for i in range(0,self.len):
                max = self.arr[i]
                for j in range(i+1,self.len):
                    if(self.arr[j]>max):
                        max = self.arr[j];
                        self.arr[j] = self.arr[i]
                        self.arr[i] = max
        return self.arr

1. 給定一個排序數組，你須要在原地刪除重複出現的元素，使得每一個元素只出現一次，返回移除後數組的新長度。

   不要使用額外的數組空間，你必須在原地修改輸入數組並在使用 O(1) 額外空間的條件下完成。

   示例 1:

   給定數組 nums = [1,1,2],

   函數應該返回新的長度 2, 而且原數組 nums 的前兩個元素被修改成 1, 2。

   你不須要考慮數組中超出新長度後面的元素。
   示例 2:

   給定 nums = [0,0,1,1,1,2,2,3,3,4],

   函數應該返回新的長度 5, 而且原數組 nums 的前五個元素被修改成 0, 1, 2, 3, 4。

   你不須要考慮數組中超出新長度後面的元素。

時間複雜度O(n)

class Solution {

    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function removeDuplicates(&$nums) {
        $n = count($nums);
        $cur = 0;
        for($i=1;$i<$n;$i++){
            if($nums[$i]!=$nums[$cur]){
               $nums[++$cur]=$nums[$i];
            }           
            if($cur!=$i) unset($nums[$i]);
        }
        return $cur+1;
    }
}

1. 給定一個只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判斷字符串是否有效。

   有效字符串需知足：

   左括號必須用相同類型的右括號閉合。
   左括號必須以正確的順序閉合。
   注意空字符串可被認爲是有效字符串。

   示例 1:

   輸入: "()"
   輸出: true
   示例 2:

   輸入: "()[]{}"
   輸出: true
   示例 3:

   輸入: "(]"
   輸出: false
   示例 4:

   輸入: "([)]"
   輸出: false
   示例 5:

   輸入: "{[]}"
   輸出: true

解題思路，運用棧：

<?php
class Solution {

    /**
     * @param String $s
     * @return Boolean
     */
    function isValid($s) {
        $ss=[];
        $length = strlen($s);
        for($i=0;$i<$length;$i++){
            $t=substr($s,$i,1);
            if($t=='('||$t=='['||$t=='{'){
                array_push($ss,$t);
            }else{
                if(empty($ss)) return false;
                $end = end($ss);
               if( ($end=='(' && $t==')') || ($end=='[' && $t==']') || ($end=='{' && $t=='}') ){
                   array_pop($ss);
               }else{
                   return false;
               }
               
            }
        }
        if($ss) return false;
        return true;
    }
}

1. 給定兩個沒有重複元素的數組 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每一個元素在 nums2 中的下一個比其大的值。

   nums1 中數字 x 的下一個更大元素是指 x 在 nums2 中對應位置的右邊的第一個比 x 大的元素。若是不存在，對應位置輸出-1。

   示例 1:

   輸入: nums1 = [4,1,2], nums2 = [1,3,4,2].
   輸出: [-1,3,-1]
   解釋:
   對於num1中的數字4，你沒法在第二個數組中找到下一個更大的數字，所以輸出 -1。
   對於num1中的數字1，第二個數組中數字1右邊的下一個較大數字是 3。
   對於num1中的數字2，第二個數組中沒有下一個更大的數字，所以輸出 -1。
   示例 2:

   輸入: nums1 = [2,4], nums2 = [1,2,3,4].
   輸出: [3,-1]
   解釋:
   對於num1中的數字2，第二個數組中的下一個較大數字是3。
   對於num1中的數字4，第二個數組中沒有下一個更大的數字，所以輸出 -1。

<?php
class Solution {

    /**
     * @param Integer[] $nums1
     * @param Integer[] $nums2
     * @return Integer[]
     */
    function nextGreaterElement($nums1, $nums2) {
        $n = count($nums2);
        $map = [];
        for($i=0;$i<$n;$i++){
            $k=$i;
            $map[$nums2[$i]]=-1;
            
            while(++$k<$n){
                 if($nums2[$k]>$nums2[$i]){
                    $map[$nums2[$i]]=$nums2[$k];
                    break;
                 }   
            }   
        }
        
        $r=[];
        for($i=0;$i<count($nums1);$i++){
            $r[]=$map[$nums1[$i]];
        }
        //測試用例沒經過，搞不懂
        //  while($num=array_pop($nums1)){
                //       $r[]=$map[$num];
                // }
        //array_shift($r);        
                
        return $r;
        
        
    }
}

1. 反轉一個單鏈表。

   示例:

   輸入: 1->2->3->4->5->NULL
   輸出: 5->4->3->2->1->NULL

   進階:
   你能夠迭代或遞歸地反轉鏈表。你可否用兩種方法解決這道題

<?php
/**
 * Definition for a singly-linked list.
 * class ListNode {
 *     public $val = 0;
 *     public $next = null;
 *     function __construct($val) { $this->val = $val; }
 * }
 */
class Solution {

    /**
     * @param ListNode $head
     * @return ListNode
     */
    function reverseList($head) {
        while($head->val!==null){
            
            $node = new ListNode($head->val);
            $node->next = isset($nodetemp)?$nodetemp:null;
            $nodetemp = $node;
            
            $head = $head->next;
        }
        return $node;
    }
}

1. 刪除鏈表中等於給定值 val 的全部節點。

   示例:

   輸入: 1->2->6->3->4->5->6, val = 6

   輸出: 1->2->3->4->5

<?php
/**
 * Definition for a singly-linked list.
 * class ListNode {
 *     public $val = 0;
 *     public $next = null;
 *     function __construct($val) { $this->val = $val; }
 * }
 */
class Solution {

    /**
     * @param ListNode $head
     * @param Integer $val
     * @return ListNode
     */
    function removeElements($head, $val) {
        $pre = new ListNode(0);
        $pre->next = $head;
        
        $cur = $pre;
        while( $pre->next!= null){
            
            if($val==$pre->next->val){
                $pre->next= $pre->next!=null?$pre->next->next:null;
            }
            
            while($val==$pre->next->val){
                $pre->next = $pre->next->next;
            }
            
            $pre = $pre->next;   
        }
        
        
        return $cur->next;
    }
}

1. 給定一個排序鏈表，刪除全部重複的元素，使得每一個元素只出現一次。

   示例 1:

   輸入: 1->1->2

   輸出: 1->2

   示例 2:

   輸入: 1->1->2->3->3

   輸出: 1->2->3

   解決：移動節點next指針，進行判斷。複雜度O(n)

<?php
/**
 * Definition for a singly-linked list.
 * class ListNode {
 *     public $val = 0;
 *     public $next = null;
 *     function __construct($val) { $this->val = $val; }
 * }
 */
class Solution {

    /**
     * @param ListNode $head
     * @return ListNode
     */
    function deleteDuplicates($head) {
        $pre = $head;
        while( $pre->next!==null ){
            if($pre->val==$pre->next->val){
                $pre->next=$pre->next?$pre->next->next:null;
            }else{
               $pre=$pre->next; 
            }
        }
        
        return $head;
    }
}