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, ...
随机推荐
- JavaScript的filter方法
var ages = [32, 33, 16, 40]; function checkAdult(age) { return age >= 18; } function myFunction() ...
- dubbo中的Filter链原理及应用
转载:https://www.jianshu.com/p/f390bb88574d filter在dubbo中的应用非常广泛,它可以对服务端.消费端的调用过程进行拦截,从而对dubbo进行功能上的扩展 ...
- centos7安装Redis5.0.5
1.下载redismkdir /home/redis/cd /home/redis/wget http://download.redis.io/releases/redis-5.0.5.tar.gzt ...
- BigDecimal 基本使用 比较大小和加减乘除
//比较大小: int a = bigdemical.compareTo(bigdemical2) //a = -1,表示bigdemical小于bigdemical2: //a = 0,表示bigd ...
- Docker是什么？
Docker是什么? Docker是一个虚拟环境容器,可以将你的环境.代码.配置文件等一并打包到这个容器中,并发布和应用到任意平台中.比如,你在本地部署了git,jenkins等,可以将其与插件一并打 ...
- Kubernetes之在k8s中部署Java应用
部署好了k8s以后 部署参考https://www.cnblogs.com/minseo/p/12055731.html 怎么在k8s部署应用 项目迁移到k8s平台是怎样的流程 1,制作镜像 2,控制 ...
- 将博客转成pdf
前些天无意间看到了“birdben”的博客,写的比较详细,但是最新的文章更新时间是“2017-05-07”,时间很是久远,本打算有时间认真学习一下博主所写的文章,但是担心网站会因为某些原因停止服务,于 ...
- 查看linux操作系统
cd /etc ll *release -rw-r--r-- 1 root root 38 Oct 8 2018 centos-release -rw-r--r-- 1 root root 393 O ...
- 服务器系统启动之所以比PC慢很多
服务器系统启动之所以比PC慢很多, 第一个是:服务器底层还有一套硬件和固件,叫做IPMI系统,这套系统需要时间来引导和载入.载入IPMI后,它才会载入BIos来继续引导.这个占主要时间,尤其是冷启动的 ...
- Retrofit 二次封装实践
首先感谢这位大神的博客:https://blog.csdn.net/u014569233/article/details/67639522,在他的基础上根据自己项目进行了修改最后成为现在项目使用的样子 ...