002.数据结构_线性结构

最新推荐文章于 2022-09-28 18:20:35 发布
最新推荐文章于 2022-09-28 18:20:35 发布
阅读量350 收藏
点赞数
分类专栏： 数据结构 c++ 文章标签： 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzq1824837536/article/details/80209164
版权

一、线性表：n个相同类型数据的有限序列（n>=0）。

    常用操作：增（尾部）、删、插、查、遍历、求表长、判断是否为空

    操作特点：可以在任意位置插入或删除一个元素。

二、顺序表：用顺序结构实现的线性表。

    Java类库中的顺序表：ArrayList

//StudIn类：定义顺序表中的数据元素
public class StudIn {
	private String name;
	private int id;
	private double score;
	public StudIn(String name,int id,double score){
		this.name=name;
		this.id=id;
		this.score=score;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public double getScore() {
		return score;
	}
	public void setScore(double score) {
		this.score = score;
	}
	@Override
	public String toString() {
		return "StudIn [姓名=" + name + ", 学号=" + id + ", 分数=" + score + "]";
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + id;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		long temp;
		temp = Double.doubleToLongBits(score);
		result = prime * result + (int) (temp ^ (temp >>> 32));
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		StudIn other = (StudIn) obj;
		if (id != other.id)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (Double.doubleToLongBits(score) != Double.doubleToLongBits(other.score))
			return false;
		return true;
	}
	
}
//StudOPeration接口：定义顺序表的数据操作
public interface StudOPeration {
	void add(StudIn node);//在尾部添加一个学生记录
	void listAll();//遍历学生记录
	void search(int index);//查询某个位置上学生的信息并输出
	int getCounts();//获取学生记录个数
	void delete(int index);//根据记录序号删除学生记录
	void delete(String name);//根据学生姓名删除学生信息
	void search(String name);//根据学生姓名查找学生信息
}

//ArrStudentl类：是一个顺序表，用来实现StudOPeration接口
public class ArrStudent implements StudOPeration{
//	StudIn[]stud=new StudIn[5];
	StudIn stud[];
	public ArrStudent(int size) {   //指定顺序表的容量
		// TODO Auto-generated constructor stub
		stud=new StudIn[size];
	}
	
	int cout=0;//记录计数器，记当前顺序表中 的记录个数
	
	@Override
	public void add(StudIn node) {  //添加纪录
		// TODO Auto-generated method stub
		int i=cout;
		stud[i]=node;
		cout++;
		if(cout==stud.length){
			System.out.println("存储空间已满");
		}
		
	}

	@Override
	public void listAll() {  //显示所有记录
		// TODO Auto-generated method stub
		try{for(int i=0;i<cout;i++){
			System.out.println(stud[i].getName()+"\t"+stud[i].getId()+"\t"+stud[i].getScore());
		}}catch(NullPointerException e){
			e.printStackTrace();
		}
	}

	@Override
	public void search(int index) {  //查询记录
		// TODO Auto-generated method stub
		if(index<=stud.length&&index>0){
			System.out.println("您查找的信息为："+stud[index-1]);
		}else{
			System.out.println("输入序号无效");
		}	
	}

	@Override
	public int getCounts() {  //获取学生记录个数
		// TODO Auto-generated method stub
		return cout;
	}

	@Override
	public void delete(int index) {
		// TODO Auto-generated method stub
		cout=cout-1;
		stud=ArrStudent.removeElementByCopy(stud, index);
		System.out.println("删除成功！");
	}
	public static StudIn[] removeElementByCopy(StudIn[] array, int position) {  
        if (position < 0 || position > array.length) {  
            throw new IndexOutOfBoundsException("the position is out of the array indices");  
        }  
        StudIn[] newArray = new StudIn[array.length - 1];  
        int index = position - 1;  
        System.arraycopy(array, 0, newArray, 0, index);  
        if (index < array.length - 1) {  
            System.arraycopy(array, index + 1, newArray, index, array.length - index - 1);  
        }  
        return newArray;  
    }  

	@Override
	public void delete(String name) {
		// TODO Auto-generated method stub
		int flag=-1;
		for(int i=0;i<cout;i++){
			if(stud[i].getName().equals(name)){
				cout=cout-1;
				stud=ArrStudent.removeElementByCopy(stud, i+1);
				System.out.println("删除成功！");
				flag=1;
			}
			if(flag==-1){
				System.out.println("没找到该学生信息！");
			}
		}
		
	}

