精华内容
下载资源
问答
  • 数组队列和链表队列

    2013-04-20 12:08:11
    无论使用数组还使用链表来实现队列,都是要实现几个基本的任务,例如添加,取出,删除和插入等。他们的区别在于使用的形式不同。 用数组实现队列的关键是创建两个数组,在实现类的内部,还是使用数组保存装入的...
    上一周我们学习了用数组来实现队列和用链表来实现队列。数组和链表还有队列的本质都是一样的,都可以理解为用来装东西的容器。
    无论使用数组还使用链表来实现队列,都是要实现几个基本的任务,例如添加,取出,删除和插入等。他们的区别在于使用的形式不同。
    用数组实现队列的关键是创建两个数组,在实现类的内部,还是使用数组保存装入的队列的对象,每次新加入对象时,则创建一个比原来数组长度大于1的数组。优点是可以实现存储多个数据而不必担心数组越界,缺点是存储过程中如果要在指定位置插入和删除会比较麻烦,必须要把指定位置后面的数组整个后移或者前移。
    用链表实现队列的好处是可以很方便的实现定点插入和删除,麻烦的是链表的遍历。
    在使用数组或者链表实现队列的时候,我们可以先定义一个接口list实现基本操作如添加,删除,插入和查找等,然后再用具体的数组队列arraylist,链表队列linklist去实现list的基本方法。
    下面是我写的一段代码,本来是想写五子棋的,可是只写到现在,还不能实现五子棋的人机对战。不过里面有写用链表队列来保存鼠标按下点的坐标。
    package cn.netjava.cf0413;

    import java.awt.Color;
    import java.awt.Graphics;

    import javax.swing.JFrame;


    public class RewritePaint extends JFrame {

    MouListener dl;
    public static void main(String[] args) {
    RewritePaint rp=new RewritePaint();
    rp.unit();
    }
    public void unit(){

    //设置窗体的各项参数
    this.setSize(900, 700);
    this.setLocationRelativeTo(null);
    this.setVisible(true);
    Graphics g=this.getGraphics();
    //加一个鼠标监听器
    dl=new MouListener(g);
    this.addMouseListener(dl);
    }

    public void paint(Graphics g){
    //绘制五子棋的表格
    super.paint(g);
    int x=100,y=100;
    int h=50,n=12,m=15;
    for(int k=0;k<n;k++){
    //绘制表格中的横线
    g.drawLine(x, y+k*h, x+14*h, y+k*h);
    }
    for(int k=0;k<m;k++){
    //绘制表格中的竖线
    g.drawLine(x+k*h, y, x+k*h, y+11*h);

    }
    int i=0;
    //接口List实例化一个list对象,用来取出所存的数据
    List<Point> list = dl.getList();
    for(int k = 0; k < list.size(); k++){
    Point p = list.get(k);
    System.out.println("x="+p.x+" y="+p.y);
    //按照记录的坐标点重画五子棋,并实现黑白颜色的转换
    int x1,y1;
    x1 = p.x;
    y1 = p.y;
    if(i%2==0){
    g.setColor(Color.BLACK);
    }
    else{
    g.setColor(Color.WHITE);
    }
    m=(x1-100)%50;
    n=(y1-100)%50;
    if(m<25){
    x1=(x1-m);
    }
    else{
    x1=(x1-m)+50;
    }
    if(n<25){
    y1=(y1-n);
    }
    else{
    y1=(y1-n)+50;
    }
    g.fillOval(x1-25, y1-25,50,50);
    i++;

    }
    }

    }
    package cn.netjava.cf0413;

    import java.awt.Color;
    import java.awt.Graphics;
    import java.awt.event.MouseEvent;
    import java.awt.event.MouseListener;

    public class MouListener implements MouseListener {
    private Graphics g;
    int i=0;
    int x1,y1;
    private LinkList<Point> list = new LinkList<Point>();
    public MouListener(Graphics g) {
    this.g = g;
    }
    //取出接口List中记录的数据
    public List<Point> getList(){
    return list;
    }

    public void mouseClicked(MouseEvent e) {
    System.out.println("按下");
    x1 = e.getX();
    y1 = e.getY();
    if(i%2==0){
    g.setColor(Color.BLACK);
    }
    else{
    g.setColor(Color.WHITE);
    }
    int m=(x1-100)%50;
    int n=(y1-100)%50;
    if(m<25){
    x1=(x1-m);
    }
    else{
    x1=(x1-m)+50;
    }
    if(n<25){
    y1=(y1-n);
    }
    else{
    y1=(y1-n)+50;
    }
    g.fillOval(x1-25, y1-25,50,50);
    i++;
    //用point类记录x1,y1
    Point point = new Point(x1,y1);
    //用接口list实现添加坐标到队列
    list.add(point);

    }

    public void mousePressed(MouseEvent e) {

    }


    public void mouseReleased(MouseEvent e) {

    }


    public void mouseEntered(MouseEvent e) {

    }


    public void mouseExited(MouseEvent e) {

    }


    }
    package cn.netjava.cf0413;
    //创建一个Point类用来记录坐标点
    public class Point {
    public int x;
    public int y;

    public Point(int x, int y){
    this.x = x;
    this.y = y;
    }
    }
    package cn.netjava.cf0413;

    public interface List<E> {

    //实现添加操作
    public void add(E obj);
    //求长度
    public int size();
    //取出操作
    public E get(int index);
    //删除操作
    public void remove(int index);
    //插入操作
    public void insert(int index, E obj);
    }
    package cn.netjava.cf0413;
    //定义一个链表,实现链表的基本操作
    public class Node<E> {

    private E e;
    Node<E> next;
    public E getData() {
    return e;
    }
    public void setData(E e) {
    this.e = e;
    }
    public Node<E> getNext() {
    return next;
    }
    public void setNext(Node<E> next) {
    this.next = next;
    }

    }package cn.netjava.cf0413;
    //用链表队列实现接口的方法,用链表队列来记录坐标点
    public class LinkList<E> implements List<E> {
    private Node<E> root;
    private Node<E> last;

    public void add(E obj) {
    Node<E> node = new Node<E>();
    node.setData(obj);

    if(root==null){
    root = node;
    last = root;
    } else {
    last.setNext(node);
    last = node;
    }
    }

    public int size() {
    int size = 0;
    if(root != null){
    Node<E> temp = root;
    while(temp != null){
    size++;
    temp = temp.getNext();
    }
    }
    return size;
    }

    @Override
    public E get(int index) {
    int len = size();
    if(index < 0 || index >= len)
    throw new java.lang.ArrayIndexOutOfBoundsException("超出范围:0-"+len);
    Node<E> temp = root;
    for(int i = 0; i < index; i++){
    temp = temp.getNext();
    }

    return temp.getData();
    }

    @Override
    public void remove(int index) {
    // TODO Auto-generated method stub

    }

    @Override
    public void insert(int index, Object obj) {
    // TODO Auto-generated method stub

    }

    }
    上面的代码是用的链表队列记录坐标点,如果想实现用数组队列记录的话,就只需要重新写一个ArrayList实现接口List的方法,然后再将鼠标监听器方法中的private LinkList<Point> list = new LinkList<Point>();改成private ArrayList<Point> list = new ArrayList<Point>();
    ArrayList代码如下:
    package cn.netjava.cf0413;
    //用数组队列来实现List的方法,记录坐标点
    public class ArrayList<E> implements List<E> {
    private Object[] arr = new Object[10];
    private int len = 0;

    public void add(E obj) {
    if(len < arr.length){
    arr[len++] = obj;
    } else {
    Object[] arr2 = new Object[arr.length+10];
    for(int i = 0; i < arr.length; i++){
    arr2[i] = arr[i];
    }
    arr2[len++] = obj;
    arr = arr2;
    }
    }

    public int size() {
    return len;
    }

    public E get(int index) {
    if(index < 0 || index > len)
    throw new java.lang.ArrayIndexOutOfBoundsException("超出范围: 0-"+len);
    return (E)arr[index];
    }

    public void remove(int index) {

    }


    public void insert(int index, Object obj) {

    }


    }
    展开全文
  • /*** 简单的线程池与任务队列**/public class WorkQueue {private final int nThreads;// 线程池的大小private final PoolWorker[] threads;// 用数组实现线程池private final LinkedList queue;// 任务队列public ...

    [java]代码库import java.util.*;

    /**

    * 简单的线程池与任务队列

    *

    */

    public class WorkQueue {

    private final int nThreads;// 线程池的大小

    private final PoolWorker[] threads;// 用数组实现线程池

    private final LinkedList queue;// 任务队列

    public WorkQueue(int nThreads) {

    this.nThreads = nThreads;

    queue = new LinkedList();

    threads = new PoolWorker[nThreads];

    for (int i = 0; i < nThreads; i++) {

    threads[i] = new PoolWorker();

    threads[i].start();// 启动所有工作线程

    }

    }

    public void execute(Runnable r) {// 执行任务

    synchronized (queue) {

    queue.addLast(r);

    queue.notify();

    }

    }

    private class PoolWorker extends Thread {// 工作线程类

    public void run() {

    Runnable r;

    while (true) {

    synchronized (queue) {

    while (queue.isEmpty()) {// 如果任务队列中没有任务,等待

    try {

    queue.wait();

    } catch (InterruptedException ignored) {

    }

    }

    r = (Runnable) queue.removeFirst();// 有任务时,取出任务

    }

    try {

    r.run();// 执行任务

    } catch (Exception e) {

    // TODO: handle exception

    }

    }

    }

    }

    public static void main(String args[]) {

    WorkQueue wq = new WorkQueue(10);// 10个工作线程

    Mytask r[] = new Mytask[20];// 20个任务

    for (int i = 0; i < 20; i++) {

    r[i] = new Mytask();

    wq.execute(r[i]);

    }

    }

    }

    class Mytask implements Runnable {// 任务接口

    public void run() {

    String name = Thread.currentThread().getName();

    try {

    Thread.sleep(100);// 模拟任务执行的时间

    } catch (Exception e) {

    // TODO: handle exception

    }

    System.out.println(name + " executed OK");

    }

    }

    694748ed64b9390909c0d88230893790.png

    展开全文
  • 现有一任务队列task[],长度为n,task中的元素值表示任务的优先级,数值越小,优先级越高。函数scheduler实现如下功能,将task[] 中的任务按照系统任务、用户任务依次存放到 system_task[] 数组和 

    操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。其中,系统任务的优先级 < 50,用户任务的优先级 >= 50 <= 255。优先级大于255的为非法任务,应予以剔除。现有一任务队列task[],长度为ntask中的元素值表示任务的优先级,数值越小,优先级越高。函数scheduler实现如下功能,将task[] 中的任务按照系统任务、用户任务依次存放到 system_task[] 数组和 user_task[] 数组中(数组中元素的值是任务在task[] 数组中的下标),并且优先级高的任务排在前面,数组元素为-1表示结束。
    例如:task[] = 

    {0, 30, 155, 1, 80, 300, 170, 40, 99}

    system_task[] = {0, 3, 1, 7, -1}    user_task[] = {4, 8, 2, 6, -1}

    函数接口    void scheduler(int task[], int n, int system_task[], int user_task[]) 

    #include
    using namespace std;
    void sort(int a[],int n)
    {
    int i=0,j=0,temp;
    for(;i
    for(j=0;j
    {
    if(a[j]>a[j+1])
    {
    temp=a[j];
    a[j]=a[j+1];
    a[j+1]=temp;
    }
    }
    }
    void scheduler(int task[], int n, int system_task[], int user_task[])
    {
    int i,sys_count=0,u_count=0;
    for(i=0;i
    {
    if(task[i]<50)
    system_task[sys_count++]=task[i];
    else if(task[i]>=50&&task[i]<=255)
    user_task[u_count++]=task[i];
    }
    system_task[sys_count]=-1;
    user_task[u_count]=-1;
    sort(system_task,sys_count);
    sort(user_task,u_count);
    int j;
    for(j=0;j
    for(i=0;i
    {
    if(system_task[j]==task[i])
    {
    system_task[j]=i;
    break;
    }
    }
    for(j=0;j
    for(i=0;i
    {
    if(user_task[j]==task[i])
    {
    user_task[j]=i;
    break;
    }
    }
    }
    void main()
    {
    int task[]={0, 30, 155, 1, 80, 300, 170, 40, 99,33,50};
    int n=sizeof(task)/sizeof(int)+1;
    int *system_task=new int[n];
    int *user_task=new int[n];
    scheduler(task,n-1,system_task,user_task);
    int i=0;
    cout<<"系统数组为"<<endl;
    while(system_task[i]!=-1)
    cout<<system_task[i++]<<" ";
    i=0;
    cout<<"用户数组为"<<endl;
    while(user_task[i]!=-1)
    cout<<user_task[i++]<<" ";
    cout<<endl;
    }
    展开全文
  • 1 import java.util.*;2 public class WorkQueue3 {4 private final int nThreads;//线程池的大小5 private final PoolWorker[] threads;//用数组实现线程池6 private final ...//任务队列78 public WorkQueu...

    1 import java.util.*;

    2 public class WorkQueue

    3 {

    4    private final int nThreads;//线程池的大小

    5    private final PoolWorker[] threads;//用数组实现线程池

    6    private final LinkedList queue;//任务队列

    7

    8   public WorkQueue(int nThreads){

    9      this.nThreads = nThreads;

    10      queue = new LinkedList();

    11      threads = new PoolWorker[nThreads];

    12

    13       for (int i=0; i

    14          threads[i] = new PoolWorker();

    15          threads[i].start();//启动所有工作线程

    16       }

    17   }

    c643ba0ef59428b06737509fcbeb4644.png

    18

    19   public void execute(Runnable r) {//执行任务

    20     synchronized(queue) {

    21             queue.addLast(r);

    22             queue.notify();

    23     }

    24   }

    25

    26   private class PoolWorker extends Thread {//工作线程类

    27         public void run() {

    28                Runnable r;

    29                while (true) {

    30                     synchronized(queue) {

    31                       while (queue.isEmpty()) {//如果任务队列中没有任务,等待

    32                         try{

    33                           queue.wait();

    34                         }catch (InterruptedException ignored){}

    35                       }

    36                        r = (Runnable) queue.removeFirst();//有任务时,取出任务

    37                    }

    38                    try {

    39                        r.run();//执行任务

    40                    }catch (RuntimeException e) {

    41                       // You might want to log something here

    42                   }

    43               }

    44       }

    45    }

    46

    47

    48  public static void main(String args[]){

    49       WorkQueue wq=new WorkQueue(10);//10个工作线程

    50       Mytask r[]=new Mytask[20];//20个任务

    51

    52       for(int i=0;i<20;i++){

    53            r[i]=new Mytask();

    54            wq.execute(r[i]);

    55       }

    56  }

    57 }

    58 class Mytask implements Runnable{//任务接口

    59          public void run(){

    60               String name=Thread.currentThread()。getName();

    61               try{

    62                   Thread.sleep(100);//模拟任务执行的时间

    63               }catch(InterruptedException e){}

    64               System.out.println(name+" executed OK");

    65          }

    66   }

    展开全文
  • import java.util.*;public class WorkQueue {private final int nThreads;// 线程池的大小private final PoolWorker[] threads;// 用数组实现线程池private ...// 任务队列public WorkQueue(int nThreads) {this....
  • 原文:数据结构基础 (代码效率优化, 线性表, 栈, 队列, 数组,字符串,树和二叉树,哈希表) 代码效率优化 复杂度 -- 一个关于输入数据量n的函数 时间复杂度 -- 昂贵 与代码的结构设计有着紧密关系 ...
  • 队列队列算法实现:使用数组队列队列算法实现:使用链表队列 队列算法实现:使用数组队列 队列是一种受限的线性表 队列算法实现:使用链表队列
  • 作者:张人大代码效率优化复杂度 -- 一个关于输入数据量n的函数时间复杂度 -- 昂贵与代码的结构设计有着紧密关系一个顺序结构的代码,时间复杂度是O(1), 即任务与算例个数 n 无关空间复杂度 -- 廉价与数据结构设计...
  • 理想的做法应该对这些任务进行限制,比如一次只跑几个,当其中一些任务完成后,再添加新的任务队列。 总的来说,我们需要这样一个服务,它提供一个添加任务的方法,内部将添加的方法维护在一个数组...
  • 利用数组模拟队列,其中有三个重要变量: 变量 含义 maxSize 队列最大容量 front 随数据输出变化(指向队列头前一个位置) rear 随数据输入变化(指向队列最后一个数据) 队列空: rear=front; 队列...
  • 基于数组的无锁队列

    2016-04-25 22:38:52
    在过去,多数计算机只有一个处理器,线程主要用于将一个大的任务拆分成一系列更小的执行单元.以使得当其中某些执行单元因为等待资源而被阻塞的时候剩余的执行单元能继续执行。举个示例,一个网络应用程序,它监听一个TCP...
  • 前言模拟的非常简单,简单到只是...下载各种.avi时,如果有15个以上的任务需要下载,假设指定5个同时下载,那么剩下的十个就是在队列里等待,先下载的先完成。队列就是这样一个“先进先出”、”后进后出”的数据结构。
  • 最精简的java 线程池与任务队列

    万次阅读 2013-06-14 16:16:50
    import java.util.*; public class WorkQueue { private final int nThreads;// 线程池的大小 private final PoolWorker[] threads;// 用数组实现线程池 ...// 任务队列 public WorkQueue(int nThre
  • 作者:张人大代码效率优化复杂度 -- 一个关于输入数据量n的函数时间复杂度 -- 昂贵与代码的结构设计有着紧密关系一个顺序结构的代码,时间复杂度是O(1), 即任务与算例个数 n 无关空间复杂度 -- 廉价与数据结构设计...
  • 作者:张人大代码效率优化复杂度 -- 一个关于输入数据量n的函数时间复杂度 -- 昂贵与代码的结构设计有着紧密关系一个顺序结构的代码,时间复杂度是O(1), 即任务与算例个数 n 无关空间复杂度 -- 廉价与数据结构设计...
  • 环形队列,例如可以创建一个包含3600个slot的环形队列(本质是个数组)2.任务集合,环上每一个slot是一个Set同时,启动一个timer,这个timer每隔1s,在上述环形队列中移动一格,有一个Current Index指针来标识正在检测...
  • 作者:张人大代码效率优化复杂度 -- 一个关于输入数据量n的函数时间复杂度 -- 昂贵与代码的结构设计有着紧密关系一个顺序结构的代码,时间复杂度是O(1), 即任务与算例个数 n 无关空间复杂度 -- 廉价与数据结构设计...
  • YTask 是 Go 的异步任务队列,比起其他框架更方便快捷。 架构图: 特性: 支持几乎所有类型,包括基本类型(int, floalt, string),数组切片,结构体以及复杂的结构体嵌套。 注册任务,调用任务一行代码完成...
  • 顺序存储 采用数组来保存队列的元素,设立一个队首指针 front ,一个队尾指针 rear,分别指向队首和队尾元素。则 rear-front 即为存储的元素个数!
  • 最近刚看完python多线程,为了加深印象,按照1分钟实现...1.环形队列,例如可以创建一个包含3600个slot的环形队列(本质是个数组) 2.任务集合,环上每一个slot是一个Set<Task> 同时,启动一个timer,这个t...
  • 代码效率优化复杂度 -- 一个关于输入数据量n的函数时间复杂度 -- 昂贵与代码的结构设计有着紧密关系一个顺序结构的代码,时间复杂度是O(1), 即任务与算例个数 n 无关空间复杂度 -- 廉价与数据结构设计有关数据结构 -...
  • kiner算法刷题记(三):线程池与任务队列 概念 有一个连续的存储区存储任意结构,有头指针和尾指针,尾指针一般指向最后一个元素的下一位 先入先出(FIFO) 基本操作 一个最简单的队列结构至少要支持以下两种操作...
  • 上面的一篇文章,我们介绍了线程池的拒接策列,这篇文章开始我们介绍线程池任务队列中的等待队列—— ArraBlockingQueue。 先看看ArrayBlockingQueue的继承和实现的关系的图。 ArrayBlockQueue是一个有界的队列,这...
  • Laravel 8 附带了很酷的新特性,并对队列系统的一些更改。在本文中,我们将研究这些特性和更改。变化Backoff (回退)已将retryAfter()方法和retryAfter排队作业,邮件,通知和侦听器的属性重命名为backoff。...
  • 原文 1 引言 ...在过去,多数计算机只有一个处理器,线程主要用于将一个大的任务拆分成一系列更小的执行单元.以使得当其中某些执行单元因为等待资源而被阻塞的时候剩余的执行单元能继续执行。举个...
  • 1.环形队列,例如可以创建一个包含3600个slot的环形队列(本质是个数组) 2.任务集合,环上每一个slot是一个Set 同时,启动一个timer,这个timer每隔1s,在上述环形队列中移动一格,有一个Current Index指针来标识...
  • 代码效率优化复杂度 -- 一个关于输入数据量n的函数时间复杂度 -- 昂贵与代码的结构设计有着紧密关系一个顺序结构的代码,时间复杂度是O(1), 即任务与算例个数 n 无关空间复杂度 -- 廉价与数据结构设计有关数据结构 -...
  • 线程池本质上所使用的逻辑模型仍然是我们熟悉的“生产者/...队列和线程池(线程池内部维护一个线程数组),完全耦合在一起,当任务特别多,队列就不断的膨胀,增多,拥堵;就向车子过洞子 另外一头走不掉,我靠,长...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 834
精华内容 333
关键字:

任务队列数组