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

1. 数组的初始化

   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);
      }

2. 检查数据是否规范

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

3. 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();
   	}

4. 根据下标增加数据

   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+"]");
   			    //实现头插法	
   	   
   	   }

5. 根据下标删除数据

   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;
   	}

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

   //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;
   	}

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

   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]+" ");
   	}

8. 下标数据修改

   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;
   	}

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

   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;
   	}

10. 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);
    	}
    

11. 结果展示：