顺序表及应用

目录

一. 线性表

二. 顺序表

2.1 ArrayList简介

2.2 ArrayList的简单实现

2.3 ArrayList使用

1. ArrayList是一个泛型类

2.  ArrayList中定义的变量​编辑

3. ArrayList的构造方法

 4. ArrayList常见的方法

2.4 ArrayList的遍历

 2.5 ArrayList的扩容机制

2.6 二维顺序表

​编辑

 杨辉三角

 2.7 ArrayList的使用

简单的洗牌算法

---

一. 线性表

线性表（ linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表： 顺序表、链表、栈、队列...

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

二. 顺序表

顺序表是用一段 物理地址连续 的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

2.1 ArrayList简介

在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：

【 说明 】(了解)

1. ArrayList 是以泛型方式实现的，使用时必须要先实例化

2. ArrayList 实现了 RandomAccess 接口，表明 ArrayList 支持随机访问

3. ArrayList 实现了 Cloneable 接口，表明 ArrayList 是可以 clone 的

4. ArrayList 实现了 Serializable 接口，表明 ArrayList 是支持序列化的

5. 和 Vector 不同， ArrayList 不是线程安全的，在单线程下可以使用，在多线程中可以选择 Vector 或者CopyOnWriteArrayList

6. ArrayList 底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

2.2 ArrayList的简单实现

存放整型为例:

 接口:

public interface IList {
    // 新增元素,默认在数组最后新增
    public void add(int data);
    // 在 pos 位置新增元素
    public void add(int pos, int data) ;
    // 判定是否包含某个元素
    public boolean contains(int toFind) ;
    // 查找某个元素对应的位置
    public int indexOf(int toFind) ;
    // 获取 pos 位置的元素
    public int get(int pos) ;
    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) ;
    //删除第一次出现的关键字toRemove
    public void remove(int toRemove);
    //使用的元素个数
    public int size() ;
    // 清空顺序表
    public void clear() ;
    // 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
    public void display() ;
    void isFull(int[] elem);
    void isEmpty();
}

自定义异常:

public class EmptyException extends RuntimeException{
    public EmptyException(){
        super();
    }
    public EmptyException(String s){
        super(s);
    }
}

public class PosException extends RuntimeException {
    public PosException(){
        super();
    }
    public PosException(String s){
        super(s);
    }
}

MyArrayList:

import java.util.Arrays;

public class MyArrayList implements IList{
    public int[] elem;
    public int usedSize;
    public static final int DEFAULT_CAPACITY = 5;

    public MyArrayList(){
        elem = new int[DEFAULT_CAPACITY];
    }
//判断是否为空, 若为空, 扩容
    @Override
    public void isFull(int[] elem) {
        if(usedSize ==elem.length){
            this.elem = Arrays.copyOf(elem,2*elem.length);
        }
    }
    @Override
    public void add(int data) {
        isFull(this.elem);
        elem[usedSize] = data;
        usedSize++;
    }
//适用Add方法:检查pos位置的合法性
    public void checkPosOfAdd(int pos){
        if(pos<0 || pos>usedSize){//可以是usedSize位置
            throw new PosException("pos位置错误");
        }
    }

    @Override
    public void add(int pos, int data) {
        isFull(this.elem);
        checkPosOfAdd(pos);
        for (int i = usedSize-1 ; i >= pos; i++) {
            elem[i+1] = elem[i];
        }
        elem[pos] = data;
        usedSize++;
    }

    @Override
    public boolean contains(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if(elem[i] == toFind){
                return true;
            }
        }
        return false;
    }

    @Override
    public int indexOf(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if(elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }
//适用于get set方法:检查pos位置的合法性
    public void checkPosOfGet(int pos){
        if(pos<0 || pos>=usedSize){//pos位置不能为useSize
            throw new PosException("pos位置错误");
        }
    }
//判断是否为空, 若为空, 抛异常
    @Override
    public void isEmpty() {
        if(usedSize==0){
            throw new EmptyException("顺序表为空");
        }
    }

    @Override
    public int get(int pos) {
        checkPosOfGet(pos);
        isEmpty();
        return elem[pos];
    }

    @Override
    public void set(int pos, int value) {
        checkPosOfGet(pos);
        isEmpty();
        elem[pos] = value;
    }

    @Override
    public void remove(int toRemove) {
        isEmpty();
        int index = indexOf(toRemove);
        for(int i=index;i< usedSize-1 ;i++){
            elem[i] = elem[i+1];
        }
        usedSize--;
    }

    @Override
    public int size() {
        return usedSize;
    }

    @Override
    public void clear() {
        usedSize = 0;
    }

    @Override
    public void display() {
        for (int i = 0; i < usedSize; i++) {
            System.out.print(elem[i]+" ");
        }
        System.out.println(" ");
    }

}

2.3 ArrayList使用

