1.java实现节点

/**
* 节点
* @luminous-xin
* @param <T>
*/
public class Node<T> {
T data;
Node<T> next;
public Node(Node<T> n){
next = n;
}
public Node(T obj,Node<T> n){
data = obj;
next = n;
}
public T getData(){
return data;
}
public Node<T> getNext(){
return next;
}
}

2.java实现链表

/**
* 链表
* @author luminous-xin
* @param <T>
*/
public class ListLink<T> {
//头指针
private Node<T> head;
//单链表的长度
private int length; //构造一个空的链表
public ListLink() {
length = 0;
head = new Node<T>(null);
} //获取链表头节点的位置
public Node<T> getHead() {
return head;
} //在链表中插入一个元素
public boolean add(T obj, int pos) {
if (pos < 1 || pos > length + 1) {
System.out.println("pos值不合法");
return false;
}
int num = 1;
Node<T> p = head, q = head.next;
while (num < pos) {
p = q;
q = q.next;
num++;
}
p.next = new Node<T>(obj, q);
length++;
return true; } //删除链表中某各元素
public T remove(int pos) {
if (isEnpty()) {
System.out.println("链表为空表");
return null;
}
if (pos < 1 || pos > length + 1) {
System.out.println("pos值不合法");
return null;
}
int num = 1;
Node<T> p = head, q = head.next;
while (num < pos) {
p = q;
q = q.next;
num++;
}
p.next = q.next;
length--;
return q.data;
} //获取链表中一个元素的值
public T value(int pos) {
if (isEnpty()) {
System.out.println("链表为空表");
return null;
}
if (pos < 1 || pos > length + 1) {
System.out.println("pos值不合法");
return null;
}
int num = 1;
Node<T> p = head, q = head.next;
while (num < pos) {
p = q;
q = q.next;
num++;
}
return q.data;
} //在链表中查找一个元素,返回该元素下标的索引
public int find(T obj) {
if (isEnpty()) {
System.out.println("链表为空表");
return -1;
}
int num = 1; Node<T> p = head, q = head.next;
while (q!= null) {
if (obj.equals(q.data)) {
return num;
}
p = q;
q = q.next;
num++;
}
return -1;
/* Node<T> p = head.next;
while (p != null) {
if (p.data.equals(obj) == false) {
p = p.next;
num++;
} else break; }
if (p == null) {
return -1;
}
return num;*/
} //更新链表中某各元素
public boolean modify(T obj, int pos) {
if (isEnpty()) {
System.out.println("链表为空表");
return false;
}
if (pos < 1 || pos > length + 1) {
System.out.println("pos值不合法");
return false;
}
int num = 1;
Node<T> q = head.next;
while (num < pos) {
q = q.next;
num++;
}
q.data = obj;
return true;
} //判空
public boolean isEnpty() {
return length == 0;
} //求链表中数据元素的个数
public int size() {
return length;
} //一次访问链表中每个元素并输出
public void nextOrder() {
Node<T> q = head.next;
while (q != null) {
System.out.println(q.data);
q = q.next;
}
} //销毁一个已经存在的链表
public void clear() {
length = 0;
head.next = null;
} public static void main(String[] args) {
ListLink<Integer> l = new ListLink<>();
int i;
int a[] = {23, 56, 12, 49, 35};
for (i = 0; i < a.length; i++) {
l.add(a[i], i + 1);
}
System.out.println("单链表中的数据元素为:");
l.nextOrder();
System.out.println(l.find(5)); }

3.java实现顺序表

/**
* 顺序表
* @author luminous-xin
* @param <T>
*/
public class SequenceList<T> {
final int maxSize = 10; //顺序表中一维数组的长度
private T[] listArray; //存储元素的数组对象
private int length; //保存顺序表的当前长度
public SequenceList(){ //构造一个空的线性表
length = 0;
listArray = (T[])new Object[maxSize];
}
public SequenceList(int n){
if(n <= 0){
System.out.println("error");
System.exit(1);
}
length = 0;
listArray = (T[])new Object[n];
}
public boolean add(T obj , int pos){ //在线性表中插入一个新元素
if(pos < 1 || pos > length + 1){ //检验插入位置的有效性
System.out.println("pos不合法");
return false;
}
if(length == listArray.length){ //扩容
T[] p = (T[])new Object[length*2];
for (int i = 0; i < length; i++) {
listArray = p;
}
}
for (int i = length; i > pos; i--) { //插入
listArray[i] = listArray[i-1];
}
listArray[pos-1] = obj;
length++;
return true;
}
public T remove(int pos){ //在线性表中删除一个元素
if(isEmpty()){
System.out.println("顺序表为空,无法执行删除操作");
return null;
}else{
if(pos<1 || pos >length){
System.out.println("pos不合法");
return null;
} T x = listArray[pos-1]; //备份被删除的元素,将其作为返回值返回
for (int i = pos ; i <= length; i++) {
listArray[i-1] = listArray[i];
}
length++;
return x;
}
} public int find(T obj){ //在线性表中查找一个元素
if(isEmpty()){
System.out.println("顺序表为空");
return -1;
}else{
for(int i = 0 ; i <length ; i++){
if(listArray[i].equals(obj)){
return i + 1; //返回该元素的位置
}
}
return -1;
}
}
public T value(int pos){ //获取线性表中的一个元素
if(isEmpty()){
System.out.println("顺序表为空");
}else{
if(pos < 1 || pos > length +1){
System.out.println("pos值不合法");
}
}
return listArray[pos - 1];
}
public boolean modify(T obj,int pos){ //更新线性表中的某各元素
if(isEmpty()){
System.out.println("顺序表为空");
return false;
}else{
if(pos < 1 || pos > length ){
System.out.println("pos值不合法");
return false;
}
}
listArray[pos-1] = obj;
return true;
}
public boolean isEmpty(){ //判空
return length == 0;
}
public int size(){ //求线性表中数据元素的个数
return length;
}
public void nextOrder(){ //一次访问栈中的每个元素并输出
for(int i = 0 ; i< length; i++ ){
System.out.println(listArray[i]);
}
}
public void clear(){ //销毁一个已经存在的线性表
length = 0;
} }

4.链表的应用,合并两个有序链表

public class Chap2_2 {
public static <T extends Comparable> void MergeList_L(ListLink<T> la, ListLink<T> lb ,ListLink<T> lc){
Node<T> pa,pb,pc;
pa = la.getHead().next;
pb = lb.getHead().next;
pc = lc.getHead(); while(pa != null && pb != null){
if(pa.data.compareTo(pb.data)<0){
pc.next = pa;
pc = pa ;
pa = pa.next;
}else{
pc.next = pb;
pc = pb;
pb = pb.next;
} while (pa != null){
pc.next = pa;
pc = pc.next;
pa = pa.next;
}
while (pb != null){
pc.next = pb;
pc = pb;
pb = pb.next;
}
la.clear();
lb.clear();
}
}
public static void main(String[] args) {
int i,j,k = 0;
int[] b = {12,23,35,49,56};
int[] a = {10,15,20};
ListLink<Integer> la = new ListLink<>();
ListLink<Integer> lb = new ListLink<>();
ListLink<Integer> lc = new ListLink<>();
for ( i = 0; i < a.length; i++) {
la.add(a[i],i+1);
}
System.out.println("单链表a中的元素为:");
la.nextOrder();
for (j = 0; j < b.length; j++) {
lb.add(b[j],j+1);
}
System.out.println("单链表b中的数据元素为:");
lb.nextOrder();
MergeList_L(la,lb,lc);
System.out.println("单链表c中的元素为:");
lc.nextOrder();
}
}

5.java实现顺序栈

/**
* 顺序栈
* @author luminous-xin
* @param <T>
*/
public class SequenceStack<T> {
final int maxSize = 10;
private T[] stackArray;
private int top;
//各方法的具体实现后有详细描述
public SequenceStack(){
top = -1;
stackArray = (T[])new Object[maxSize];
}
public SequenceStack(int n){
if(n<=0){
System.out.println("数组长度要大于零,否则退出程序运行!");
System.exit(1);
}
top = -1;
stackArray = (T[])new Object[n];
}
//在栈顶位置插入一个新元素
public void push(T obj){
if(top == stackArray.length-1){
T[] p = (T[])new Object[top*2+2];
for (int i = 0; i <= top; i++){
p[i] = stackArray[i];
}
stackArray = p;
} top++;
stackArray[top] = obj;
}
//删除栈顶元素
public T pop(){
if(top == -1) {
System.out.println("数据栈已空,无法删除元素");
return null;
}
top--;
return stackArray[top+1];
}
//取栈顶数据元素
public T getHead(){
if (top == -1){
System.out.println("数据栈已空,无法删除元素");
return null;
}
return stackArray[top];
}
//判断当前栈是否为空
public boolean isEmpty(){
return top == -1;
}
//求出栈中元素的个数
public int size(){
return top +1;
}
//依次访问栈中元素并输出
public void nextOrder(){
for(int i = top ; i >= 0;i--){
System.out.println(stackArray[i]);
}
}
//销毁一个已经存在的栈
public void clear(){
top = -1;
}
}

6.java实现链栈

/**
* 链栈
* @luminous-xin
* @param <T>
*/
public class LinkStack<T> {
private Node<T> top; //栈顶指针
private int length; //存储栈的长度
public LinkStack(){ //构造一个空的栈
length = 0;
top = null;
}
public void push(T obj){ //入栈
top = new Node<T>(obj,top);
length++;
}
public T pop(){ //出栈
if(top == null){
System.out.println("栈已空,无法删除");
return null;
}
T x = top.data;
top = top.next;
length--;
return x;
}
public T getHead(){ //取栈顶元素
if(top == null){
System.out.println("栈已空,无法删除");
return null;
}
return top.data;
}
public int size(){ //求出栈中元素的个数
return length;
}
public boolean isEmpty(){ //判断栈是否为空
if (top ==null){
return true;
}
return false;
}
public void nextOrder(){ //便利栈
Node<T> p = top;
while (p != null){
System.out.println(p.data);
p = p.next;
}
} public void clear(){ //销毁一个栈
top = null;
}
}

7.java实现顺序链表

import org.omg.CORBA.Object;

/**
* 循环队列
* @author luminous
* @param <T>
*/
public class SequenceQueue<T> {
final int maxSize = 10;
private T queueArray[];
private int front, rear; public SequenceQueue() {
rear = front = 0;
queueArray = (T[]) new Object[maxSize];
} public void enQueue(T obj) { //入队
if ((rear + 1) % queueArray.length == front) {
T[] p = (T[]) new Object[queueArray.length * 2];
if (rear == ((T[]) queueArray).length) {
for (int i = 0; i <= rear; i++) {
p[i] = queueArray[i];
}
} else {
int i,j = 1;
for (i = front + 1; i<queueArray.length;i++,j++)
p[j] = queueArray[i];
for (i = 0;i<= rear ; i++,j++)
p[j] = queueArray[i];
front = 0;
rear = queueArray.length-1;
}
queueArray = p;
}
rear = (rear+1)%queueArray.length;
queueArray[rear] = obj;
}
public T DeQueue(){ //出队
if(isEmpty()){
System.out.println("队列已空,无法出队!");
return null;
}
front = (front +1)%queueArray.length;
return queueArray[front]; }
public T getTop(){ //取出头元素
if(isEmpty()){
System.out.println("队列已空,无法读取元素!");
return null;
}
return queueArray[(front+1)%queueArray.length] ;
}
public boolean isEmpty(){ //队列的非空队列
return front==rear;
}
public int size(){ //求队列长度
return (rear - front +queueArray.length)%queueArray.length;
}
public void nextOrder(){ //遍历队列
int i,j = front ;
for (i = 1; i < size(); i++) {
j = (j+1)%queueArray.length;
System.out.println(queueArray[j]); }
}
public void clear(){ //清空队列
front = rear =0;
}
}

java实现顺序表、链表、栈 (x)->{持续更新}的更多相关文章

