Java數據結構和算法（二）：數組

時間 2019-11-24

標籤 java 數據結構算法數組欄目 Java 简体版

原文原文鏈接

上篇博客咱們簡單介紹了數據結構和算法的概念，對此模糊很正常，後面會慢慢經過具體的實例來介紹。本篇博客咱們介紹數據結構的鼻祖——數組，能夠說數組幾乎能表示一切的數據結構，在每一門編程語言中，數組都是重要的數據結構，固然每種語言對數組的實現和處理也不相同，可是本質是都是用來存放數據的的結構，這裏咱們以Java語言爲例，來詳細介紹Java語言中數組的用法。java

一、Java數組介紹

　　在Java中，數組是用來存放同一種數據類型的集合，注意只能存放同一種數據類型(Object類型數組除外)。算法

　　①、數組的聲明編程

　　第一種方式：數組

 
         數據類型 []  數組名稱 =  
         new  
         數據類型[數組長度];

　　這裏 [] 能夠放在數組名稱的前面，也能夠放在數組名稱的後面，咱們推薦放在數組名稱的前面，這樣看上去數據類型 [] 表示的很明顯是一個數組類型，而放在數組名稱後面，則不是那麼直觀。數據結構

　　第二種方式：數據結構和算法

 
         數據類型 [] 數組名稱 = {數組元素 
         1 
         ，數組元素 
         2 
         ，......}

　　這種方式聲明數組的同時直接給定了數組的元素，數組的大小由給定的數組元素個數決定。編程語言

 
         //聲明數組1,聲明一個長度爲3，只能存放int類型的數據 
        
         int  
         [] myArray =  
         new  
         int 
         [ 
         3 
         ]; 
        
         //聲明數組2,聲明一個數組元素爲 1,2,3的int類型數組 
        
         int  
         [] myArray2 = { 
         1 
         , 
         2 
         , 
         3 
         };

　　②、訪問數組元素以及給數組元素賦值ide

　　數組是存在下標索引的，經過下標能夠獲取指定位置的元素，數組小標是從0開始的，也就是說下標0對應的就是數組中第1個元素，能夠很方便的對數組中的元素進行存取操做。函數

　　前面數組的聲明第二種方式，咱們在聲明數組的同時，也進行了初始化賦值。測試

 
         //聲明數組,聲明一個長度爲3，只能存放int類型的數據 
        
         int  
         [] myArray =  
         new  
         int 
         [ 
         3 
         ]; 
        
         //給myArray第一個元素賦值1 
        
         myArray[ 
         0 
         ] =  
         1 
         ; 
        
         //訪問myArray的第一個元素 
        
         System.out.println(myArray[ 
         0 
         ]);

　　上面的myArray 數組，咱們只能賦值三個元素，也就是下標從0到2，若是你訪問 myArray[3] ，那麼會報數組下標越界異常。

　　③、數組遍歷

　　數組有個 length 屬性，是記錄數組的長度的，咱們能夠利用length屬性來遍歷數組。

 
         //聲明數組2,聲明一個數組元素爲 1,2,3的int類型數組 
        
         int  
         [] myArray2 = { 
         1 
         , 
         2 
         , 
         3 
         }; 
        
         for 
         ( 
         int  
         i =  
         0  
         ; i < myArray2.length ; i++){ 
        
         System.out.println(myArray2[i]); 
        
         }

二、用類封裝數組實現數據結構

　　上一篇博客咱們介紹了一個數據結構必須具備如下基本功能：

　　①、如何插入一條新的數據項

　　②、如何尋找某一特定的數據項

　　③、如何刪除某一特定的數據項

　　④、如何迭代的訪問各個數據項，以便進行顯示或其餘操做

　　而咱們知道了數組的簡單用法，如今用類的思想封裝一個數組，實現上面的四個基本功能：

