线性表之顺序表常见操作

顺序表

顺序表采用连续的数据结构进行数据的存取,插入删除元素(非最后元素),需要移动元素,对于插入元素,需要考虑扩容.但是顺序表可以进行随机访问,对于插入删除操作相对较少,访问元素操作较多的类型,可以采用顺序表进行存储

一,主要内容

1,顺序表的插入元素到指定位置

2,顺序表的删除指定位置元素

3,获取指定位置元素

4,获取指定元素的索引

5,删除所有指定的元素

6,删除指定索引位置的元素

7,顺序表元素逆置反转

8,顺序表元素循环左移

 

二,对应的算法实现

 

package com.zl.ds;

import java.util.Arrays;

public class SequenceList<T extends Comparable<T>>{

	private static final int DEFAULT_CAPACITY = 10;
	private Object[] elements;

	private int size;

	public SequenceList(int capacity) {
		elements = new Object[capacity];
	}

	public SequenceList() {
		this(DEFAULT_CAPACITY);
	}

	public void printSqList() {

		for (int i = 0; i < size; i++) {
			System.out.print(elements[i] + "   ");
		}
	}

	@SuppressWarnings("unchecked")
	public T get(int index) {

		if (size <= 0) {
			return null;
		}

		if (index < 0 || index >= size) {
			throw new IllegalArgumentException("下标参数" + index + "不合法");
		}
		return (T)elements[index];
	}

	/**
	 * 得到指定元素的第一个索引
	 *
	 * @param arr
	 * @param value
	 * @return 返回要查找的索引 查找不到返回-1
	 */
	int getElemIndex(T value) {

		for (int i = 0; i < size; i++) {
			if (value == elements[i]) {
				return i;
			}
		}

		return -1;
	}
	
	/**
	 * 更改索引index的值为value
	 * @param index  索引
	 * @param value	 更新的新值
	 */
	public void set(int index, T value){
		if (size <= 0) {
			return ;
		}

		if (index < 0 || index >= size) {
			throw new IllegalArgumentException("下标参数" + index + "不合法");
		}
		
		elements[index] = value;
	}

	/**
	 * 插入元素到指定位置
	 *
	 * @param arr
	 * @param value
	 * @param index
	 */
	public void insert(int index, T value) {
		if (index < 0 || index > size) {
			throw new IllegalArgumentException("下标参数" + index + "不合法");
		}

		ensureCapacity(size + 1);

		for (int i = size - 1; i >= index; i--) {
			elements[i + 1] = elements[i];
		}

		elements[index] = value;
		size++;
	}

	/**
	 * 删除指定位置元素
	 * 
	 * @param index
	 *            被删除元素的位置索引
	 * @return 被删除元素的值
	 */
	@SuppressWarnings("unchecked")
	T deleteElem(int index) {
		if (index < 0 || index >= size) {
			throw new IllegalArgumentException("下标参数" + index + "不合法");
		}

		Object obj = elements[index];
		for (int i = index; i < size - 1; i++) {
			elements[i] = elements[i + 1];
		}
		elements[--size] = null;
		return (T) obj;
	}

	/**
	 * 元素逆置
	 */
	public void reverse1() {

		if (size <= 1) {
			return;
		}
		reverse(0, size - 1);
	}

	/**
	 * 元素逆置
	 */
	public void reverse2() {
		if (size <= 0) {
			return;
		}

		int mid = size / 2;
		for (int i = 0; i < mid; i++) {
			Object obj = elements[i];
			elements[i] = elements[size - i - 1];
			elements[size - i - 1] = obj;
		}
	}

	/**
	 * 元素循环左移shift位
	 * 
	 * @param shift
	 *            元素左移shift个位置
	 */
	public void leftShift(int shift) {

		if (shift <= 0) {
			return;
		}

		shift = shift % size;
		reverse(0, size - 1);
		reverse(0, shift - 1);
		reverse(shift, size - 1);
	}

	private void reverse(int start, int end) {
		if (start >= end) {
			return;
		}

		while (start < end) {
			Object temp = elements[start];
			elements[start] = elements[end];
			elements[end] = temp;

			start++;
			end--;
		}
	}

	/**
	 * 顺序表中删除所有元素值为value的元素
	 * 
	 * @param value
	 *            被删除的值
	 */
	public void deleteDul(T value) {
		if (size <= 0) {
			return;
		}

		int dulNumber = 0;
		for (int i = 0; i < size; i++) {
			if (elements[i] == value) {
				dulNumber++;
			} else {
				elements[i - dulNumber] = elements[i];
			}
		}

		for (int j = size - 1; j >= size - dulNumber; j--) {
			elements[j] = null;
		}

		size = size - dulNumber;
	}

	/**
	 * 保证插入有足够的空间
	 * 
	 * @param minCapacity
	 */
	private void ensureCapacity(int minCapacity) {
		if (minCapacity - elements.length > 0) {
			grow(minCapacity);
		}
	}

	/**
	 * 空间不足时,二倍增长
	 * 
	 * @param minCapacity
	 */
	private void grow(int minCapacity) {
		int newCapacity = 2 * minCapacity;
		elements = Arrays.copyOf(elements, newCapacity);
	}
	
	public int size(){
		return size;
	}
	
	public void setSize(int size){
		this.size = size;
	}
}

 

代码下载