数据结构-顺序表的顺序存储

定义：

• 用一组地址连续的存储单元依次存储线性表中每个数据元素，这种存储结构称为线性表的顺序存储结构，用这种结构表示的线性表称为顺序表。

特点：

• 用数据元素在计算机内物理位置相邻来表示线性表中数据元素之间的逻辑关系。

存储位置：

• 线性表中第i个数据元素ai的存储位置

  

• 线性表的顺序存储结构为随机存储结构

• 存储结构内存视图
  

代码表示：

• 顺序表的插入

	/**
     * 顺序表的插入
     *
     * @param arr   数组
     * @param pos   插入的位置
     * @param value 插入的值
     * @return
     */
    public static boolean listInsert(int[] arr, int pos, int value) {
     
        if (arr.length > MaxSize) {
     
            System.out.println("顺序表已满，无法继续插入数据！");
            return false;
        }

        if (pos < 1 || pos > arr.length + 1) {
     
            System.out.println("插入数据的位置无效，无法插入");
            return false;
        }

        // 因为在java中数组的大小不能动态变化的，所以只能使用新数组
        int[] newArr = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
     
            newArr[i] = arr[i];
        }

        for (int i = newArr.length - 1; i >= pos; i--) {
     
            newArr[i] = newArr[i - 1];
        }
        newArr[pos - 1] = value;
        listTraverse(newArr);
        return true;
    }

• 顺序表的删除

	/**
     * 顺序表的删除
     *
     * @param arr   数组
     * @param pos   删除的位置
     * @param value 删除的值
     * @return
     */
    public static boolean listDelete(int[] arr, int pos, int value) {
     
        if (arr.length == 0) {
     
            System.out.println("顺序表为空表，无法删除");
            return false;
        }

        if (pos < 1 || pos > arr.length) {
     
            System.out.println("删除的位置无效");
            return false;
        }

        for (int i = pos - 1; i < arr.length; i++) {
     
            if (i != arr.length - 1) {
     
                arr[i] = arr[i + 1];
            }
        }
        arr[arr.length - 1] = 0;
        listTraverse(arr);
        return true;
    }

• 获取顺序表上指定位置上的值

	/**
     * 获取顺序表上指定位置上的值
     *
     * @param arr 数组
     * @param pos 元素的位置
     * @return
     */
    public static int listFindByPos(int[] arr, int pos) {
     
        if (pos < 1 || pos > arr.length) {
     
            System.out.println("获取的位置无效");
            return -1;
        }
        return arr[pos - 1];
    }

• 获取顺序表上指定元素的位置

	/**
     * 获取顺序表上指定元素的位置
     *
     * @param arr   数组
     * @param value 查找的值
     * @return
     */
    public static int listFindByValue(int[] arr, int value) {
     
        if (arr.length == 0) {
     
            System.out.println("顺序表为空表，无法获取元素的位置");
            return -1;
        }

        for (int i = 0; i < arr.length; i++) {
     
            if (arr[i] == value) {
     
                return i + 1;
            }
        }

        return -1;
    }

• 遍历顺序表

	/**
     * 遍历顺序表
     *
     * @param arr 数组
     */
    public static void listTraverse(int[] arr) {
     
        for (int i = 0; i < arr.length; i++) {
     
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }

• main方法

public static void main(String[] args) {
     
        // 固定演示的数组的长度
        int[] arr = new int[7];
        // 添加测试的数据
        testData(arr);
        // 遍历
        listTraverse(arr);
        // 插入数据
        listInsert(arr, 3, 100);
        // 删除数据
        //listDelete(arr, 3, 50);
        // 获取指定位置的值
        System.out.println(listFindByPos(arr, 5));
        System.out.println(listFindByValue(arr, 20));

        System.out.println();
    }

    public static void testData(int[] arr) {
     
        arr[0] = 30;
        arr[1] = 10;
        arr[2] = 50;
        arr[3] = 20;
        arr[4] = 60;
        arr[5] = 70;
        arr[6] = 90;
    }

demo代码：

package test;

public class Test {
     

    private static final int MaxSize = 20;

    public static void main(String[] args) {
     
        // 固定演示的数组的长度
        int[] arr = new int[7];
        // 添加测试的数据
        testData(arr);
        // 遍历
        listTraverse(arr);
        // 插入数据
        listInsert(arr, 3, 100);
        // 删除数据
        //listDelete(arr, 3, 50);
        // 获取指定位置的值
        System.out.println(listFindByPos(arr, 5));
        System.out.println(listFindByValue(arr, 20));

        System.out.println();
    }

    public static void testData(int[] arr) {
     
        arr[0] = 30;
        arr[1] = 10;
        arr[2] = 50;
        arr[3] = 20;
        arr[4] = 60;
        arr[5] = 70;
        arr[6] = 90;
    }

    /**
     * 顺序表的插入
     *
     * @param arr   数组
     * @param pos   插入的位置
     * @param value 插入的值
     * @return
     */
    public static boolean listInsert(int[] arr, int pos, int value) {
     
        if (arr.length > MaxSize) {
     
            System.out.println("顺序表已满，无法继续插入数据！");
            return false;
        }

        if (pos < 1 || pos > arr.length + 1) {
     
            System.out.println("插入数据的位置无效，无法插入");
            return false;
        }

        // 因为在java中数组的大小不能动态变化的，所以只能使用新数组
        int[] newArr = new int[arr.length + 1];
        for (int i = 0; i < arr.length; i++) {
     
            newArr[i] = arr[i];
        }

        for (int i = newArr.length - 1; i >= pos; i--) {
     
            newArr[i] = newArr[i - 1];
        }
        newArr[pos - 1] = value;
        listTraverse(newArr);
        return true;
    }

    /**
     * 顺序表的删除
     *
     * @param arr   数组
     * @param pos   删除的位置
     * @param value 删除的值
     * @return
     */
    public static boolean listDelete(int[] arr, int pos, int value) {
     
        if (arr.length == 0) {
     
            System.out.println("顺序表为空表，无法删除");
            return false;
        }

        if (pos < 1 || pos > arr.length) {
     
            System.out.println("删除的位置无效");
            return false;
        }

        for (int i = pos - 1; i < arr.length; i++) {
     
            if (i != arr.length - 1) {
     
                arr[i] = arr[i + 1];
            }
        }
        arr[arr.length - 1] = 0;
        listTraverse(arr);
        return true;
    }

    /**
     * 获取顺序表上指定位置上的值
     *
     * @param arr 数组
     * @param pos 元素的位置
     * @return
     */
    public static int listFindByPos(int[] arr, int pos) {
     
        if (pos < 1 || pos > arr.length) {
     
            System.out.println("获取的位置无效");
            return -1;
        }
        return arr[pos - 1];
    }

    /**
     * 获取顺序表上指定元素的位置
     *
     * @param arr   数组
     * @param value 查找的值
     * @return
     */
    public static int listFindByValue(int[] arr, int value) {
     
        if (arr.length == 0) {
     
            System.out.println("顺序表为空表，无法获取元素的位置");
            return -1;
        }

        for (int i = 0; i < arr.length; i++) {
     
            if (arr[i] == value) {
     
                return i + 1;
            }
        }

        return -1;
    }

    /**
     * 遍历顺序表
     *
     * @param arr 数组
     */
    public static void listTraverse(int[] arr) {
     
        for (int i = 0; i < arr.length; i++) {
     
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }
}