数据结构笔记 2

最新推荐文章于 2022-10-31 19:45:59 发布
最新推荐文章于 2022-10-31 19:45:59 发布
阅读量85 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lchlibedichyan/article/details/122498597
版权

栈的应用

进制转换

例：十进制转十六进制
输入654321，打印输出与其等值的十六进制数。
654321 ÷ 16 =‬ 40895 ~ 1
40895 ÷ 16 = 2555 ~ 15
2555 ÷ 16 = 159 ~ 11
159 ÷ 16 = 9 ~ 15
9 ÷ 16 = 0 ~ 9

9 F B F 1
在这里插入图片描述
十六进制转换为十进制

9 F B F 1
1 × 160 + F × 161 + B × 162 + F × 163 + 9 × 164
1 × 160 + 15 × 161 + 11 × 162 + 15 × 163 + 9 × 164
在这里插入图片描述

import jdk.internal.dynalink.linker.ConversionComparator;
import java.util.Stack;

public class BinaryConversion {
    public static void main(String[] args) {
   
     //进制转化
        int num = 654321;
        String a = Conversion(num);
        System.out.println(a);
        String  n = "9FBF1";
        int p =  Con(n);
        System.out.println(p);
    }
    private static int Con(String n) {
        //  16--> 10;
        Stack <Character>s = new Stack();
        int i = 0;
        int rs = 0;
        while (i < n.length()){
            s.push(n.charAt(i));
            i++;
        }
        while(!s.isEmpty()){
            for (int j = 0; j < n.length(); j++) {
                int p = s.pop();
                if(p <=57 &&p >=49){
                    rs = rs+ (p-48) * mi(16,j);
                }else if(p <=70 && p >=65){
                    rs = rs+ (p-55) * mi(16,j);
                }else{
                    throw new IllegalArgumentException("erro");
                }
            }
        }
        return rs;
    }
    private static int mi(int i, int j) {
        int c = 1;
        if(i==0){
            return 1;
        }
        for(i =0;i < j;i++){
            c = c * 16;
        }
        return c;
    }
    private static String Conversion(int num) {
        //10  --> 16
        StringBuilder sb = new StringBuilder();
        Stack<String> s = new Stack();
        while (num!=0){
            int res = num % 16 ;
            if(res < 10 && res >=0){
                s.push(res+"");
            }else{
                s.push((char)(res + 55) +"");
            }
            num = num/ 16;
        }
        while (!s.isEmpty()){
            sb.append(s.pop());
        }
        return sb.toString();
    }
}

括号匹配

在这里插入图片描述

import java.util.Stack;

public class ParenthesesMatching {
   
    //括号匹配
    public static void main(String[] args) {
        String s1 = "{[<>]()}";
        boolean matching = Matching(s1);
        System.out.println(matching);
    }
    private static boolean Matching(String s1) {
        Stack<Character> st = new Stack();
        for (int i = 0; i < s1.length(); i++) {
            //进栈  如果是空  或者 ASCII码的差值不为2或者1；
            int res = 0;
            if(!st.isEmpty()){
                res = s1.charAt(i) - st.peek();
                if (res ==1 || res == 2){
                    st.pop();
                }else{
                    st.push(s1.charAt(i));
                }
            }else{
                st.push(s1.charAt(i));
            }
        }
        return st.isEmpty();
    }
}

双端栈

双端栈的定义：
是指将一个线性表的两端当做栈底分别进行入栈和出栈操作
主要利用了栈“栈底位置不变，而栈顶位置动态变化” 的特性。

                   左栈为空：ltop = -1
                   左栈元素个数：ltop + 1
                   右栈为空：rtop = length
                   右栈元素个数：length – rtop
                   栈满：ltop + 1 = rtop

在这里插入图片描述
双端栈是线性表的一种，更是栈的一个特殊分类，可以用动态数组和栈的思想来实现双端栈
在这里插入图片描述
双端栈扩容缩容问题
在这里插入图片描述
因为双端栈对两端进行操作，所有不能用ArrayList来实现（ArrayList只能在一端进行操作）用数组来实现左右端 push pop peek 等方法

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

