java实现顺序表、链表、栈 (x)->{持续更新}
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)->{持续更新}的更多相关文章
- 线性表 及Java实现 顺序表、链表、栈、队列
数据结构与算法是程序设计的两大基础,大型的IT企业面试时也会出数据结构和算法的题目, 它可以说明你是否有良好的逻辑思维,如果你具备良好的逻辑思维,即使技术存在某些缺陷,面试公司也会认为你很有培养价值, ...
- Java实现顺序表
利用顺序存储结构表示的顺序表称为顺序表. 它用一组连续的地址存储单元一次存放线性表中的数据元素. 顺序表的实现是数据结构中最简单的一种. 由于代码中已经有详细注释,代码外不再阐述. 下次再陈上关于顺序 ...
- C# 数据结构 线性表（顺序表 链表 IList 数组）
线性表 线性表是最简单.最基本.最常用的数据结构.数据元素 1 对 1的关系,这种关系是位置关系. 特点 (1)第一个元素和最后一个元素前后是没有数据元素,线性表中剩下的元素是近邻的,前后都有元素. ...
- 数据结构——Java实现顺序表
一.分析 什么是顺序表?顺序表是指用一组地址连续的存储单元依次存储各个元素,使得在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中的线性表.一个标准的顺序表需要实现以下基本操作: 1.初始化顺序表 ...
- 学生信息管理系统-顺序表&&链表（数据结构第一次作业）
实验目的 : 1 .掌握线性表的定义: 2 .掌握线性表的基本操作,如建立.查找.插入和删除等. 实验内容: 定义一个包含学生信息(学号,姓名,成绩)的的 顺序表和链表,使其具有如下功能: (1) 根 ...
- (java实现)顺序表-ArrayList
什么是顺序表 顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构. 在使用顺序表存储数据前,会先申请一段连续的内存空间(即数组),然后把数组依次存入 ...
- Java数据结构——顺序表
一个线性表是由n(n≥0)个数据元素所构成的有限序列. 线性表逻辑地表示为:(a0,a1,…,an-1).其中,n为线性表的长度,n=0时为空表.i为ai在线性表中的位序号. 存储结构:1.顺序存储, ...
- Java算法 -- 顺序表
顺序表结构定义:就是按照顺序存储方式存储的线性表 1.定义一个顺序表的基本数据: static final int MAXLEN = 100; Class Student{ private Strin ...
- Java日常错误及需要注意细节，持续更新......
记录日常工作中一些容易被忽视的错误及细节,持续更新...... 一.问题:HashMap<Long, String>中,用get(Integer key)取不到值 Map<Long, ...
随机推荐
- Mercurial 安装及使用
版权声明:本文为博主原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接和本声明. 本文链接:https://blog.csdn.net/moonspiritacm/articl ...
- 信息系统项目十大管理ITO
这是份关于信息系统项目管理师教程的内容提炼而成的电子文档,帮助所有备考信息系统管理师的考生准备,让大家快速记忆,助考加速.闲话少叙:直接上传我自己提炼的知识点.下图只是一部分,附件是所有内容.下载链接 ...
- JVM探究之 —— 垃圾回收（一）
垃圾收集(Garbage Collection,GC),大部分人都把这项技术当做Java语言的伴生产物.事实上,GC的历史比Java久远,1960年诞生于MIT的Lisp是第一门真正使用内存动态分配和 ...
- Java: Java终止线程的几种方式
首先说明,使用stop方法终止的方式已经在很久之前就被废弃了,在加锁的情况下有可能会造成死锁,这里不做讨论. 1. 使用标志位终止线程 在run()方法执行完毕后,该线程就终止了.但是在某些特殊的情况 ...
- Myeclipse安装Maven插件
Myeclipse安装Maven插件 一.下载Maven 官网下载maven插件 http://maven.apache.org/download.cgi 下载apache-maven-3.6.3- ...
- wikiquote
發現了一個很好玩的網站wikiquote,上面有很多引用的句子 比如關於編程語言的說法 https://en.m.wikiquote.org/wiki/Category:Programming_lan ...
- python做上位机
参考文章: https://blog.csdn.net/dgut_guangdian/article/details/78391270 https://www.cnblogs.com/lanceyu/ ...
- 解决Linux系统下面javamelody图片中文乱码问题
从windows系统中,copy了C:\Windows\Fonts\msyh.ttc和msyhbd.ttc 2个文件到 服务器的%JAVA_HOME%\jre\lib\fonts\fallback 目 ...
- odoo开发笔记 -- 提高访问安全性的一种方式
场景描述: 最近在做项目的过程中,需要需要将odoo应用集成到其他系统中, 在对方的系统中点击我们的应用,打开对应系统,但是界面不做跳转,在当前页面打开,并且浏览器地址栏只显示IP+应用名,不让显示o ...
- C#实现通过HttpWebRequest发送POST请求实现网站自动登陆
C#实现通过HttpWebRequest发送POST请求实现网站自动登陆 怎样通过HttpWebRequest 发送 POST 请求到一个网页服务器?例如编写个程序实现自动用户登录,自动提交表单数 ...