	@Override
	public void search(String name) {
		// TODO Auto-generated method stub
		int flag=-1;
		for(int i=0;i<cout;i++){
			if(stud[i].getName().equals(name)){
				System.out.println(stud[i].toString());
				flag=1;
				break;
			}
			if(flag==-1){
				System.out.println("没有找到该学生信息");
			}
			
		}
	}

}
import java.io.*;
public class ArrStudentUser {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrStudent stud=new ArrStudent(10);
//		ArrStudent stud=new ArrStudent();
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		while(true){
			System.out.println("********学生信息管理系统********");
			System.out.println("1 添加纪录");
			System.out.println("2 显示所有记录");
			System.out.println("3 查询记录");
			System.out.println("4 删除记录");
			System.out.println("5 获取学生记录个数");
			System.out.println("6 输入学生姓名查询学生记录");
			System.out.println("7 输入学生姓名删除学生记录");
			System.out.println("0 退出\n");
			System.out.print("输入你的选择：");
			try {
				int choice=Integer.parseInt(br.readLine());
				switch (choice) {
				case 0:
					System.exit(0);
					break;
				case 1:
					System.out.println("输入学生姓名：");
					String Sname=br.readLine().toString();
					System.out.println("输入学生学号：");
					int Sid=Integer.parseInt(br.readLine());
					System.out.println("输入学生成绩：");
					int Sscore=Integer.parseInt(br.readLine());
					StudIn sd=new StudIn(Sname, Sid, Sscore);
					stud.add(sd);
					System.out.println("信息添加完毕！");
					break;
				case 2:
					System.out.println("姓名：\t学号：\t成绩：");
					try{stud.listAll();
					}catch(NullPointerException e){
						e.printStackTrace();
					}
					break;
				case 3:
					System.out.println("输入学生的位置序号:");
					int index=Integer.parseInt(br.readLine());
					stud.search(index);
					break;
				case 4:
					System.out.println("输入记录序号：");
					int index1=Integer.parseInt(br.readLine());
					stud.delete(index1);
					break;
				case 5:
					System.out.println("学生记录个数为："+stud.getCounts());
					break;
				case 6:
					System.out.println("输入学生姓名：");
					String Sname1=br.readLine();
					stud.search(Sname1);
					break;
				case 7:
					System.out.println("输入学生姓名：");
					String Dname=br.readLine();
					stud.delete(Dname);
					break;
				default:
					break;
				}
			} catch (NumberFormatException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} 
//			finally {
//				if(null!=br){
//					try {
//						br.close();
//					} catch (IOException e) {
//						// TODO Auto-generated catch block
//						e.printStackTrace();
//					}
//				}
//			}
			
		}
		
		
	}

}

三、链表：使用链式存储结构存储数据的线性表称为链表

        分为：单链表、双链表、循环单链表、双向循环链表。

        Java类库中链表：LinkedList类是一个双向链表结构，可用来作为单链表或双向链表使用

     

带头结点的循环单链表

CircList.h

//
// Created by zhangzhiqiang on 2020/7/5.
//

#ifndef DATASTRUCTURE_CIRCLIST_H
#define DATASTRUCTURE_CIRCLIST_H
#include <iostream>
using namespace std;
class LinkNode{//单链表结点
public:
    LinkNode *link;//指针域
    int data;//数据域
};

//带头结点的循环单链表
class CircList{
private:
    LinkNode *first,*last;//first指向头结点，last指向尾结点
public:
    CircList();//构造函数
    bool Insert(int &x);//将新元素x插入
    bool Remove(int i,int &x);//删除第i个位置的结点（i从1开始），将被删结点值通过引用类型x返回
    void Print();
};



#endif //DATASTRUCTURE_CIRCLIST_H


CircList.cpp

//
// Created by zhang zhiqiang on 2021/9/11.
//

#include "CircList.h"

//构造函数，初始化附加头结点的循环单链表
CircList::CircList() {
    LinkNode *headNode=new LinkNode;//分配一个头结点
    headNode->link=headNode;//link域存放的是头结点的地址
    first=headNode;//头指针指向头结点
    last=headNode;//尾指针指向头结点
}

//将新元素x插入到循环链表
bool CircList::Insert(int &x) {
    LinkNode *newNode=new LinkNode;//为新插入元素构建结点
    newNode->data=x;//数据域存放元素值
    //尾插法(新插入元素作为表尾)
    newNode->link=first;//新插入元素的结点作为尾结点，指向头结点
    last->link=newNode;//插入在最后一个结点后面
    last=newNode;//尾指针指向尾结点
    return true;
}