  1. 线性表 及Java实现 顺序表、链表、栈、队列

    数据结构与算法是程序设计的两大基础,大型的IT企业面试时也会出数据结构和算法的题目, 它可以说明你是否有良好的逻辑思维,如果你具备良好的逻辑思维,即使技术存在某些缺陷,面试公司也会认为你很有培养价值, ...

  2. Java实现顺序表

    利用顺序存储结构表示的顺序表称为顺序表. 它用一组连续的地址存储单元一次存放线性表中的数据元素. 顺序表的实现是数据结构中最简单的一种. 由于代码中已经有详细注释,代码外不再阐述. 下次再陈上关于顺序 ...

  3. C# 数据结构 线性表(顺序表 链表 IList 数组)

    线性表 线性表是最简单.最基本.最常用的数据结构.数据元素 1 对 1的关系,这种关系是位置关系. 特点 (1)第一个元素和最后一个元素前后是没有数据元素,线性表中剩下的元素是近邻的,前后都有元素. ...

  4. 数据结构——Java实现顺序表

    一.分析 什么是顺序表?顺序表是指用一组地址连续的存储单元依次存储各个元素,使得在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中的线性表.一个标准的顺序表需要实现以下基本操作: 1.初始化顺序表 ...

  5. 学生信息管理系统-顺序表&&链表(数据结构第一次作业)

