数据结构之 数组

数据结构之 数组

前序

前两天在想研究树时，想写出树的广度优先遍历算法，但是想不出来怎么写，也参考了其它人写的，但是还是理解不了程序的执行顺序，

于是觉得自己还是从头开始学习下数据结构，本来在大学时期已经重修过了的，由于大一没好好学习C语言，

所以后面第一次学习数据结构的时就可想而知了，我也忘记了考试成绩，反正没及格，补考也没及格，大三的时候又重修了遍，第二次学习比

第一次学习是好一些，考试还得了80几分了，也能大概看懂C语言程序了。

无序数组

     我是Java程序员，大多时候自己在程序中使用的都是使用无序数组，自己写了一个无序数组的例子

package com.jaws.array;

public class NoSequenceArray {
	private int[] array = null;
	private int index = 0;//索引
	
	public  NoSequenceArray(int max) {
		array = new int[max];
	}
	
	/**
	 * 添加元素
	 * @param element
	 */
	public void add(int element){
		if (index>array.length-1) {
			throw new ArrayIndexOutOfBoundsException("数组容量已达到最大容量!");
		}
		this.array[index] = element;
		index++;
	}
	
	/**
	 * 根据元素值查找索引
	 * @param element
	 * @return 索引
	 */
	public int searchIndex(int element){
		for (int i = 0; i < this.index; i++) {
			if(element == array[i]){
				return i;
			}
		}
		return -1;
	}
	

	/**
	 * 删除元素
	 * @param element
	 */
	public void delete(int element){
		int indexTarget = this.searchIndex(element);
		if (indexTarget==-1) {
			return;
		}
		for (int i = indexTarget; i < this.index; i++) {
			array[i]=array[i+1];
		}
		array[this.index] = 0;
	}
	
	public void println(){
		System.out.println("数组包含的元素为：");
		for (int i = 0; i < array.length; i++) {
			System.out.println("["+i+"]"+":"+array[i]);
		}
	}
	
	public static void main(String[] args) {
		NoSequenceArray array = new NoSequenceArray(10);
		array.add(3);
		array.add(20);
		array.add(8);
		array.add(33);
		array.add(15);
		array.println();
		System.out.println("8的索引为："+array.searchIndex(8));
		array.delete(8);
		System.out.println("8的索引为："+array.searchIndex(8));
		array.println();
	}
}

输出结果：

数组包含的元素有：
[0]:3
[1]:20
[2]:8
[3]:33
[4]:15
[5]:0
[6]:0
[7]:0
[8]:0
[9]:0
8的索引为：2
8的索引为：-1
数组包含的元素有：
[0]:3
[1]:20
[2]:33
[3]:15
[4]:0
[5]:0
[6]:0
[7]:0
[8]:0
[9]:0

  分析无序数组时间复杂度

操作	时间复杂度
插入	1
查找	O(N)
删除	O(N)

         

      插入操作，只需在数组尾部插入数据即可，执行一步，所以时间复杂度为1

      查询操作，数组长度为N，需要循环匹配元素，如果运气好，第一个元素为需要查找目标，如果运气最差，最后一个元素为需要找到目标，

所以需要执行的步数为N/2，时间复杂度也就是O(N)

      删除操作，需要先查找到目标元素，再将[目标索引+1]到[N-1]的元素往前移动一步，所以整个删除操作需要N步，时间复杂度为O(N)

 

   

有序数组

    有序数组真很少使用，JDK提高的Arrays类提供对无序数组的排序功能和其它有用的功能，修改下测试的代码

  

public static void main(String[] args) {
			NoSequenceArray noSeqArray = new NoSequenceArray(10);
			noSeqArray.add(3);
			noSeqArray.add(20);
			noSeqArray.add(8);
			noSeqArray.add(33);
			noSeqArray.add(15);
<span style="white-space:pre">			</span>System.out.println("排序前："+Arrays.toString(noSeqArray.array));
<span style="white-space:pre">			</span>Arrays.sort(noSeqArray.array);
<span style="white-space:pre">			</span>System.out.println(Arrays.binarySearch(noSeqArray.array, 33));
<span style="white-space:pre">			</span>System.out.println("排序后: "+Arrays.toString(noSeqArray.array));
		}

测试结果：

排序前：[3, 20, 8, 33, 15, 0, 0, 0, 0, 0]
9
排序后: [0, 0, 0, 0, 0, 3, 8, 15, 20, 33]

在使用过程发现了toString()方法，所以前面的无序的数组程序并不需要自己写println方法，意外的发现啊 ，还有排序、针对有序数组的二分法查找、填充(fill,用指定值填满整个数组)、复制数组、equals等很多的有用功能。有时候写自己写了一些功能，在查询JDK API时却发现JDK已经提供了相同的功能，所以以为要多看看JDK API，说不定会有意外的收获。