public class ArrayDoubleEndStack<E> implements Iterable<E> {
    //属性和行为
    //左端栈的栈顶
    private  int ltop;
    //右端栈的栈顶
    private int rtop;
    //存储元素的容器
    private  E [] data;
    //数组容器的默认容量
    private static int Default_CAPACITY=10;
    public  ArrayDoubleEndStack(){
        data = (E[]) new Object[Default_CAPACITY];
        ltop = -1;
        rtop = data.length;
    }
    public  void pushLeft(E element){
        //判断是否满了
        if(ltop +1 == rtop){
            resize(data.length *2);
        }
        data[++ltop] = element;
    }
    public  void pushRight(E element){
        if(ltop +1 == rtop){
            resize(data.length *2);
        }
        data[--rtop] = element;
    }
    private void resize(int newLen) {
        E[] newData = (E[]) new Object[newLen];
        //复制左端栈
        for (int i = 0; i <= ltop; i++) {
            newData[i] = data[i];
        }
        //复制右端栈的元素
        int index = rtop;
        for (int i = newLen - sizeRight();i < newLen;i++){
            newData[i] = data[index++];
        }
        rtop = newLen - sizeRight();
        data = newData;
    }
    public  E popLeft(){
        if(isLeftEmpty()){
            throw new IllegalArgumentException("left is null");
        }
        E ret = data[ltop--];
        if(sizeLeft() +sizeRight() <= data.length/4 && data.length>Default_CAPACITY){
            resize(data.length/2);
        }
        return  ret;
    }
    public  E popRight(){
        if(isRightEmpty()){
            throw new IllegalArgumentException("right is null");
        }
        E ret = data[rtop++];
        if(sizeLeft() +sizeRight() <= data.length/4 && data.length>Default_CAPACITY){
            resize(data.length/2);
        }
        return  ret;
    }
    public E peekLeft(){
        if(isLeftEmpty()){
            throw new IllegalArgumentException("left is null");
        }
        return data[ltop];
    }
    public  E peekRight(){
        if(isRightEmpty()){
            throw new IllegalArgumentException("right is null");
        }
        return data[rtop];
    }
    public  boolean isLeftEmpty(){
        return ltop ==-1;
    }
    public  boolean isRightEmpty(){
        return  rtop== data.length;
    }
    private int sizeRight() {
        return data.length - rtop;
    }
    private int sizeLeft() {
        return ltop;
    }
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        if(isLeftEmpty()&& isRightEmpty()){
            sb.append("]");
            return  sb.toString();
        }
        //左边
        for (int i = 0; i <= ltop; i++) {
            sb.append(data[i]);
            if(i==ltop && isRightEmpty()){
                sb.append("]");
                return sb.toString();
            }else{
                sb.append(",");
            }
        }
        //右边
        for (int i = rtop; i < data.length ; i++) {
            sb.append(data[i]);
            if(i == data.length-1){
                sb.append("]");
            }else{
                sb.append(",");
            }
        }
        return sb.toString();
    }
    @Override
    public Iterator<E> iterator () {

        return new ArrayDoubleEndStackStackInerator();
    }
    class  ArrayDoubleEndStackStackInerator implements Iterator<E>{
        private ArrayList<E>list1 ;
        private Iterator<E>it;
        public  ArrayDoubleEndStackStackInerator(){
            list1 = new ArrayList<>();
            for (int i = 0; i < ltop; i++) {
                list1.add(data[i]);
            }
            for (int i = rtop; i < data.length ; i++) {
                list1.add(data[i]);
            }
            it = list1.iterator();
        }
        @Override
        public boolean hasNext() {
            return it.hasNext();
        }
        @Override
        public E next() {
            return it.next();
        }
    }
}

用ArrayList实现队列

定义：
1.队列只是允许在一端进行插入操作，而在另一端进行删除操作的线性表
2.队首：允许删除的一端。
3.队尾：插入的一端
4.不含任何数据元素的队列称为空队列
5.队列本身就是一个线性表，其数据元素具有线性关系，只不过他是一种特殊的线性表
6.队列的插入叫做入队
7.队列的删除叫做出队

import p1.接口.Queue;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Objects;

public class ArrayQueue<E> implements Queue<E> {
    //底层用ArrayList
    private ArrayList<E> list ;
    public ArrayQueue(){
        list = new ArrayList<>();
    }
    @Override
    public void offer(E element) {
        //入队
        list.add(list.size(), element);
    }
    @Override
    public E poll() {
        return list.remove(0);
    }
    @Override
    public E peek() {
        return list.get(0);
    }
    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }
    @Override
    public void clear() {
        list.clear();
    }
    @Override
    public int size() {
        return list.size();
    }
    @Override
    public Iterator<E> iterator() {
        return list.iterator();
    }
    @Override
    public String toString() {
        return list.toString();
    }
    @Override
    public boolean equals(Object o) {
       if(o==null){
           return false;
       }
       if(this ==o){
           return true;
       }
       if(o instanceof ArrayQueue){
           ArrayQueue other = (ArrayQueue) o;
           return list.equals(other.list);
       }
       return  false;
    }
}