　　ps:假設操做人是不會添加劇復元素的，這裏沒有考慮重複元素，若是添加劇復元素了，後面的查找，刪除，修改等操做只會對第一次出現的元素有效。

  1 package com.ys.array;
  2  
  3 public class MyArray {
  4     //定義一個數組
  5     private int [] intArray;
  6     //定義數組的實際有效長度
  7     private int elems;
  8     //定義數組的最大長度
  9     private int length;
 10      
 11     //默認構造一個長度爲50的數組
 12     public MyArray(){
 13         elems = 0;
 14         length = 50;
 15         intArray = new int[length];
 16     }
 17     //構造函數，初始化一個長度爲length 的數組
 18     public MyArray(int length){
 19         elems = 0;
 20         this.length = length;
 21         intArray = new int[length];
 22     }
 23      
 24     //獲取數組的有效長度
 25     public int getSize(){
 26         return elems;
 27     }
 28      
 29     /**
 30      * 遍歷顯示元素
 31      */
 32     public void display(){
 33         for(int i = 0 ; i < elems ; i++){
 34             System.out.print(intArray[i]+" ");
 35         }
 36         System.out.println();
 37     }
 38      
 39     /**
 40      * 添加元素
 41      * @param value,假設操做人是不會添加劇復元素的，若是有重複元素對於後面的操做都會有影響。
 42      * @return添加成功返回true,添加的元素超過範圍了返回false
 43      */
 44     public boolean add(int value){
 45         if(elems == length){
 46             return false;
 47         }else{
 48             intArray[elems] = value;
 49             elems++;
 50         }
 51         return true;
 52     }
 53      
 54     /**
 55      * 根據下標獲取元素
 56      * @param i
 57      * @return查找下標值在數組下標有效範圍內，返回下標所表示的元素
 58      * 查找下標超出數組下標有效值，提示訪問下標越界
 59      */
 60     public int get(int i){
 61         if(i<0 || i>elems){
 62             System.out.println("訪問下標越界");
 63         }
 64         return intArray[i];
 65     }
 66     /**
 67      * 查找元素
 68      * @param searchValue
 69      * @return查找的元素若是存在則返回下標值，若是不存在，返回 -1
 70      */
 71     public int find(int searchValue){
 72         int i ;
 73         for(i = 0 ; i < elems ;i++){
 74             if(intArray[i] == searchValue){
 75                 break;
 76             }
 77         }
 78         if(i == elems){
 79             return -1;
 80         }
 81         return i;
 82     }
 83     /**
 84      * 刪除元素
 85      * @param value
 86      * @return若是要刪除的值不存在，直接返回 false;不然返回true，刪除成功
 87      */
 88     public boolean delete(int value){
 89         int k = find(value);
 90         if(k == -1){
 91             return false;
 92         }else{
 93             if(k == elems-1){
 94                 elems--;
 95             }else{
 96                 for(int i = k; i< elems-1 ; i++){
 97                     intArray[i] = intArray[i+1];
 98                    
 99                 }
100                  elems--;
101             }
102             return true;
103         }
104     }
105     /**
106      * 修改數據
107      * @param oldValue原值
108      * @param newValue新值
109      * @return修改爲功返回true，修改失敗返回false
110      */
111     public boolean modify(int oldValue,int newValue){
112         int i = find(oldValue);
113         if(i == -1){
114             System.out.println("須要修改的數據不存在");
115             return false;
116         }else{
117             intArray[i] = newValue;
118             return true;
119         }
120     }
121  
122 }

　　測試：

 
         package  
         com.ys.test; 
        
         import  
         com.ys.array.MyArray; 
        
         public  
         class  
         MyArrayTest { 
        
         public  
         static  
         void  
         main(String[] args) { 
        
         //建立自定義封裝數組結構，數組大小爲4 
        
         MyArray array =  
         new  
         MyArray( 
         4 
         ); 
        
         //添加4個元素分別是1,2,3,4 
        
         array.add( 
         1 
         ); 
        
         array.add( 
         2 
         ); 
        
         array.add( 
         3 
         ); 
        
         array.add( 
         4 
         ); 
        
         //顯示數組元素 
        
         array.display(); 
        
         //根據下標爲0的元素 
        
         int  
         i = array.get( 
         0 
         ); 
        
         System.out.println(i); 
        
         //刪除4的元素 
        
         array.delete( 
         4 
         ); 
        
         //將元素3修改成33 
        
         array.modify( 
         3 
         ,  
         33 
         ); 
        
         array.display(); 
        
         } 
        
         }

　　打印結果爲：

三、分析數組的侷限性

　　經過上面的代碼，咱們發現數組是能完成一個數據結構全部的功能的，並且實現起來也不難，那數據既然能完成全部的工做，咱們實際應用中爲啥不用它來進行全部的數據存儲呢？那確定是有緣由呢。

　　數組的侷限性分析：

　　①、插入快，對於無序數組，上面咱們實現的數組就是無序的，即元素沒有按照從大到小或者某個特定的順序排列，只是按照插入的順序排列。無序數組增長一個元素很簡單，只須要在數組末尾添加元素便可，可是有序數組卻不必定了，它須要在指定的位置插入。

　　②、查找慢，固然若是根據下標來查找是很快的。可是一般咱們都是根據元素值來查找，給定一個元素值，對於無序數組，咱們須要從數組第一個元素開始遍歷，直到找到那個元素。有序數組經過特定的算法查找的速度會比無需數組快，後面咱們會講各類排序算法。