//删除第i个位置的结点（i从1开始），将被删结点值通过引用类型x返回
bool CircList::Remove(int i, int &x) {
    LinkNode *current;//被删除结点的前一个结点
    LinkNode *del;//被删除结点
    current=first;//先将结点指向头结点，然后遍历寻找第i个位置的前一个结点
    for (int j = 0; j < i-1; ++j) {
        current=current->link;
    }
    del=current->link;//找到删除结点
    x=del->data;//保存删除结点的元素值
    if(del==last){//删除位置为表尾结点
        current->link=first;//则current变成表尾,让其指向头结点
        last=current;//修改表尾指针
    }else{
        current->link=del->link;//重新拉链，表尾指针不变
    }
    delete del;//删除结点
    return true;
}

//打印链表元素
void CircList::Print() {
    LinkNode *current=first->link;
    do{
        cout<<current->data<<",";
        current=current->link;
    }while (current->link!=first);
    cout<<last->data;

}

顺序表

SeqList.h

//
// Created by zhangzhiqiang on 2020/5/16.
//

#ifndef DATASTRUCTURE_SEQLIST_H
#define DATASTRUCTURE_SEQLIST_H
#include <cstdlib>
#include <iostream>

//顺序表
struct SeqList{
private:
    int *data;//定义int型指针用于动态分配数组
    int maxSize;//顺序表的最大容量
    int last;//当前已存表项的最后位置（从0开始)，表空时为-1
public:
    SeqList(int size);//构造函数,size为初始化顺序表的大小
    bool IsFull();//判满
    bool IsEmpty();//判空
    bool Insert(int i,int x);//将新元素x插入到第i个位置后面
    bool Remove(int i,int &x);//删除第i个位置的元素，并通过引用类型x返回其值
    void ReSize(int newSize);//扩充顺序表，使其新数组的元素个数为newSize
};

#endif //DATASTRUCTURE_SEQLIST_H





SeqList.cpp

//
// Created by zhang zhiqiang on 2021/9/11.
//

#include "SeqList.h"

//构造函数（初始化）
SeqList::SeqList(int size) {
    maxSize=size;
    last=-1;//设置表长为空
    data=new int[size];
}
//判满
bool SeqList::IsFull() {
    return last == maxSize - 1;
}
//判空
bool SeqList::IsEmpty() {
    return last==-1;
}
//插入
bool SeqList::Insert(int i, int x) {
    if(IsFull() || i<0 || i>last+1 ){//判表满、参数i是否合理，(i>last+1)表示只能顺序存储
        return false;
    }else{
        for (int j = last; j >= i ; j--) {
            data[j+1]=data[j];//先依次后移，空出第i号位置
        }
        data[i]=x;//这里注意，若定义数组 int a[10],表示10个元素，但使用数组时，下标是0～9
        last++;//最后位置加1
        return true;
    }
}
//删除
bool SeqList::Remove(int i, int &x) {
    if (IsEmpty() || i<1 ||i>last+1){//判表空、参数i是否合理
        return false;
    }else{
        x=data[i-1];//保存第i个被删元素
        for (int j = i; j <= last; j++) {
            data[j-1]=data[j];//依次往前移，填补
        }
        last--;//最后位置减1
        return true;
    }
}
//扩充顺序表，新数组元素个数为newSize
void SeqList::ReSize(int newSize) {
    if (newSize <= 0 || newSize == maxSize) {//检查参数的合理性
        std::cout << "无效的数组大小\n";
    } else {
        int *newArray = new int[newSize];//建立新数组
        int n = last + 1;//记录原数组长度为n
        int *srcptr = data;//原数组首地址
        int *destptr = newArray;//新数组首地址
        while (n--) {
            *destptr++ = *srcptr++;//复制元素
        }
        delete[]data;//删老数组
        data = newArray;//复制新数组
        maxSize = newSize;
    }
}

带头结点的单链表

SinList.h
//
// Created by zhangzhiqiang on 2020/7/5.
//

#ifndef DATASTRUCTURE_SINLIST_H
#define DATASTRUCTURE_SINLIST_H

#include <iostream>

//单链表结点
struct LinkNode{
    int data;//数据域
    LinkNode *link;//指针域
};

