1.顺序表的基本介绍

顺序表在内存中的存储是连续的，它是线性表中的其中一种，使用顺序表可以对数据进行增删查改。

2.顺序表的模拟实现

2.1 常见的功能

// 新增元素,默认在数组最后新增
public void add(E data) { }
// 在 pos 位置新增元素
public void add(int pos, E data) { }
// 判定是否包含某个元素
public boolean contains(E toFind) { return true; }
// 查找某个元素对应的位置
public int indexOf(int toFind) { return -1; }
// 获取 pos 位置的元素
public E get(int pos) { return null; }
// 给 pos 位置的元素设为 value
public void set(int pos, E value) { }
//删除第⼀次出现的关键字key
public void remove(E toRemove) { }
// 获取顺序表⻓度
public int size() { return 0; }
// 清空顺序表
public void clear() { }
// 打印顺序表，注意：该⽅法并不是顺序表中的⽅法，为了⽅便看测试结果给出的
public void display() { }

2.2 基本框架

顺序表在内存中的存储是连续的，可以理解为顺序表在底层存放类似于数组的存放，所以在模拟实现时要定义一个数组，在增删除查改的过程中数据的实际存储会变化，可以再定义一个变量统计实际顺序表中存储的元素个数。

//顺序表
public class myArrayList<E> {public Object[] arrays;//存放数据public int usedSize;//统计个数public static int initialCapacity = 5;//默认容量public myArrayList(){//创建同时定义大小arrays = new Object[initialCapacity];}//方法// 新增元素,默认在数组最后新增public void add(E data) { }// 在 pos 位置新增元素public void add(int pos, E data) { }// 判定是否包含某个元素public boolean contains(int toFind) { return true; }// 查找某个元素对应的位置public int indexOf(E toFind) { return -1; }// 获取 pos 位置的元素public E get(int pos) { return null; }// 给 pos 位置的元素设为 valuepublic void set(int pos, E value) { }//删除第⼀次出现的关键字keypublic void remove(int toRemove) { }// 获取顺序表⻓度public int size() { return 0; }// 清空顺序表public void clear() { }// 打印顺序表，注意：该⽅法并不是顺序表中的⽅法，为了⽅便看测试结果给出的public void display() { }
}

2.3 方法的实现

2.3.1 add方法

 private void add_capacity(Object[] arrays){//二倍扩容arrays = Arrays.copyOf(arrays,arrays.length * 2);}// 新增元素,默认在数组最后新增public void add(E data) { //1.添加元素前需要判断是否容量是否未满if(usedSize == arrays.length){//如果容量已满扩容add_capacity(arrays);}//2.增加元素arrays[usedSize] = data;usedSize++;//下次增加的下标}

2.3.2 size方法

// 获取顺序表⻓度public int size() { //返回usedSize,实际使用的长度return usedSize;}

2.3.3 display方法

// 打印顺序表，注意：该⽅法并不是顺序表中的⽅法，为了⽅便看测试结果给出的public void display() {//1.判断是否为空if(usedSize == 0){return;//无需打印}//2.打印for (int i = 0; i < arrays.length; i++) {System.out.print(arrays[i] + " ");}}

2.3.4 add（int pos，E data)方法

public class PosillegalException extends RuntimeException{public PosillegalException() {}public PosillegalException(String message) {super(message);}
}

 // 在 pos 位置新增元素public void add(int pos, E data) {//1.判断是否需要扩容if(usedSize == arrays.length){add_capacity(arrays);}//2.坐标的使用需要判断是否合法if(pos < 0 || pos > usedSize){throw new PosillegalException("坐标非法：" + pos);}//3.增加:将pos位置后面的元素往后移动，再增加for (int i = usedSize - 1;i <= pos;i--){arrays[usedSize] = arrays[usedSize + 1];}arrays[pos] = data;usedSize++;//元素+1}

2.3.5 remove方法

 //删除第⼀次出现的关键字keyprivate int search(E toRemove){for (int i = 0; i < arrays.length; i++) {if(arrays[i] == toRemove){return i;}}return -1;}public void remove(E toRemove) {//1.遍历数组查询是否存在int pos = search(toRemove)if (pos == -1) {System.out.println(toRemove + "不存在该元素！");return;}//2.在指定下标开始，从前往后覆盖for (int i = pos; i < usedSize - 1; i++) {arrays[i] = arrays[i + 1];}//3.元素减一usedSize--;}