　　③、刪除慢，根據元素值刪除，咱們要先找到該元素所處的位置，而後將元素後面的值總體向前面移動一個位置。也須要比較多的時間。

　　④、數組一旦建立後，大小就固定了，不能動態擴展數組的元素個數。若是初始化你給一個很大的數組大小，那會白白浪費內存空間，若是給小了，後面數據個數增長了又添加不進去了。

　　很顯然，數組雖然插入快，可是查找和刪除都比較慢，並且擴展性差，因此咱們通常不會用數組來存儲數據，那有沒有什麼數據結構插入、查找、刪除都很快，並且還能動態擴展存儲個數大小呢，答案是有的，可是這是創建在很複雜的算法基礎上，後面咱們也會詳細講解。

四、分析數組在內存中的存儲

咱們知道Java裏當一個對象使用關鍵字「new」建立時，會在堆上分配內存空間，而後返回對象的引用，這對數組來講也是同樣的，由於數組也是一個對象。

新建一個數組

int[] arr = new int[4];

上面這段代碼能夠當作兩部分，一部分是數組引用，即在代碼中定義的數組引用變量；另外一部分是實際的數組對象，這部分是在堆內存裏運行的，一般沒法直接訪問，只能經過數組引用變量來訪問。

棧內存中存儲所定義並初始化的引用變量arr，堆內存中存儲arr指向的4個數組arr[0],arr[1],arr[2],arr[3]

五、擴展

1）滑動窗口練習題

有一個整型數組 arr 和一個大小爲 w 的窗口從數組的最左邊滑到最右邊,窗口每次向右邊滑一個位置。返回一個長度爲n-w+1的數組res，res[i]表示每一種窗口狀態下的最大值。以數組爲[4,3,5,4,3,3,6,7]，w=3爲例。由於第一個窗口[4,3,5]的最大值爲5，第二個窗口[3,5,4]的最大值爲5，第三個窗口[5,4,3]的最大值爲5。第四個窗口[4,3,3]的最大值爲4。第五個窗口[3,3,6]的最大值爲6。第六個窗口[3,6,7]的最大值爲7。因此最終返回[5,5,5,4,6,7]。

給定整形數組arr及它的大小n，同時給定w，請返回res數組。保證w小於等於n，同時保證數組大小小於等於500。

測試樣例：

[4,3,5,4,3,3,6,7],8,3

返回：[5,5,5,4,6,7]

import java.util.*;
public class SlideWindow {
    public int[] slide(int[] arr, int n, int w) {
        //result數組中保存每一個窗口狀態下的最大值
        int[] result = new int[n-w+1];
        //記錄雙端隊列隊頭的下標 ，隊尾下標
        int[] qmax = new int[n];
        int front = 0, back = 0;
        //j 標記是否達到窗口大小,同時記錄result中下一個應該放入的元素的下標
        int j = 0;
        for(int i=0; i<n; i++){
            while(front < back && arr[qmax[back-1]] < arr[i])//back爲當前要往qmax中放入的值
                back--;
            qmax[back++] = i;
            if(j+w-1 == i){
                //達到窗口長度
                result[j] = arr[qmax[front]];
                j++;
            }
            if(qmax[front]+w-1 == i){
                //隊頭過時
                front++;
            }
        } 
        return result;
    }
}

2）數組變樹練習題

對於一個沒有重複元素的整數數組，請用其中元素構造一棵MaxTree，MaxTree定義爲一棵二叉樹，其中的節點與數組元素一一對應，同時對於MaxTree的每棵子樹，它的根的元素值爲子樹的最大值。現有一建樹方法，對於數組中的每一個元素，其在樹中的父親爲數組中它左邊比它大的第一個數和右邊比它大的第一個數中更小的一個。若兩邊都不存在比它大的數，那麼它就是樹根。請設計O(n)的算法實現這個方法。

給定一個無重複元素的數組A和它的大小n，請返回一個數組，其中每一個元素爲原數組中對應位置元素在樹中的父親節點的編號，若爲根則值爲-1。

測試樣例：
[3,1,4,2],4
返回：[2,0,-1,2]

思路：要求時間複雜度爲O(n),題目中已經有提示了，其實和最大最小堆有一點類似，對於大頂堆，咱們經常使用樹的方式理解，可是實際上能夠用線性表存儲（即數組），所以它須要是一棵徹底二叉樹（中間不能缺節點）。本題中的MaxTree只要求是二叉樹就好了~，限制少一些，因此構建的時間複雜度也比創建大頂堆低一些。（大根堆構建初堆的時間複雜度也是O(n)) 利用棧能夠快速找出左邊和右邊第一個比它大的值。