//带头结点的单链表
class SinList{
private:
    LinkNode *first;//指向头结点的指针
public:
    SinList();//构造函数
    bool Insert(int &x);//将新元素x插入
    bool Remove(int i,int &x);//删除第i个位置的结点（i从1开始），将被删结点值通过引用类型x返回
    void Print();
};


#endif //DATASTRUCTURE_SINLIST_H




SinList.cpp

//
// Created by zhang zhiqiang on 2021/9/11.
//

#include "SinList.h"

//附加头结点的单链表构造函数
SinList::SinList() {
    LinkNode *headNode=new LinkNode;
    headNode->link=nullptr;
    first=headNode;
}
//插入新元素x
bool SinList::Insert(int &x) {
    LinkNode *newNode=new LinkNode;//为新插入元素构造结点
    newNode->data=x;//数据域为元素值
    //将新结点放在头结点的后面（不必区分在单链表头部或中部、尾部插入）
    newNode->link=first->link;
    first->link=newNode;
    return true;
}
//删除第i个位置的结点（i从1开始），将被删结点值通过引用类型x返回
bool SinList::Remove(int i, int &x) {
    LinkNode *del;//被删结点的指针
    LinkNode *current;//被删除结点的前一个结点
    current=first;//先将结点指向头结点，然后遍历寻找第i个位置的前一个结点
    for (int j = 0; j <i-1 ; ++j) {
        current=current->link;
    }
    del=current->link;//保存被删除结点
    current->link=del->link;//重新拉链
    x=del->data;//保存被删结点元素
    delete del;//删除del指向的结点
    return true;
}