实际上, 我们在使用顺序表时, 不需要自己定义, 我们只需要拿来用即可, 那么我们可以分析一下源码, 方便我们使用:

1. ArrayList是一个泛型类

 我们看到, ArrayList是一个泛型类, 那么我们在实例化对象时, 写法为:

ArrayList arrayList = new ArrayList<>();

2.  ArrayList中定义的变量

我们大致可以猜出:

DEFAULT_CAPACITY = 10; ---  默认容量 为10 

size   ----相当于上述我们定义的usedSize, 数组中使用的个数

其他的我们往下看:

3. ArrayList的构造方法

a. 带有一个容量参数的构造方法

b. 不带参数的构造方法

 c. 带有一个接口参数的构造方法

 ① Collection< ? extends E> 代表参数的类型

      c 代表变量

②Collection是一个接口

意味着下面的具体类都能用Collection接收

③< ? extends E>   ? 是一个通配符, 意味着传入的参数必须是E类型或E的子类类型, E表示的是原ArrayList中的参数类型

 举例:

这个构造方法的意义是: 利用另一个集合, 构造当前集合 

例:

结果为:

 也可对其进行操作:

 补充: 

1. 第一次add时, 分配了内存, 大小为10 

2. 当空间不足时需扩容, 以1.5倍扩容, 意味着第二次容量应为15

 4. ArrayList常见的方法

我们来详细了解一下subList方法:

 

当我们修改list的值, 发现:

 arrayList1的值也被修改了.

实际上, subList方法, 截取时, 不是产生了新的对象, 只是指向了原顺序表的某个下标.

2.4 ArrayList的遍历

第一种:for循环

// 使用下标 +for 遍历

for ( int i = 0 ; i < arrayL ist . size (); i ++ ) {

        System . out . print (arrayL ist . get ( i ) + " " );

}

 第二种: for-each

// 借助 foreach 遍历

for ( Integer x   : arrayList ) {

        System . out . print ( integer + " " );

}

System . out . println ();

第三种: 使用迭代器

可以使用迭代器的原因是: 继承了Iterable接口

从前往后: 

Iterator < Integer > it = arrayList .iterator ();

while ( it . hasNext ()){

        System . out . print ( it . next () + " " );

}

或

ListIterator < Integer > it = arrayList .l istIterator ();

while ( it . hasNext ()){

        System . out . print ( it . next () + " " );

}

注: ListIterator是Iterator的子类

 从后往前:

ListIterator < Integer > it = arrayList .l istIterator ();

while ( it . hasPrevious ()){

        System . out . print ( it .previous () + " " );

}

 2.5 ArrayList的扩容机制

源码了解即可, 就不在这里展示

【 总结 】

1. 检测是否真正需要扩容，如果是调用 grow 准备扩容

2. 预估需要扩容的大小

初步预估按照 1.5 倍大小扩容

如果用户所需大小超过预估 1.5 倍大小，则按照用户所需大小扩容

真正扩容之前检测是否能扩容成功，防止太大导致扩容失败

3. 使用 copyOf 进行扩容

面试题:

给出两个字符串, 将字符串1中的和字符串2相同的字符删掉, 例:  str1 = "welcome to cvte" str2 = "come"

思路: 遍历str1, 判断此字符是否出现在str2中, 若没出现, 将此字符串存到顺序表中.

2.6 二维顺序表

 语法结构:

List> ret = new ArrayList<>();

画图理解:

 添加元素:

实例:

 杨辉三角

思路:

1. 每一行的第一个数字和最后一个数是1 

2. 每一行中间的数字 假设这个数字在[ i ][ j ]位置, 那么[ i ][ j ] = [ i -1 ][ j ] +[ i -1 ][ j -1 ]

首先定义一个二维顺序表, 先将第一个数和最后一个数加入

public List> generate(int numRows) {
        List> ret = new ArrayList<>();
        for (int i = 0; i < numRows; i++) {
            List list = new ArrayList<>();
            //1. 第一个元素设为1
            list.add(1);
            //2. 中间元素

            //3. 最后一个元素设为1
            list.add(1);
            ret.set(i,list);
        }

    }

 中间元素, 首先我们要创建列下标, 并找到第i-1行, 进行[ i ][ j ] = [ i -1 ][ j ] +[ i -1 ][ j -1 ]

 public List> generate(int numRows) {
        List> ret = new ArrayList<>();
        List list = new ArrayList<>();
        list.add(1);
        ret.add(list);

        for (int i = 1; i < numRows; i++) {
            List curList = new ArrayList<>();
            //1. 第一个元素设为1
            curList.add(1);
            //2. 中间元素
            for (int j = 1; j < i; j++) {
                List prevList = ret.get(i-1);
                int x = prevList.get(j-1)+prevList.get(j);
                prevList.add(x);
            }

            //3. 最后一个元素设为1
            curList.add(1);
            ret.add(curList);
        }
        return ret;

    }

 2.7 ArrayList的使用

