【数据结构_3】顺序表

一、顺序表的遍历

1.创建一个顺序表

//第一种，通过下标来实现遍历

for (int i = 0; i <list.size() ; i++) {
    System.out.print(list.get(i)+" ");
}


System.out.println();
//第二种，通过forecah来遍历
for(Integer x :list){
    System.out.print(x+" ");
}

//特别的，顺序表还可以通过迭代器来进行遍历

迭代器是什么？对于所有的线性表都有一个接口Iterable，迭代器就是用来迭代“可迭代的”对象的。

迭代表示“一小步一小步地前进，直至接近结果”。

<>尖括号里面的泛型类型应该与顺序表的泛型参数一样，从这个创建的式子中我们可见迭代器是顺序表内部内置的东西。创建的迭代器是由哪个集合类生成的，接下来的遍历就是针对这个集合类。

二、顺序表的自动扩容

假设我们给arraylist的初始容量赋值为100，那么当元素个数达到100以上的时候，arraylist就会触发自动扩容基址，自动创建一个更大的数组，把旧数组元素，复制到新数组上去，再使用新数组去替代原来的数组。

顺序表的自动扩容机制，是一个高风险的操作。如果数组本身存在的元素数量就非常多，那么，每次进行扩容的时候，就会存在大量内存数据的拷贝操作，这个操作的时间复杂度为O（N）。

ArrayList每次扩容都会扩容到原来容量的1.5倍。

【实现简单的洗牌算法】

package arrayList;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;

//首先创建一个类来表示一张牌
class Card{
    public String rank;//牌的点数

    public String suit;//花色

    public Card(String rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }//实现一个构造方法

    //实现一张牌的打印

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

public class test13 {

    //首先通过CreateDeck方法来创建一副牌
    public static ArrayList<Card> CreateDeck(){
        //首先，创建一个数组，记录四种花色
        String[] Suit =  {"♦", "♥","♣","♠"};

        //其次，由于我们还要返回一个牌堆，所以我们要创建一个顺序表用来存储扑克牌
        ArrayList<Card> deck = new ArrayList<>();


        //通过遍历来解决
        for(String suit : Suit){

            //先解决点数为2~10的牌
            for (int i = 2; i <10 ; i++) {
              //先要创建一个card对象用于存放
                Card card = new Card(i+"",suit);//通过i+”“将数字转化为字符
                deck.add(card);
            }
            //再来解决JQKA
            deck.add(new Card("J","suit"));
            deck.add(new Card("Q","suit"));
            deck.add(new Card("K","suit"));
            deck.add(new Card("A","suit"));
        }
        return deck;
        
    }