打字员小张
关注
专栏目录
（C语言）实现顺序表的操作集（增删改查）
HYK_DJ5201314的博客
06-02 482
（C语言）实现顺序表的操作集（增删改查） 各个操作函数的定义为： List MakeEmpty()：创建并返回一个空的线性表； int Find( List L, ElementType X )：返回线性表中X的位置。若找不到则返回ERROR； bool Insert( List L, ElementType X, int P )：将X插入在位置P并返回true。若空间已满，则打印“FULL”并返回false；如果参数P指向非法位置，则打印“ILLEGAL POSITION”并返回false； bool D
数据结构之顺序表
最新发布
aaa1336的博客
10-15 3422
简单的说，线性表就是一个数组，不过实现的时候我们把这个数组放在一个结构体里面，再记录一下有效元素的个数，就可以了。从数据结构的角度来看，数据元素之间的逻辑关系是线性的，存储结构是顺序存储。
顺序表的基本操作（1）——插入操作
热门推荐
just do something
03-27 2万+
顺序表的插入运算 线性表的插入运算是指在表的第i (1≤i≤n+1)个位置，插入一个新元素x，使长度为n的线性表 ( a1​，…，ai−1​，ai​，…，an​) 变成长度为n+1的线性表( a1​，…，ai−1​，x，ai+1​，…，an​) 。 算法思想：用顺序表作为线性表的存储结构时，由于结点的物理顺序必须和结点的逻辑顺序保持一致，因此我们必须将原表中位置n-1，n-2，…，i-1上的结点，依次后移到位置n，n-1，…，i上，空出第i-1个位置，然后在该位置上插入新结点x。当i=n+1时，是指..
顺序表如何插入元素？ 看这里！！
qq_63179750的博客
09-21 3574
顺序表的插入
数据结构与算法练习题：插入元素x到顺序表以保持该表的有序性。
qq_61334455的博客
09-28 1310
数据结构 简单习题
zx.rar_数据结构_C++_Builder_
08-11
数据结构分为两大类：线性结构和非线性结构。线性结构如数组、链表、栈和队列，它们的数据元素按线性顺序排列；非线性结构如树、图和哈希表，它们的数据元素之间存在一对多或多对多的关系。理解每种数据结构的特点...
minMGN.zip_minmgn_最小二乘优化_结构最小二乘_结构非线性
07-15
结构非线性问题（Structural Nonlinear Problems）是指那些涉及非线性模型结构的问题，如非线性动态系统或非线性回归模型。解决这类问题的关键在于找到一个合适的非线性变换，使得问题可以通过迭代求解近似线性化。...
Ttf.rar_surpriseiuu_数据结构
09-20
本资料包“Ttf.rar_surpriseiuu_数据结构”包含了MATLAB代码示例和讲解材料，旨在帮助学习者深入理解线性规划及其在MATLAB中的应用。 首先，我们来看文件名中的“surpriseiuu”，这可能是一个特定的项目代号或标识...
shujujiegou.rar_线性链表_链表逆序
09-24
线性链表是一种基本的数据结构，它在计算机科学中扮演着重要的角色，特别是在处理动态数据集合时。线性链表与数组不同，不连续存储数据，而是通过节点间的指针链接来表示数据序列。本资料"shujujiegou.rar_线性链表_...
compute_mapping.rar_compute_mapping_dts_writero5t_降维_非线性降维
07-14
这些方法简单且计算效率高，但可能无法捕捉复杂的非线性结构。 非线性降维方法则更加灵活，能处理非线性数据分布。常见的非线性降维算法包括： 1. **局部线性嵌入(LLE)**：通过保持数据点的局部邻域结构来进行降维...
通过Mybatis实现对单表的增删改查-通过定义一个接口实现
Vincent
07-23 2060
Pom.xml文件 定义工程项目依赖的软件库<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apach
修改个人资料接口的总结
weixin_40214184的博客
07-05 2065
1、修改之前应该先获取到用户的登陆信息。用户登陆的时候信息会存储到缓存中，因此我们只需要在缓存中直接取出即可，主要的代码实现： /* * 获取用户的个人资料，用于编辑的接口使用 * */ @RequestMapping(value = "/getUserData.json", method = RequestMethod.POST) @ApiOperation(value = "获...
PTA1.1-顺序表基本操作
starrynightbeats的博客
09-07 3436
数据结构的第一次作业，讲顺序表的 6-1 顺序表基本操作（10 分） 本题要求实现顺序表元素的增、删、查找以及顺序表输出共4个基本操作函数。L是一个顺序表，函数Status ListInsert_Sq(SqList &L, int pos, ElemType e)是在顺序表的pos位置插入一个元素e（pos应该从1开始），函数Status ListDelete_Sq(SqL
8.接口隔离原则——面向对象设计原则
bater2356的博客
03-20 243
面向对象设计原则除了开闭原则、里氏替换原则、依赖倒置原则和单一职责原则以外，还有接口隔离原则、迪米特法则和合成复用原则。本节将详细介绍接口隔离原则。 接口隔离原则的定义 接口隔离原则（Interface Segregation Principle，ISP）要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口，让接口中只包含客户感兴趣的方法。 2002 年罗伯特·C.马丁给“接口隔离原则”的...
Java中字符串解析
面朝大海，春暖花开
12-31 1017
1、字符串不属于基本数据类型（基本数据类型有【byte,int,char,float,double,boolean,short,long】），字符串由单个或多个字符组成，本质上是字符数组，Java中提供两种实现字符串的类，分别是String、StringBuffer类。 String类 字符串的声明： 1、常量声明方式 String sName="Bob"; 2、对象声明方式 Stri
JavaWeb购物车项目
weixin_62270300的博客
04-14 1万+
项目分析： 1、购物车并不是一直放数据库 2、选择使用的技术： session： 好处:快(放在内存当中)，存对象的 坏处:占用内存，服务器意外待机数据会丢失 cookie 好处：不占用内存，存储很久 坏处：存在客户端上，只能存String,数据有泄露的风险 ...
构建SpringCloud项目时的统一规范
私は悪い人ですか的博客
02-18 1224
1.统一返回结果的格式 项目中我们会将响应封装成json返回，一般我们会将所有接口的数据格式统一， 使前端(iOS Android, Web)对数据的操作更一致、轻松。 一般情况下，统一返回数据格式没有固定的格式，只要能描述清楚返回的数据状态以及要返回的具体数据就可以。但是一般会包含状态码、返回消息、数据这几部分内容 例如，我们的系统要求返回的基本数据格式如下 { "succe...
_002_AndroidStudioOperation_AndroidStudio3.2的一些插件
poiuyppp的博客
09-11 386
现在Android的开发者基本上都使用Android Studio进行开发(如果你还在使用eclipse那也行，毕竟你乐意怎么样都行)。使用好Android Studio插件能大量的减少我们的工作量。 1.GsonFormat 快速将json字符串转换成一个Java Bean，免去我们根据json字符串手写对应Java Bean的过程。 使用方法：快捷键Alt+S也可以使用A...
Python数据结构详解：线性结构之栈
"这篇博客主要介绍了Python中的线性数据结构之一——栈，包括栈的基本概念、特性、生活中的实例以及栈的抽象数据类型的操作。同时，通过一个简单的Python类实现了一个栈的数据结构，包含了初始化、入栈、出栈、查看...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值