Java 顺序表的基本操作（增删查改，扩容，冒泡排序，逆序）_java顺序表的基本操作

package list;
 
 
public class Seqlist {
   private  Object[] elements;
   private static int  size ;//将size作为数组elements容器
   public Seqlist(int capacity){ 
	   size = 0;
	   elements = new Object[capacity];
   }
   public Seqlist() {
	   this(10);
   }

检查数据是否规范

//检查index是否合法
	private void checkIndexforAdd(int index) {
		if(index<0||index>size) {//index在【0，size】范围
			throw new IllegalArgumentException(" Index Error[0,size]");
		}
	}

toString()方法的重写--目的是为了使数据更加直观的显示

@Override
	public String toString() {//重写toSring()方法
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		for(int i = 0;i<size;i++) {
			sb.append(elements[i]);//追加数据进入数组中，并将数组的数据打印追加
			if(i!=size-1) {
				sb.append(",");
			}
		}
		sb.append("]");
		return sb.toString();
	}

根据下标增加数据

public void add(int index ,Object x) {
		    //添加add方法
		    //index属性代表位置下标，x代表位置下标所对应的数据
			checkIndexforAdd(index);
			/*扩容
			1.重新申请一个数组temp,并且数组容器为elements的两倍（扩容）
			2.将原数组的数据赋值给新的数组  
			3.新数组赋值给原数组*/
			if(size==elements.length) {
				Object[] temp = new Object[2*size];
				for(int i = 0;i<size;i++) {
					temp[i] = elements[i];
				}
				elements = temp;
			}
				for(int i = size-1; i>= index ; i--) {
					//范围[index,size-1],在此范围内，i步长-1，遍历这个范围内的数据
					elements[i+1] = elements[i];
				}
				 //从最后一个往前数，后面的数据依次等于前面的数据，并把每个数据往后移动一位
				 //i>= index不成立时，退出循环结构
				elements[index] = x;//数组下标对应的数为x
				size++;//数组长度需要多一位
				System.out.println("添加的数据:"+"["+index+","+x+"]");
			    //实现头插法	
	   
	   }

根据下标删除数据

public int delete(int index) {//delete()方法，使通过删除下标来删除下标所对应的数据
		checkIndexforAdd(index);
		if(isEmpty()) {System.out.print("Array Error,顺序表错误");}
		else 
		for(int i = index+1 ;i<=size-1;i++) {
			/*范围在[index-1,size-1]之中,
			一定要确定index是我们赋予的需要删除数据的参数，在index位上的值我们是不需要的
			所以前后交换数据时最小一位并不是index，而是index的后一位，
			index+1将数据传给index这个位置，index下标被删除了。
			步长为1，在此范围内，i++
			*/
			elements[i-1]=elements[i];
			//将数据全部往前移动一位,将删除一位
		}
		size--;
		//删除一位
		return index;
	}

根据数据判定是否存在，根据下标查询数据

//contain方法--如果包含这个key数据，输出false,否则输出true
public boolean contain(int key) {
    	for(int i=0;i<size;i++){
    		if((int)key==(int)elements[i]){
    			return false;}
    	}
    	    
		return true;
    }

public int find(int index) {//find()查找方法,通过查找下标得到数据
		if(isEmpty()) {System.out.print("Array Error,没有该数据");}
		else {
			checkIndexforAdd(index);
			if(elements[index]!=null) {
				System.out.println("查找的数据:"+"["+index+","+elements[index]+"]");	
			}
		}
		return index;
	}

逆序输出（可以使用二分法）

public void reverse() {
		Object[] temp= new Object[size];
		for (int i = 0; i < size; i++) {
		  temp[i]=elements[size-i-1];
	}
	    elements=temp;
	    for (int i = 0; i < size; i++) {
			System.out.print(elements[i]+" ");
		}
	}

二分法：

int arr[]= {1,2,3,4,5};
		int middle=arr.length/2;
		for (int i = 0; i <middle; i++) {
			    int temp=arr[i];
				arr[i]=arr[arr.length-i-1];
				arr[arr.length-i-1]=temp;
		}
      for (int i = 0; i < arr.length; i++) {
 		System.out.print(arr[i]+" ");
	}

下标数据修改

public boolean update(int index,Object x) {//update()方法,通过查找下标，修改数据
		if(isEmpty()) {System.out.print("Array Error,顺序表错误");}
		else {
		for(int i = 0;i<size-1;i++) {
			if(i==index) {
				elements[i] = x ;
				System.out.println("修改的数据为"+"["+index+","+x+"]");
			}
		}	
		}
		return true;
	}

排序（这个很简单，我在这里是用的是交换排序中的冒泡排序）

public Object delLast() {//delLast()方法代表倒排序方法，数组中数据的排序
    	if(isEmpty()) {System.out.print("Array Error,顺序表错误");}
    	else {
		Object temp;//创造出一个object对象，作为容器和可变变量
		for(int i=0;i<size;i++)	{
			 for(int j=i+1;j<size;j++) {//两次遍历,一定要确定j=i+1
		       if((int)elements[i]<= (int)elements[j]) {//将object类型强制转换为int
		    	   //冒泡排序，将最小的赋给第一位，然后遍历的都往前一位比较
		          temp=elements[i];
		          elements[i]=elements[j];
		          elements[j]=temp;
		    	  }
		      }
		}
    	}
		return 0;
	}

main（）方法调用各种方法

public static void main(String[] args) {
		Seqlist list = new Seqlist();//创造一个对象，再创建一个随机数组
		for(int i = 0;i<9;i++) {
			int x = (int)Math.round(Math.random()*10);//启用随机数，建立[0,100]的数据数组
			list.add(i,x);//对象调用add(index,x)方法，参数index变为i,x变为x
		}
		System.out.println(list);
		list.len();
		list.find(3);//启用find()查找方法
		list.contain(7);
		System.out.println("----------------------------");
     	list.add(2, 89);//启用add()添加方法
     	System.out.println(list);
     	System.out.println("----------------------------");
		list.delete(1);//启用delete方法
		System.out.println(list);
		System.out.println("----------------------------");
		list.update(6, 80);//启用update()修改方法
		System.out.println(list);
		System.out.println("----------------------------");
        list.delLast();
        System.out.println("倒序输出："+list);
		System.out.println("----------------------------");
		list.delFirst();
		System.out.println("正序输出："+list);
		System.out.println("----------------------------");	
		System.out.print("逆序：");
		list.reverse();
		list.clear();
		System.out.println("数据清空："+list);
	}

结果展示：