2.3.6 get方法

// 获取 pos 位置的元素public E get(int pos) { //1.判断坐标是否合法if(pos < 0 || pos >= usedSize){throw new PosillegalException("坐标非法：" + pos);}//2.返回return (E)arrays[pos]; }

2.3.7 contain方法

    // 判定是否包含某个元素public boolean contains(E toFind) {//1.判断是否为空if(usedSize == 0) return false;//2.调用search方法int pos = search(toFind);//3.判断if(pos == -1) return false;else return true;}

2.3.8 indexOf方法

 // 查找某个元素对应的位置private boolean isEmpty(){return usedSize == 0;}public int indexOf(E toFind) { //1.判断是否为空if(isEmpty()) return -1;//2.使用searchreturn search(toFind);}

2.3.9 set方法

   // 给 pos 位置的元素设为 valuepublic void set(int pos, E value) {//1.判断坐标是否合法if(pos < 0 || pos >= usedSize){throw new PosillegalException("坐标非法："+ pos);}//2.考虑是否扩容if(usedSize == arrays.length){add_capacity(arrays);}//3.设置arrays[pos] = value;}

2.3.10 clear方法

 // 清空顺序表public void clear() {//数组中的元素是E类型（泛型），有可能是引用数据类型//需要将元素设置为nullfor (int i = 0; i < usedSize; i++) {arrays[i] = null;}//将数组引用设置为nullarrays = null;}

2.4方法的使用

public class Main{public static void main(String[] args) {myArrayList<Integer> myArrayList = new myArrayList<>();myArrayList.add(1);//增加myArrayList.add(1,2);myArrayList.display();//展示System.out.println("=====");myArrayList.remove(2);//移除myArrayList.set(0,3);//设置boolean ret = myArrayList.contains(1);//查询是否包含System.out.println(ret);int pos = myArrayList.indexOf(0);//查找位置System.out.println(pos);int e = myArrayList.get(0);//获取System.out.println(e);myArrayList.clear();//回收顺序表myArrayList.display();}
}

3.顺序表的应用

顺序表是连续存储的一块内存空间，在游戏中使用比较广泛，利用顺序表可以实现简单的洗牌算法

3.1 创建卡牌

//牌
public class Card {public int rank;//牌值public String suit;//花色//重写toString方法@Overridepublic String toString() {return  String.format("%s %d",suit,rank);}
}

3.2 牌的实现

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;/**/
public class CardDemo {//花色public static String[] Suit = {"♦","♣","♥","♠"};//使用顺序表实现一副牌（不包含大小王）public List<Card> buyDeck(){List<Card> deck = new ArrayList<>(52);for (int i = 0; i < 4; i++) {//花色for (int j = 1; j <= 13; j++) {//牌值String suit = Suit[i];int rank = j;Card card = new Card();card.suit = suit;card.rank = rank;deck.add(card);}}return deck;}//打乱顺序:生成随机坐标，与指定坐标交换private static void swap(List<Card> deck,int i,int j ){Card card = deck.get(i);deck.set(i,deck.get(j));deck.set(j,card);}private static List<Card> shuffle(List<Card> deck){Random random = new Random();int j = random.nextInt(52);//0 - 51for (int i = deck.size() - 1; i >= 0 ; i--) {swap(deck,i,j);}return deck;}}

简单测试实现的排序

 public static void main(String[] args) {CardDemo cardDemo = new CardDemo();List<Card> deck = cardDemo.buyDeck();System.out.println(deck);//洗牌前deck = CardDemo.shuffle(deck);System.out.println(deck);//洗牌后}

3.3 发牌

 public static void main(String[] args) {CardDemo cardDemo = new CardDemo();List<Card> deck = cardDemo.buyDeck();System.out.println(deck);//洗牌前deck = CardDemo.shuffle(deck);System.out.println(deck);//洗牌后List<List<Card>> hand = new ArrayList<>();hand.add(new ArrayList<>());hand.add(new ArrayList<>());hand.add(new ArrayList<>());//发牌:一共发5轮，一轮每人发一张for (int i = 0; i < 5; i++) {for (int j = 0; j < 3; j++) {hand.get(j).add(deck.remove(0));}}//第一个人的牌System.out.println(hand.get(0));//第二个人的牌System.out.println(hand.get(1));//第三个人的牌System.out.println(hand.get(2));//剩余的牌System.out.println(deck);}}

4.代码链接

顺序表的使用