    public static void main(String[] args) {
        //Card card = new Card("9","♦");
        //System.out.println(card);
        
        ArrayList<Card> deck = CreateDeck();
        System.out.println(deck);//说明此时已经成功创建好牌堆了

        //通过shuffle方法来进行洗牌
        Collections.shuffle(deck);
        System.out.println(deck);

        //Arrrays.toString：Arrays就是一个特殊的工具类，包含了数组相关操作的一些静态方法
        //Collections差不多，也是一个特殊的工具类，只不过他提供的方法是给集合类去使用的,如果某个类，里面的全部是静态方法，那我们就称之为”工具类“
        //这些类不需要创建对象，只需要提供方法~不依赖类的属性~


        //首先创建三个玩家
        //通过二维数组的方式创建三个玩家
        ArrayList<ArrayList<Card>> players = new ArrayList<>();
        for (int i = 0; i <3 ; i++) {
            players.add(new ArrayList<>());
        }
        //现在已经创建好三个玩家了

        //此时我们可以进行发牌操作了！！
        //假设有三个玩家，每个玩家都发五张牌
        //思路为 1.首先从牌堆里面取出第0张牌，然后将这张牌按顺序发给每个玩家，一共发5轮
        for(int round =0 ;round<5;round++){

            for (int i = 0; i < 3; i++) {

                //先取出第0张牌
                Card card = deck.remove(0);
                //找到第i个玩家
                ArrayList<Card> player =players.get(i);
                //将牌送入玩家手中
                player.add(card);

            }
        }
        //此时就完成了发牌操作

        //让我们通过遍历来看一遍

        for (int i = 0; i < 3; i++) {

            System.out.println("玩家"+(i+1)+players.get(i));

        }

    }

【实现杨辉三角】

public ArrayList<ArrayList<Integer>> generate(int numRows) {
    //杨辉三角最重要的三条规律
    //1.第i行有i+1个元素 2.对于每一行来说，第0列和最后一列的元素都是1 3.针对任意的第i行第j列的元素，他的值为
    //第i-1行第j列元素的值加上第i-1行第j-1列元素之和
    //这道题要通过二维的ArrayList来解决

    //要考虑0行的情况

    ArrayList<ArrayList<Integer>> list = new ArrayList<>();

    if(numRows ==0){
        return list;
    }

    //考虑第0行
    ArrayList<Integer> firstList = new ArrayList<>();
    firstList.add(1);
    list.add(firstList);

    //考虑其他行，此时从第1行开始考虑
    for (int i = 1; i < numRows; i++) {

        //首先创建这一行
        ArrayList<Integer> row = new ArrayList<>();

        //首个元素肯定是1
        row.add(1);

        //中间通过规律来进行创建
        for (int j = 1; j < i; j++) {

            int num = list.get(i-1).get(j-1)+list.get(i-1).get(j);
            row.add(num);

        }


        //末尾元素肯定也是1
        row.add(1);


        //然后最后补药忘记把这一行加到list上去
        list.add(row);

    }


    return list;
}

（这个我自认为逻辑没错，但是leetCode上一直不给我运行成功，如果有大佬知道这段代码错误在哪里恳请指教！）

【模拟实现ArrayList】

package arrayList;

import java.util.Arrays;

public class MyArrayList {
    private String[] data = null;
    //表示有效元素的个数
    private int  size =0;
    //创建一个构造方法 似地默认的初始容量为10
    public MyArrayList(){
        data = new String[10];
    }
    //如果初始容量给的小于10，那我们要把他扩容到10
    public MyArrayList(int capacity){
        if(capacity<=10){
            capacity=10;
        }
        data = new String[capacity];
    }
/*    @Override
    public String toString() {
        return  Arrays.toString(data)  ;
    }
    */
    @Override
    public String toString() {
        //把有效字符转化为字符串，并把他们拼接到一起
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        for (int i = 0; i < size; i++) {
            stringBuilder.append(data[i]);
            if(i!=size-1) {
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("]");

        return stringBuilder.toString();
        //最后还要通过toString方法把StringBuilder转化为字符串类型

    }
    //2.实现扩容操作
    public void resize(){
        //思路：首先我们要创建一个更大的数组newData
        String[] newData = new String[data.length + data.length>>1];
        //然后将旧数组的值一个个赋值到新数组
        for (int i = 0; i < data.length ; i++) {
            newData[i]= data[i];
        }
        //然后将data的地址赋给newData
        newData = data;
    }
    //3.实现中间插入元素的操作
    public void add(int index,String elem){
        //1.首先要考虑index的值是否合法
        if(index <0 || index >size){
            //这里要考虑边界情况
            //当index = 0的时候相当于”头插“
            //当index = size 的时候相当于”尾插“
            //如果满足if条件，那我们就要抛出越界的异常
            throw new IndexOutOfBoundsException("Index: "+ index +"Size "+size);
        }
        //2.现在我们先把Index直至size的元素全部向后挪1位
        //*这里要注意，应该是从后往前移动，否则后面的值都被覆盖掉了
        for (int i = size-1; i >=index ; i++) {
           data[i+1]= data[i];
        }
        //3.最后把elem放到index这个位置就可以了
        data[index] = elem;
        //不要忘记size还要++
        size++;

    }
    //1.实现尾插操作
    public void add(String elem){
        data[size] = elem;//这里本来就有10的容量了，只不过数组里没有任何东西，所以可以这样存放，也不会触发数组越界的问题
        size++;
        //实现扩容方法
        if(size > data.length){

            resize();
        }
    }
    //我们来测试一下尾插操作
    public static void main(String[] args) {
        MyArrayList list = new MyArrayList();
        list.add("hello");
        list.add("world");
        System.out.println(list);
    }

}

*仅仅实现了一部分，剩下一部分明天补完