顺序表是一种线性表的存储结构，是指数据类型相同的元素在物理上按照顺序紧密地存储在一块连续的内存空间中。
大概就长这样：
我们可以用java的数组来模拟一个顺序表【注：这里默认的元素类型是int，如果想换成其他类型的数据也可以使用泛型类代替】
public class ArraySeqList {
//默认的初始化数组大小 为10 .
private static final int DEFAULT_CAPACITY = 10;
// 定义一个数组用来表示顺序表
private int[] arrSqList;
// 顺序表的实际长度
private int size;
// 无参构造方法，默认创建一个容量为10的顺序表
public ArraySeqList() {
this.arrSqList = new int[DEFAULT_CAPACITY];
this.size = 0;
}
// 有参构造方法，会根据参数生成指定容量的顺序表
public ArraySeqList(int length){
this.arrSqList = new int[length];
this.size = 0;
}
// 判空处理
public boolean isEmpty(){
return size==0;
}
// 判满处理
public boolean isFull(){
return size==arrSqList.length;
}
// 打印顺序表
public void display(){
if(size==0){
return;
}
for (int i = 0; i < size-1; i++) {
System.out.print(arrSqList[i]+" -> ");
}
System.out.println(arrSqList[size-1]);
}
// 扩容处理，默认每次扩容1.5倍，
public void reSize(){
int[] newSqList = new int[arrSqList.length+(arrSqList.length>>1)];
// System.arraycopy()方法将原顺序表数组 arrSqList 中的元素复制到新顺序表数组 newSqList 中
System.arraycopy(arrSqList,0,newSqList,0,size);
arrSqList = newSqList;
}
// 输出顺序表长度
public int getSize(){
return this.size;
}
// 快速生成一个顺序表
public void createSeqList(int[] arr){
if(arr==null){
return;
}else if(arr.length>=this.arrSqList.length){
this.reSize();
}
for (int i = 0; i < arr.length; i++) {
this.arrSqList[i] = arr[i];
size++;
}
}
}
这样的话我们就获得了一个顺序表类，我们还能对顺序表进行一些基本操作：
- 在尾部插入元素
public void insertElement(int element){
// 先进行判满处理
if(this.isFull()){
this.reSize();
}
size++;
arrSqList[size-1] = element;
}
- 在指定位置插入元素
public void insertToIndex(int index,int element){
// 要先进行参数合法性校验
if(index<=0 || index>arrSqList.length || index-size>=2){
try {
throw new Exception("插入的位置异常");
} catch (Exception e) {
e.printStackTrace();
return;
}
}
// 再进行判满处理
if(this.isFull()){
this.reSize();
}
for (int i = size; i >= index ; i--) {
arrSqList[i] = arrSqList[i-1];
}
arrSqList[index-1]=element;
size++;
}
- 删除元素，删除最后一个元素
public void deleteElement(){
// 先进行判空处理
if(this.isEmpty()){
return;
}
size--;
this.arrSqList[size]=0;
}
- 删除指定位置元素
public void deleteInIndex(int index){
// 先进行判空处理
if(this.isEmpty()){
return;
}
if(index<=0 || index>size ){
try {
throw new Exception("删除的位置异常");
} catch (Exception e) {
e.printStackTrace();
return;
}
}
size--;
for(int i = index-1;i<size;i++){
this.arrSqList[i] = this.arrSqList[i+1];
}
}
- 修改指定位置元素
public void updateByIndex(int index,int element){
// 要先进行参数合法性校验
if(index<=0 || index>arrSqList.length || index-size>=2){
try {
throw new Exception("修改的位置异常");
} catch (Exception e) {
e.printStackTrace();
return;
}
}
if(isEmpty()){
return;
}
this.arrSqList[index-1] = element;
}
- 不考虑重复元素，查找顺序表中元素x出现的位置，这里采用二分法
public void searchElemet(int element){
int low = 0;
int high = this.arrSqList.length-1;
int mid;
int l;
int r;
LinkedList result = new LinkedList();
while (low<=high){
mid = (low+high)/2;
if(arrSqList[mid]==element){
l = mid;
r = mid;
while ((l-1)>=0 && arrSqList[l-1]==element){
result.add(l);
l--;
}
result.add(mid+1);
while ((r+1)<arrSqList.length && arrSqList[r+1]==element){
result.add(r+2);
r++;
}
System.out.print("元素"+element+"在顺序表中的位置为：");
for(Object i:result){
System.out.print(i);
}
System.out.println();
return;
}else if(arrSqList[mid]>element){
high = mid-1;
}else if(arrSqList[mid]<element){
low = mid+1;
}
}
if(result.size()==0){
System.out.println("该顺序表不存在元素"+element);
}
}
- **考虑重复元素，查找元素x在顺序表出现位置**
```java
public List searchElemets(int element){
if(this.isEmpty()){
return null;
}
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < size; i++) {
if(element == this.arrSqList[i]){
list.add(i+1);
}
}
if (list.size()==0){
return null;
}else{
// System.out.print("元素"+element+"在顺序表中出现的位置为：");
// for (Integer i:list) {
// System.out.print(i+" ");
// }
// System.out.println();
return list;
}
}
- 删除顺序表中相同元素
public void deleteSameElement(){
if(this.isEmpty()){
return;
}
HashMap<Integer,Integer> hashMap = new HashMap();
for (int i = 0; i < size; i++) {
hashMap.put(arrSqList[i],i);
}
for (Map.Entry<Integer, Integer> entry : hashMap.entrySet()) {
List<Integer> list = this.searchElemets(entry.getKey());
if(list!=null && list.size()>=2){
for (int i = 1; i < list.size(); i++) {
this.deleteInIndex(list.get(i));
}
}
}
}
- 将顺序表元素置逆
public void reverseSeqList(){
if(this.isEmpty()){
return;
}
if(this.arrSqList.length-this.size <= 1){
this.reSize();
}
for (int i = 0; i < size/2; i++) {
this.arrSqList[size] = this.arrSqList[size-1-i];
this.arrSqList[size-1-i] = this.arrSqList[i];
this.arrSqList[i] = this.arrSqList[size];
}
}
测试代码
public class ArraySeqListTest {
public static void main(String[] args) {
ArraySeqList seqList = new ArraySeqList();
seqList.createSeqList(new int[] {1,2,3,4,5,6,7,8});
seqList.display();
seqList.insertElement(9);
seqList.insertToIndex(5,5);
seqList.insertToIndex(5,6);
seqList.deleteInIndex(5);
seqList.updateByIndex(5,6);
seqList.searchElemet(6);
seqList.searchElemets(6);
seqList.display();
seqList.deleteSameElement();
seqList.reverseSeqList();
seqList.display();
}
}
全部代码
package com.DataStructures.LinearList.SequenceList;
import java.util.*;
/**
* @Description: 基于数组的顺序表
*/
public class ArraySeqList {
//默认的初始化数组大小 为10 .
private static final int DEFAULT_CAPACITY = 10;
private int[] arrSqList;
private int size;
public ArraySeqList() {
this.arrSqList = new int[DEFAULT_CAPACITY];
this.size = 0;
}
public ArraySeqList(int length){
this.arrSqList = new int[length];
this.size = 0;
}
public int[] getArrSqList() {
return arrSqList;
}
// 判空处理
public boolean isEmpty(){
return size==0;
}
// 扩容处理
public void reSize(){
int[] newSqList = new int[arrSqList.length+(arrSqList.length>>1)];
System.arraycopy(arrSqList,0,newSqList,0,size);
arrSqList = newSqList;
}
// 判满处理
public boolean isFull(){
return size==arrSqList.length;
}
// 输出顺序表
public void display(){
if(size==0){
return;
}
for (int i = 0; i < size-1; i++) {
System.out.print(arrSqList[i]+" -> ");
}
System.out.println(arrSqList[size-1]);
}
// 输出顺序表长度
public int getSize(){
return this.size;
}
public void createSeqList(int[] arr){
if(arr==null){
return;
}else if(arr.length>=this.arrSqList.length){
this.reSize();
}
for (int i = 0; i < arr.length; i++) {
this.arrSqList[i] = arr[i];
size++;
}
}
// 插入元素，插入尾部
public void insertElement(int element){
if(this.isFull()){
this.reSize();
}
size++;
arrSqList[size-1] = element;
}
// 在指定位置插入元素
public void insertToIndex(int index,int element){
if(index<=0 || index>arrSqList.length || index-size>=2){
try {
throw new Exception("插入的位置异常");
} catch (Exception e) {
e.printStackTrace();
return;
}
}
if(this.isFull()){
this.reSize();
}
for (int i = size; i >= index ; i--) {
arrSqList[i] = arrSqList[i-1];
}
arrSqList[index-1]=element;
size++;
}
// 删除元素，删除最后一个元素
public void deleteElement(){
if(this.isEmpty()){
return;
}
size--;
this.arrSqList[size]=0;
}
// 删除指定位置元素
public void deleteInIndex(int index){
if(this.isEmpty()){
return;
}
if(index<=0 || index>size ){
try {
throw new Exception("删除的位置异常");
} catch (Exception e) {
e.printStackTrace();
return;
}
}
size--;
for(int i = index-1;i<size;i++){
this.arrSqList[i] = this.arrSqList[i+1];
}
}
// 修改指定位置元素
public void updateByIndex(int index,int element){
if(index<=0 || index>arrSqList.length || index-size>=2){
try {
throw new Exception("修改的位置异常");
} catch (Exception e) {
e.printStackTrace();
return;
}
}
if(isEmpty()){
return;
}
this.arrSqList[index-1] = element;
}
// 查找顺序表中x出现的位置，二分法
public void searchElemet(int element){
int low = 0;
int high = this.arrSqList.length-1;
int mid;
int l;
int r;
LinkedList result = new LinkedList();
while (low<=high){
mid = (low+high)/2;
if(arrSqList[mid]==element){
l = mid;
r = mid;
while ((l-1)>=0 && arrSqList[l-1]==element){
result.add(l);
l--;
}
result.add(mid+1);
while ((r+1)<arrSqList.length && arrSqList[r+1]==element){
result.add(r+2);
r++;
}
System.out.print("元素"+element+"在顺序表中的位置为：");
for(Object i:result){
System.out.print(i);
}
System.out.println();
return;
}else if(arrSqList[mid]>element){
high = mid-1;
}else if(arrSqList[mid]<element){
low = mid+1;
}
}
if(result.size()==0){
System.out.println("该顺序表不存在元素"+element);
}
}
// 查找所有相同元素位置
public List searchElemets(int element){
if(this.isEmpty()){
return null;
}
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < size; i++) {
if(element == this.arrSqList[i]){
list.add(i+1);
}
}
if (list.size()==0){
return null;
}else{
// System.out.print("元素"+element+"在顺序表中出现的位置为：");
// for (Integer i:list) {
// System.out.print(i+" ");
// }
// System.out.println();
return list;
}
}
// 删除顺序表中相同元素
public void deleteSameElement(){
if(this.isEmpty()){
return;
}
HashMap<Integer,Integer> hashMap = new HashMap();
for (int i = 0; i < size; i++) {
hashMap.put(arrSqList[i],i);
}
for (Map.Entry<Integer, Integer> entry : hashMap.entrySet()) {
List<Integer> list = this.searchElemets(entry.getKey());
if(list!=null && list.size()>=2){
for (int i = 1; i < list.size(); i++) {
this.deleteInIndex(list.get(i));
}
}
}
}
// 将顺序表元素置逆
public void reverseSeqList(){
if(this.isEmpty()){
return;
}
if(this.arrSqList.length-this.size <= 1){
this.reSize();
}
for (int i = 0; i < size/2; i++) {
this.arrSqList[size] = this.arrSqList[size-1-i];
this.arrSqList[size-1-i] = this.arrSqList[i];
this.arrSqList[i] = this.arrSqList[size];
}
}
}
561
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