用栈实现队列

在这里插入图片描述
用两个栈来实现队列的功能
stack A主要存储元素
stackB 临时存储元素

import p1.接口.Queue;
import java.util.Iterator;
import java.util.Stack;

public class StackToQueue {
    //栈实现队列
    public static void main(String[] args) {
        QueueImplByStack <Integer> queue = new QueueImplByStack<>();
        for(int i =1;i <=5;i++){
            queue.offer(i);
        }
        System.out.println(queue);
        System.out.println(queue.poll());
        System.out.println(queue);
    }
}
class QueueImplByStack<E> implements Queue<E>{
    private Stack<E> stackA;
    private Stack<E> stackB;
    public QueueImplByStack(){
        stackA = new Stack<>();
        stackB = new Stack<>();
    }
    @Override
    public void offer(E element) {
        stackA.push(element);
    }
    @Override
    public E poll() {
        if(isEmpty()){
            throw new IllegalArgumentException("queue is null");
        }
        while (stackA.size()!=1){
            stackB.push(stackA.pop());
        }
        E ret = stackA.pop();
        while (!stackB.isEmpty()){
            stackA.push(stackB.pop());
        }
        return ret;
    }
    @Override
    public E peek() {
        if(isEmpty()){
            throw new IllegalArgumentException("queue is null");
        }
        while (stackA.size()!=1){
            stackB.push(stackA.pop());
        }
        E ret = stackA.peek();
        while (!stackB.isEmpty()){
            stackA.push(stackB.pop());
        }
        return ret;
    }
    @Override
    public boolean isEmpty() {
        return stackA.isEmpty();
    }
    @Override
    public void clear() {
        stackA.clear();
        stackB.clear();
    }
    @Override
    public int size() {
        return stackA.size();
    }
    @Override
    public Iterator<E> iterator() {
        return stackA.iterator();
    }
    @Override
    public String toString() {
        return stackA.toString();
    }
}
yumiaoze
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构】6.双端栈的实现
weixin_46955173的博客
01-13 771
目录 一、双端栈的定义 二、图形解释 三、ArrayDoubleEndStack类（双端栈类） 四、具体实现 1.声明属性 2.声明无参构造函数 3. 入栈方法 4.弹栈方法 5.入栈弹栈时遇到扩容缩容的问题 6.查看栈顶元素 7.前面所用到的方法 8.重写toString()方法 9.重写迭代器 五、代码总汇 六、测试代码 七、输出结果 一、双端栈的定义 是指将一个线性表的两端当做栈底分别进行入栈和出栈操作 主要利用了栈...
BJFU_数据结构习题_241双栈的基本操作
雪地行进
10-26 3125
241双栈的基本操作 描述 将编号为0和1的两个栈存放于一个数组空间V[m]中，栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]等于-1时该栈为空；当第1号栈的栈顶指针top[1]等于m时，该栈为空。两个栈均从两端向中间增长（见下图）。试编写双栈初始化，判断栈空、栈满、进栈和出栈算法的函数。函数调用次序依次为：进栈、栈满的判断、出栈、栈空的判断。 双栈数据结构的定义如下： typedef ...
动态数组------双端栈的实现
ll_j_21的博客
05-27 161
ArrayDoubleEndStack实现类 package shixianClass; import java.util.Arrays; public class ArrayDoubleEndStack<E> { private E[] data; //存元素的容器 private int ltop; //左端栈的栈顶 ltop==-1表示左端栈为空 ltop+1==表示左端栈的个数 private int rtop;//右端栈的栈顶 rtop...
数据结构之动态数组双端栈
暖风吹起云之博客
12-11 328
双端栈同栈操作相同，不过有左右栈区分而已。
【数据结构】栈与队列的双向实现
weixin_53106294的博客
10-31 118
队列去实现一个栈。栈去实现一个队列
数据结构笔记.docx
最新发布
12-19
数据结构笔记 数据结构是计算机科学中的一门重要学科，涉及到数据的存储、表示和操作等方面。本笔记涵盖了数据结构的基本概念、线性表、栈和队列、树、图、排序和查找等重要知识点。 一、数据结构的基本概念 数据...
Java数据结构学习笔记
12-18
Java数据结构学习笔记
考研数据结构学习笔记.doc
10-20
"数据结构学习笔记" 本文档是一个关于数据结构学习笔记，涵盖了数据结构的基本概念、逻辑结构、物理结构、算法设计规范、算法时间复杂度分析、空间复杂度分析等方面的内容。下面是对每个知识点的详细解释： 一、...
数据结构高分笔记2
10-30
本资源“数据结构高分笔记2”是一份针对考研准备的珍贵资料，旨在帮助考生深入理解和掌握数据结构的关键概念与技巧。 笔记首先会涵盖基本的数据结构类型，包括数组、链表、栈和队列。数组是最基础的数据结构，它...
数据结构笔记：栈
01-20
分类目录——数据结构笔记](https://blog.csdn.net/bbjg_001/category_9753496.html) 栈（stack），有些地方也成为堆栈，是一种容器，可存储元素、访问元素、删除元素，他的特点是值能允许在容器的一段（称之为 栈顶...
双端栈——入栈与出栈
PD137的博客
05-14 2364
【代码】双端栈——入栈与出栈。
数据结构—双端栈
qq_45162113的博客
12-11 255
双端栈的定义 指线性表的两边当作栈底进行入栈出栈操作 双端栈的主要功能 //特殊情况的线性表 public interface Stack<E> extends Iterable<E>{ int getSize(); //获取栈元素个数 boolean isEmpty(); //栈判空 void push(E e); //进栈 E p...
数据结构之使用双队列实现栈
weixin_42205937的博客
03-28 185
使用队列实现栈的push、pop、top、empty这四个接口功能 队列的特点：先进先出，和栈先进后出相反，那么怎么使用队列实现相反操作顺序的栈呢？ 其主要原理是在出栈时将原队列queue1除了队首的元素之外所有元素都按照顺序依次缓存到另外一个队列queue2，单独对队列末端元素出队并记录为e，最后将queue2队列元素全部放回原队列并返回末端元素e 这里考虑top()查看栈顶的方法会经常调用，使用变量Integer top; 对其缓存，把复杂度降为O(1)；未改动的top()操作文末贴出。 package
025 通过链表学Rust之使用栈实现双端队列
令狐一冲
02-17 277
介绍 视频地址：https://www.bilibili.com/video/av78062009/ 相关源码：https://github.com/anonymousGiga/Rust-link-list 详细内容 本节我们使用栈来实现双端队列。 实现栈 栈的实现基本上和最开始的单链表的实现差不多，如下： pub struct Stack<T> { head: Link<T>, } type Link<T> = Option<Box<Node<T&g
225. 用队列实现栈(java版双队列解法详细多图)
e891377的专栏
03-01 337
题目 使用队列实现栈的下列操作： push(x) – 元素 x 入栈 pop() – 移除栈顶元素 top() – 获取栈顶元素 empty() – 返回栈是否为空 注意: 你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。 你所使用的语言也许不支持队列。 你可以使用 list 或者 de...
栈和队列、双端队列
AC__GO的博客
08-18 712
栈、队列、双端队列
双端栈
听君“一席”话...
10-19 2501
/*双端队列可以用于存储两个栈，使用deque来实现的 *读入20个随机整数，把偶数压入一个栈 *把奇数压入另一个栈 *然后分别弹出并输出两个栈的元素，直到为空*/ //备注：随机数要加上种子，要不然不会变的，这个不是mfc版 #include #include
顺序栈和链栈的初始化，出栈，进栈的具体实现(new和exit的用法)
xdznb_的博客
01-13 3348
文章目录一 . 栈的定义和特点二 . 栈的抽象类型定义三 . 顺序栈的基本操作1 . 顺序栈的定义2 . 初始化new和exit的用法new的用法：exit的用法：3 . 入栈（压栈）4 . 出栈5 . 取栈顶元素四 . 链栈的基本操作1 . 链栈的定义2 . 初始化3 . 入栈4 . 出栈5 . 取栈顶元素五 . 顺序栈操作的实现六 . 链栈基本操作的实现 一 . 栈的定义和特点 栈的基本操作...
如何两个栈实现队列？两个队列实现栈？
编程开发资料库
11-20 127
初看此题目，你可能觉得自找苦吃，队列就队列为什么要用栈来实现，工程中总是很典型的应用，直接调API就可以了，不管是什么语言，已经有现成API封装好队列以及堆栈的所有操作。没错，在项目中很少有这样的需要。但是我们是站在学习的角度，并不是画地为牢，难为自己，而是对思维的一种锻炼，对算法的提升么。我们在面试的时候碰到的这类问题还少吗?所以大家就不要拍砖了。现在开始研究此问题。 首先看如何用两个栈去实现...
数据结构学习笔记.docx
12-02
《数据结构学习笔记.docx》是一份包含关于算法时间复杂度、空间复杂度以及线性表的基本特点和存储结构的学习笔记。在学习笔记中提到，算法的时间复杂度T(n)表示算法执行时间的增长率和问题规模n的增长率相同，用O(f...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值