简单的洗牌算法

(一副扑克牌, 不包含大小王, 共4个花色, 13个数字 )

首先我们要创建一个牌对象Card, 并提供构造方法, 重写toString方法

public class Card {
    public String suit;//花色
    public int rank;//数字

    @Override
    public String toString() {
        return "Card{" +
                "suit='" + suit + '\'' +
                ", rank=" + rank +
                '}';

//若不想要本方法打印输出, 可以自定义,如:
//  return suit+rank+" ";
    }

    public Card(String suit, int rank) {
        this.suit = suit;
        this.rank = rank;
    }
}

 

下面创建一个CardGame类, 来实现对牌的操作

public class CardGame {
    public static final String[] suits = {"♠","♥","♣","♦"};
    
}

 

再创建一个Main类, 用来放main方法, 进行运行测试代码

public class Main {
    public static void main(String[] args) {
     
    }
}

 

下面实现一个买牌的操作, 即创建一副扑克牌

 //CardGame
public List butCard(){

        List cardList = new ArrayList<>();//创建一个顺序表用来存放Card,构成一副牌

        for (int i = 0; i < 4; i++) {//四个花色
            for (int j = 1; j <= 13; j++) {//13个数字
                String suit = suits[i];
                Card card = new Card(suit,j);//实例化一张牌
                cardList.add(card);//添加到顺序表中

            }
        }
        return cardList;
    }

 

下面实现一个洗牌的操作, 通过交换的方式, 每一个下标的数据和其他下标的数据进行交换

生成0~100的随机数(不包括100)

   Random random = new Random();
        int index = random.nextInt(100);

 public void shuffle(List cardList){
        Random random = new Random();
        for (int i = cardList.size()-1; i > 0; i--) {
//从后往前遍历, 让i位置和0~i的随机数位置进行交换数据
            int index = random.nextInt(i);
            swap(cardList, i,index);
        }
    }
    private static void swap(List cardList,int i,int j ){
        Card tmp = cardList.get(i);
        cardList.set(i,cardList.get(j));
        cardList.set(j,tmp);
    }

 

 下面实现一个抓牌的操作, 共三个人, 轮流抓牌, 每人抓5张

可以用二维顺序表来实现, 定义一个person顺序表, 共三个数据, 每个数据指向一个CardList

public List> getCard(List cardList){
        List person1 = new ArrayList<>();
        List person2 = new ArrayList<>();
        List person3 = new ArrayList<>();
        List> person = new ArrayList<>();
        person.add(person1);
        person.add(person2);
        person.add(person3);
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                Card card = cardList.remove(0);//没抓一张牌代表删去顺序表的第一个数据
                person.get(j).add(card);
            }
        }
        return person;

    }

完整代码+实现:

//Card.java
public class Card {
    public String suit;//花色
    public int rank;//数字

    @Override
    public String toString() {
       /* return "Card{" +
                "suit='" + suit + '\'' +
                ", rank=" + rank +
                '}';*/
        return suit+rank+" ";
    }

    public Card(String suit, int rank) {
        this.suit = suit;
        this.rank = rank;
    }
}

//CardGame.java
public class CardGame {
    public static final String[] suits = {"♠","♥","♣","♦"};

    public List butCard(){

        List cardList = new ArrayList<>();
        for (int i = 0; i < 4; i++) {
            for (int j = 1; j <= 13; j++) {
                String suit = suits[i];
                Card card = new Card(suit,j);
                cardList.add(card);
               // cardList.add(new Card(suits[i],j));  匿名对象

            }
        }
        return cardList;
    }

    public void shuffle(List cardList){
        Random random = new Random();
        for (int i = cardList.size()-1; i > 0; i--) {
            int index = random.nextInt(i);
            swap(cardList, i,index);
        }
    }
    private static void swap(List cardList,int i,int j ){
        Card tmp = cardList.get(i);
        cardList.set(i,cardList.get(j));
        cardList.set(j,tmp);
    }

    public List> getCard(List cardList){
        List person1 = new ArrayList<>();
        List person2 = new ArrayList<>();
        List person3 = new ArrayList<>();
        List> person = new ArrayList<>();
        person.add(person1);
        person.add(person2);
        person.add(person3);
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                Card card = cardList.remove(0);
                person.get(j).add(card);
            }
        }
        return person;

    }
}


//Main.java
public class Main {
    public static void main(String[] args) {
        CardGame cardGame = new CardGame();
        List ret =  cardGame.butCard();
        System.out.println("买牌:");
        System.out.println(ret);
        System.out.println("洗牌:");
        cardGame.shuffle(ret);
        System.out.println(ret);
        System.out.println("抓牌:");
        List> person = cardGame.getCard(ret);
        for (int i = 0; i < person.size(); i++) {
            System.out.println("person"+(i+1)+":"+ person.get(i));
        }
        System.out.println("剩余的牌:"+ret);
    }
}