    实验目的 : 1 .掌握线性表的定义: 2 .掌握线性表的基本操作,如建立.查找.插入和删除等. 实验内容: 定义一个包含学生信息(学号,姓名,成绩)的的 顺序表和链表,使其具有如下功能: (1) 根 ...

  6. (java实现)顺序表-ArrayList

    什么是顺序表 顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构. 在使用顺序表存储数据前,会先申请一段连续的内存空间(即数组),然后把数组依次存入 ...

  7. Java数据结构——顺序表

    一个线性表是由n(n≥0)个数据元素所构成的有限序列. 线性表逻辑地表示为:(a0,a1,…,an-1).其中,n为线性表的长度,n=0时为空表.i为ai在线性表中的位序号. 存储结构:1.顺序存储, ...

  8. Java算法 -- 顺序表

    顺序表结构定义:就是按照顺序存储方式存储的线性表 1.定义一个顺序表的基本数据: static final int MAXLEN = 100; Class Student{ private Strin ...

  9. Java日常错误及需要注意细节,持续更新......

    记录日常工作中一些容易被忽视的错误及细节,持续更新...... 一.问题:HashMap<Long, String>中,用get(Integer key)取不到值 Map<Long, ...

随机推荐

  1. @Autowired和@Resource的区别和联系

    背景: 今天下班路上看到一个大货车,于是想到了装配,然后脑海里跳出了一个注解@Autowired(自动装配),于是又想到最近工作项目用的都是@Resource注解来进行装配.于是本着学什么东西都要一钻 ...

  2. List和数组的互转

    list转数组: /要转换的list集合 List<String> testList = new ArrayList<String>(){{add("aa" ...

  3. ubuntu16.04 overlay 不支持redirect_dir开关

    modinfo overlay--查看overlay版本 通过linux网站--https://elixir.bootlin.com/linux/v4.4.196/source/fs/overlayf ...

  4. Mysql模糊查询like提速优化

    LOCATE('substr',str,pos)方法 SELECT LOCATE('xbar',`foobar`); ###返回0 SELECT LOCATE('bar',`foobarbar`); ...

  5. linux tomcat 文件切割

    修改bin目录下catalina.sh if [ -z "$CATALINA_OUT" ] ; then CATALINA_OUT="$CATALINA_BASE&quo ...

  6. 支付宝小程序开发——H5跳转到小程序(获取小程序页面的链接)

    前言: 这个问题支付宝小程序官方文档并没有专门说明,钉钉群的官方技术支持给了个开发者社区的帖子,详见:如何跳转小程序. 如果配置的页面没有参数还好,不会出问题,如果有参数,很可能配出来的链接无法正常获 ...

  7. android Studio keytool' 不是内部或外部命令,也不是可运行的程序 或批处理文件

    //android Studio  keytool' 不是内部或外部命令,也不是可运行的程序 或批处理文件 遇到这个问题好久了,一直没解决今天搜集了大量的资料,有的说什么Java没配置好,不是扯犊子吗 ...

  8. exe4j 打包jar包程序,inno setup complier打包所有

    关于库: jar包中对于引用第三方库的话,需要再exe4j中引用. rxtx http://rxtx.qbang.org/wiki/index.php/Download

  9. Invalid prop: custom validator check failed for prop "pagination" <Table> vue.runtime.esm

    错误如图 原因,返回数据中没有包括分布的属性

  10. java导出pdf功能记录

    这几天已在做处理导出pdf文件的功能,摸索了几天总算可以了.记录下这几天遇到的问题. 1.网上基本都是基于Itext5和Itext7来处理的.我最终是在Itext5上成功了,itext7应该是模板出问 ...