Jack-Chan
Jack-Chan

Java数据结构和算法：数组、单链表、双链表

1. 概要

线性表是一种线性结构，它是具有相同类型的n(n≥0)个数据元素组成的有限序列。本章先介绍线性表的几个基本组成部分：数组、单向链表、双向链表；随后给出双向链表的C、C++和Java三种语言的实现

2. 数组

数组有上界和下界，数组的元素在上下界内是连续的。存储10,20,30,40,50的数组的示意图如下

Java数据结构和算法：数组、单链表、双链表_第1张图片

数组的特点是：数据是连续的；随机访问速度快。

数组中稍微复杂一点的是多维数组和动态数组。对于C语言而言，多维数组本质上也是通过一维数组实现的。至于动态数组，是指数组的容量能动态增长的数组；对于C语言而言，若要提供动态数组，需要手动实现；而对于C++而言，STL提供了Vector；对于Java而言，Collection集合中提供了ArrayList和Vector。

3. 单向链表

单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针。

单链表的示意图如下：

单链表

表头为空，表头的后继节点是”节点10”(数据为10的节点)，”节点10”的后继节点是”节点20”(数据为10的节点)

3.1 单链表删除节点

单链表

删除”节点30”
删除之前：”节点20” 的后继节点为”节点30”，而”节点30” 的后继节点为”节点40”。
删除之后：”节点20” 的后继节点为”节点40”。

3.2 单链表添加节点

单链表

在”节点10”与”节点20”之间添加”节点15”
添加之前：”节点10” 的后继节点为”节点20”。
添加之后：”节点10” 的后继节点为”节点15”，而”节点15” 的后继节点为”节点20”。

单链表的特点是：节点的链接方向是单向的；相对于数组来说，单链表的的随机访问速度较慢，但是单链表删除/添加数据的效率很高。

4. 双向链表

双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

双链表的示意图如下：

双链表

表头为空，表头的后继节点为”节点10”(数据为10的节点)；”节点10”的后继节点是”节点20”(数据为10的节点)，”节点20”的前继节点是”节点10”；”节点20”的后继节点是”节点30”，”节点30”的前继节点是”节点20”；…；末尾节点的后继节点是表头。

4.1 双链表删除节点

双链表

删除”节点30”
删除之前：”节点20”的后继节点为”节点30”，”节点30” 的前继节点为”节点20”。”节点30”的后继节点为”节点40”，”节点40” 的前继节点为”节点30”。
删除之后：”节点20”的后继节点为”节点40”，”节点40” 的前继节点为”节点20”。

4.2 双链表添加节点

双链表

在”节点10”与”节点20”之间添加”节点15”
添加之前：”节点10”的后继节点为”节点20”，”节点20” 的前继节点为”节点10”。
添加之后：”节点10”的后继节点为”节点15”，”节点15” 的前继节点为”节点10”。”节点15”的后继节点为”节点20”，”节点20” 的前继节点为”节点15”。

5. Java实现双链表

/**
 * Java 实现的双向链表。 
 * 注：java自带的集合包中有实现双向链表，路径是:java.util.LinkedList
 *
 * @author skywang
 * @date 2013/11/07
 */
public class DoubleLink<T> {

    // 表头
    private DNode mHead;
    // 节点个数
    private int mCount;

    // 双向链表“节点”对应的结构体
    private class DNode<T> {
        public DNode prev;
        public DNode next;
        public T value;

        public DNode(T value, DNode prev, DNode next) {
            this.value = value;
            this.prev = prev;
            this.next = next;
        }
    }

    // 构造函数
    public DoubleLink() {
        // 创建“表头”。注意：表头没有存储数据！
        mHead = new DNode(null, null, null);
        mHead.prev = mHead.next = mHead;
        // 初始化“节点个数”为0
        mCount = 0;
    }

    // 返回节点数目
    public int size() {
        return mCount;
    }

    // 返回链表是否为空
    public boolean isEmpty() {
        return mCount==0;
    }

    // 获取第index位置的节点
    private DNode getNode(int index) {
        if (index<0 || index>=mCount)
            throw new IndexOutOfBoundsException();

        // 正向查找
        if (index <= mCount/2) {
            DNode node = mHead.next;
            for (int i=0; ireturn node;
        }

        // 反向查找
        DNode rnode = mHead.prev;
        int rindex = mCount - index -1;
        for (int j=0; jreturn rnode;
    }

    // 获取第index位置的节点的值
    public T get(int index) {
        return getNode(index).value;
    }

    // 获取第1个节点的值
    public T getFirst() {
        return getNode(0).value;
    }

    // 获取最后一个节点的值
    public T getLast() {
        return getNode(mCount-1).value;
    }

    // 将节点插入到第index位置之前
    public void insert(int index, T t) {
        if (index==0) {
            DNode node = new DNode(t, mHead, mHead.next);
            mHead.next.prev = node;
            mHead.next = node;
            mCount++;
            return ;
        }

        DNode inode = getNode(index);
        DNode tnode = new DNode(t, inode.prev, inode);
        inode.prev.next = tnode;
        inode.next = tnode;
        mCount++;
        return ;
    }

    // 将节点插入第一个节点处。
    public void insertFirst(T t) {
        insert(0, t);
    }

    // 将节点追加到链表的末尾
    public void appendLast(T t) {
        DNode node = new DNode(t, mHead.prev, mHead);
        mHead.prev.next = node;
        mHead.prev = node;
        mCount++;
    }

    // 删除index位置的节点
    public void del(int index) {
        DNode inode = getNode(index);
        inode.prev.next = inode.next;
        inode.next.prev = inode.prev;
        inode = null;
        mCount--;
    }

    // 删除第一个节点
    public void deleteFirst() {
        del(0);
    }

    // 删除最后一个节点
    public void deleteLast() {
        del(mCount-1);
    }
}

测试程序(DlinkTest.java)

/**
 * Java 实现的双向链表。 
 * 注：java自带的集合包中有实现双向链表，路径是:java.util.LinkedList
 *
 * @author skywang
 * @date 2013/11/07
 */

public class DlinkTest {

    // 双向链表操作int数据
    private static void int_test() {
        int[] iarr = {10, 20, 30, 40};

        System.out.println("\n----int_test----");
        // 创建双向链表
        DoubleLink dlink = new DoubleLink();

        dlink.insert(0, 20);    // 将 20 插入到第一个位置
        dlink.appendLast(10);    // 将 10 追加到链表末尾
        dlink.insertFirst(30);    // 将 30 插入到第一个位置

        // 双向链表是否为空
        System.out.printf("isEmpty()=%b\n", dlink.isEmpty());
        // 双向链表的大小
        System.out.printf("size()=%d\n", dlink.size());

        // 打印出全部的节点
        for (int i=0; i"dlink("+i+")="+ dlink.get(i));
    }


    private static void string_test() {
        String[] sarr = {"ten", "twenty", "thirty", "forty"};

        System.out.println("\n----string_test----");
        // 创建双向链表
        DoubleLink dlink = new DoubleLink();

        dlink.insert(0, sarr[1]);    // 将 sarr中第2个元素 插入到第一个位置
        dlink.appendLast(sarr[0]);    // 将 sarr中第1个元素 追加到链表末尾
        dlink.insertFirst(sarr[2]);    // 将 sarr中第3个元素 插入到第一个位置

        // 双向链表是否为空
        System.out.printf("isEmpty()=%b\n", dlink.isEmpty());
        // 双向链表的大小
        System.out.printf("size()=%d\n", dlink.size());

        // 打印出全部的节点
        for (int i=0; i"dlink("+i+")="+ dlink.get(i));
    }


    // 内部类
    private static class Student {
        private int id;
        private String name;

        public Student(int id, String name) {
            this.id = id;
            this.name = name;
        }

        @Override
        public String toString() {
            return "["+id+", "+name+"]";
        }
    }

    private static Student[] students = new Student[]{
        new Student(10, "sky"),
        new Student(20, "jody"),
        new Student(30, "vic"),
        new Student(40, "dan"),
    };

    private static void object_test() {
        System.out.println("\n----object_test----");
        // 创建双向链表
        DoubleLink dlink = new DoubleLink();

        dlink.insert(0, students[1]);    // 将 students中第2个元素 插入到第一个位置
        dlink.appendLast(students[0]);    // 将 students中第1个元素 追加到链表末尾
        dlink.insertFirst(students[2]);    // 将 students中第3个元素 插入到第一个位置

        // 双向链表是否为空
        System.out.printf("isEmpty()=%b\n", dlink.isEmpty());
        // 双向链表的大小
        System.out.printf("size()=%d\n", dlink.size());

        // 打印出全部的节点
        for (int i=0; i"dlink("+i+")="+ dlink.get(i));
        }
    }


    public static void main(String[] args) {
        int_test();        // 演示向双向链表操作“int数据”。
        string_test();    // 演示向双向链表操作“字符串数据”。
        object_test();    // 演示向双向链表操作“对象”。
    }
}

运行结果

----int_test----
isEmpty()=false
size()=3
dlink(0)=30
dlink(1)=20
dlink(2)=10

----string_test----
isEmpty()=false
size()=3
dlink(0)=thirty
dlink(1)=twenty
dlink(2)=ten

----object_test----
isEmpty()=false
size()=3
dlink(0)=[30, vic]
dlink(1)=[20, jody]
dlink(2)=[10, sky]

6. 双链表实现2

public class MyDoubleLink implements Iterable<Object>{
    private class Node{
        public Node(Object data){
            this.data = data;
        }
        Node next;
        Node prev;
        Object data;
    }
    private Node head;
    private Node rear;

    public void add(Object data){
        Node node = new Node(data);
        if (head == null){
            head = node;
            rear = node;
        } else {
            rear.next = node;
            node.prev = rear;
            rear = node;
        }
    }

    public boolean contains(Object data){
        Node node = find(data);
        return node != null;
    }

    public void print(){
        Node temp = head;
        while(temp != null){
            System.out.print(temp.data + ",");
            temp = temp.next;
        }
        System.out.println();
    }
    private Node find(Object data){
        Node node = head;
        while (node != null){
            if (node.data.equals(data) && node.data.hashCode() == data.hashCode()){
                break;
            } else {
                node = node.next;
            }
        }
        return node;
    }

    public void remove(Object data){
        Node node = find(data);
        if (node != null){
            if (node == head && node == rear){//只有一个节点
                head = null;
                rear = null;
            } else if (node == head){ //头节点
                head = head.next;
                head.prev = null;
            } else if (node == rear){ //尾节点
                rear = rear.prev;
                rear.next = null;
            } else { //中间节点
                node.prev.next = node.next;
                node.next.prev = node.prev;
            }
        }
    }

    @Override
    public Iterator iterator() {
        Iterator ite = new Iterator() {
            private Node temp = head;
            @Override
            public boolean hasNext() {
                return temp != null;
            }

            @Override
            public Object next() {
                // TODO Auto-generated method stub
                Object data = temp.data;
                temp = temp.next;
                return data;
            }

            @Override
            public void remove() {
                // TODO Auto-generated method stub      
            }
        };
        return ite;
    }   
} 
  
6.1 测试双链表
 
  
public class Test {

    public static  class Instance{
        public Instance(int i){

        }
        public Instance(){

        }
    }

    public static void main(String[] args) {
        Instance in  = new Instance(){

        };
        MyDoubleLink datas = new MyDoubleLink();
        datas.add("aaa");
        datas.add("bbb");
        datas.add("ccc");
        datas.print();
        datas.remove("ccc");
        datas.print();
        for (Object d : datas) {
            System.out.println(d);
        }
    }
}
 
  
7. 双链表
 
  
import java.util.Iterator;
public class MyDoubleLink implements Iterable<Object>{
    private class Node{
        public Node(Object data){
            this.data = data;
        }
        Node next;
        Node prev;
        Object data;
    }
    private Node head;
    private Node rear;

    public void add(Object data){
        Node node = new Node(data);
        if (head == null){
            head = node;
            rear = node;
        } else {
            rear.next = node;
            node.prev = rear;
            rear = node;
        }
    }

    public boolean contains(Object data){
        Node node = find(data);
        return node != null;
    }

    public void print(){
        Node temp = head;
        while(temp != null){
            System.out.print(temp.data + ",");
            temp = temp.next;
        }
        System.out.println();
    }
    private Node find(Object data){
        Node node = head;
        while (node != null){
            if (node.data.equals(data) && node.data.hashCode() == data.hashCode()){
                break;
            } else {
                node = node.next;
            }
        }
        return node;
    }

    public void remove(Object data){
        Node node = find(data);
        if (node != null){
            if (node == head && node == rear){//只有一个节点
                head = null;
                rear = null;
            } else if (node == head){ //头节点
                head = head.next;
                head.prev = null;
            } else if (node == rear){ //尾节点
                rear = rear.prev;
                rear.next = null;
            } else { //中间节点
                node.prev.next = node.next;
                node.next.prev = node.prev;
            }
        }
    }

    @Override
    public Iterator iterator() {
        Iterator ite = new Iterator() {
            private Node temp = head;
            @Override
            public boolean hasNext() {
                return temp != null;
            }

            @Override
            public Object next() {
                // TODO Auto-generated method stub
                Object data = temp.data;
                temp = temp.next;
                return data;
            }

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

            }
        };
        return ite;
    }
} 
  

public class TEst {

    public static  class Instance{
        public Instance(int i){

        }
        public Instance(){

        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Instance in  = new Instance(){

        };
        MyDoubleLink datas = new MyDoubleLink();
        datas.add("aaa");
        datas.add("bbb");
        datas.add("ccc");
        datas.print();
        datas.remove("ccc");
        datas.print();
        for (Object d : datas) {
            System.out.println(d);
        }
    }
}
 
  
7.1 单链表的实现
 
  
// linkList2.java
// demonstrates linked list
// to run this program: C>java LinkList2App
////////////////////////////////////////////////////////////////
class Link
   {
   public int iData;              // data item (key)
   public double dData;           // data item
   public Link next;              // next link in list
// -------------------------------------------------------------
   public Link(int id, double dd) // constructor
      {
      iData = id;
      dData = dd;
      }
// -------------------------------------------------------------
   public void displayLink()      // display ourself
      {
      System.out.print("{" + iData + ", " + dData + "} ");
      }
   }  // end class Link
////////////////////////////////////////////////////////////////
class LinkList
   {
   private Link first;            // ref to first link on list

// -------------------------------------------------------------
   public LinkList()              // constructor
      {
      first = null;               // no links on list yet
      }
// -------------------------------------------------------------
   public void insertFirst(int id, double dd)
      {                           // make new link
      Link newLink = new Link(id, dd);
      newLink.next = first;       // it points to old first link
      first = newLink;            // now first points to this
      }
// -------------------------------------------------------------
   public Link find(int key)      // find link with given key
      {                           // (assumes non-empty list)
      Link current = first;              // start at 'first'
      while(current.iData != key)        // while no match,
         {
         if(current.next == null)        // if end of list,
            return null;                 // didn't find it
         else                            // not end of list,
            current = current.next;      // go to next link
         }
      return current;                    // found it
      }
// -------------------------------------------------------------
   public Link delete(int key)    // delete link with given key
      {                           // (assumes non-empty list)
      Link current = first;              // search for link
      Link previous = first;
      while(current.iData != key)
         {
         if(current.next == null)
            return null;                 // didn't find it
         else
            {
            previous = current;          // go to next link
            current = current.next;
            }
         }                               // found it
      if(current == first)               // if first link,
         first = first.next;             //    change first
      else                               // otherwise,
         previous.next = current.next;   //    bypass it
      return current;
      }
// -------------------------------------------------------------
   public void displayList()      // display the list
      {
      System.out.print("List (first-->last): ");
      Link current = first;       // start at beginning of list
      while(current != null)      // until end of list,
         {
         current.displayLink();   // print data
         current = current.next;  // move to next link
         }
      System.out.println("");
      }
// -------------------------------------------------------------
   }  // end class LinkList
////////////////////////////////////////////////////////////////
class LinkList2App
   {
   public static void main(String[] args)
      {
      LinkList theList = new LinkList();  // make list

      theList.insertFirst(22, 2.99);      // insert 4 items
      theList.insertFirst(44, 4.99);
      theList.insertFirst(66, 6.99);
      theList.insertFirst(88, 8.99);

      theList.displayList();              // display list

      Link f = theList.find(44);          // find item
      if( f != null)
         System.out.println("Found link with key " + f.iData);
      else
         System.out.println("Can't find link");

      Link d = theList.delete(66);        // delete item
      if( d != null )
         System.out.println("Deleted link with key " + d.iData);
      else
         System.out.println("Can't delete link");

      theList.displayList();              // display list
      }  // end main()
   }  // end class LinkList2App
////////////////////////////////////////////////////////////////

 
  
7.2 有序链表
 
  
// sortedList.java
// demonstrates sorted list
// to run this program: C>java SortedListApp
////////////////////////////////////////////////////////////////
class Link
   {
   public long dData;                  // data item
   public Link next;                   // next link in list
// -------------------------------------------------------------
   public Link(long dd)                // constructor
      { dData = dd; }
// -------------------------------------------------------------
   public void displayLink()           // display this link
      { System.out.print(dData + " "); }
   }  // end class Link
////////////////////////////////////////////////////////////////
class SortedList
   {
   private Link first;                 // ref to first item
// -------------------------------------------------------------
   public SortedList()                 // constructor
      { first = null; }
// -------------------------------------------------------------
   public boolean isEmpty()            // true if no links
      { return (first==null); }
// -------------------------------------------------------------
   public void insert(long key)        // insert, in order
      {
      Link newLink = new Link(key);    // make new link
      Link previous = null;            // start at first
      Link current = first;
                                       // until end of list,
      while(current != null && key > current.dData)
         {                             // or key > current,
         previous = current;
         current = current.next;       // go to next item
         }
      if(previous==null)               // at beginning of list
         first = newLink;              // first --> newLink
      else                             // not at beginning
         previous.next = newLink;      // old prev --> newLink
      newLink.next = current;          // newLink --> old currnt
      }  // end insert()
// -------------------------------------------------------------
   public Link remove()           // return & delete first link
      {                           // (assumes non-empty list)
      Link temp = first;               // save first
      first = first.next;              // delete first
      return temp;                     // return value
      }
// -------------------------------------------------------------
   public void displayList()
      {
      System.out.print("List (first-->last): ");
      Link current = first;       // start at beginning of list
      while(current != null)      // until end of list,
         {
         current.displayLink();   // print data
         current = current.next;  // move to next link
         }
      System.out.println("");
      }
   }  // end class SortedList
////////////////////////////////////////////////////////////////
class SortedListApp
   {
   public static void main(String[] args)
      {                            // create new list
      SortedList theSortedList = new SortedList();
      theSortedList.insert(20);    // insert 2 items
      theSortedList.insert(40);

      theSortedList.displayList(); // display list

      theSortedList.insert(10);    // insert 3 more items
      theSortedList.insert(30);
      theSortedList.insert(50);

      theSortedList.displayList(); // display list

      theSortedList.remove();      // remove an item

      theSortedList.displayList(); // display list
      }  // end main()
   }  // end class SortedListApp
////////////////////////////////////////////////////////////////

 
  
7.3 双向链表
 
  
// doublyLinked.java
// demonstrates doubly-linked list
// to run this program: C>java DoublyLinkedApp
////////////////////////////////////////////////////////////////
class Link
   {
   public long dData;                 // data item
   public Link next;                  // next link in list
   public Link previous;              // previous link in list
// -------------------------------------------------------------
   public Link(long d)                // constructor
      { dData = d; }
// -------------------------------------------------------------
   public void displayLink()          // display this link
      { System.out.print(dData + " "); }
// -------------------------------------------------------------
   }  // end class Link
////////////////////////////////////////////////////////////////
class DoublyLinkedList
   {
   private Link first;               // ref to first item
   private Link last;                // ref to last item
// -------------------------------------------------------------
   public DoublyLinkedList()         // constructor
      {
      first = null;                  // no items on list yet
      last = null;
      }
// -------------------------------------------------------------
   public boolean isEmpty()          // true if no links
      { return first==null; }
// -------------------------------------------------------------
   public void insertFirst(long dd)  // insert at front of list
      {
      Link newLink = new Link(dd);   // make new link

      if( isEmpty() )                // if empty list,
         last = newLink;             // newLink <-- last
      else
         first.previous = newLink;   // newLink <-- old first
      newLink.next = first;          // newLink --> old first
      first = newLink;               // first --> newLink
      }
// -------------------------------------------------------------
   public void insertLast(long dd)   // insert at end of list
      {
      Link newLink = new Link(dd);   // make new link
      if( isEmpty() )                // if empty list,
         first = newLink;            // first --> newLink
      else
         {
         last.next = newLink;        // old last --> newLink
         newLink.previous = last;    // old last <-- newLink
         }
      last = newLink;                // newLink <-- last
      }
// -------------------------------------------------------------
   public Link deleteFirst()         // delete first link
      {                              // (assumes non-empty list)
      Link temp = first;
      if(first.next == null)         // if only one item
         last = null;                // null <-- last
      else
         first.next.previous = null; // null <-- old next
      first = first.next;            // first --> old next
      return temp;
      }
// -------------------------------------------------------------
   public Link deleteLast()          // delete last link
      {                              // (assumes non-empty list)
      Link temp = last;
      if(first.next == null)         // if only one item
         first = null;               // first --> null
      else
         last.previous.next = null;  // old previous --> null
      last = last.previous;          // old previous <-- last
      return temp;
      }
// -------------------------------------------------------------
                                     // insert dd just after key
   public boolean insertAfter(long key, long dd)
      {                              // (assumes non-empty list)
      Link current = first;          // start at beginning
      while(current.dData != key)    // until match is found,
         {
         current = current.next;     // move to next link
         if(current == null)
            return false;            // didn't find it
         }
      Link newLink = new Link(dd);   // make new link

      if(current==last)              // if last link,
         {
         newLink.next = null;        // newLink --> null
         last = newLink;             // newLink <-- last
         }
      else                           // not last link,
         {
         newLink.next = current.next; // newLink --> old next
                                      // newLink <-- old next
         current.next.previous = newLink;
         }
      newLink.previous = current;    // old current <-- newLink
      current.next = newLink;        // old current --> newLink
      return true;                   // found it, did insertion
      }
// -------------------------------------------------------------
   public Link deleteKey(long key)   // delete item w/ given key
      {                              // (assumes non-empty list)
      Link current = first;          // start at beginning
      while(current.dData != key)    // until match is found,
         {
         current = current.next;     // move to next link
         if(current == null)
            return null;             // didn't find it
         }
      if(current==first)             // found it; first item?
         first = current.next;       // first --> old next
      else                           // not first
                                     // old previous --> old next
         current.previous.next = current.next;

      if(current==last)              // last item?
         last = current.previous;    // old previous <-- last
      else                           // not last
                                     // old previous <-- old next
         current.next.previous = current.previous;
      return current;                // return value
      }
// -------------------------------------------------------------
   public void displayForward()
      {
      System.out.print("List (first-->last): ");
      Link current = first;          // start at beginning
      while(current != null)         // until end of list,
         {
         current.displayLink();      // display data
         current = current.next;     // move to next link
         }
      System.out.println("");
      }
// -------------------------------------------------------------
   public void displayBackward()
      {
      System.out.print("List (last-->first): ");
      Link current = last;           // start at end
      while(current != null)         // until start of list,
         {
         current.displayLink();      // display data
         current = current.previous; // move to previous link
         }
      System.out.println("");
      }
// -------------------------------------------------------------
   }  // end class DoublyLinkedList
////////////////////////////////////////////////////////////////
class DoublyLinkedApp
   {
   public static void main(String[] args)
      {                             // make a new list
      DoublyLinkedList theList = new DoublyLinkedList();

      theList.insertFirst(22);      // insert at front
      theList.insertFirst(44);
      theList.insertFirst(66);

      theList.insertLast(11);       // insert at rear
      theList.insertLast(33);
      theList.insertLast(55);

      theList.displayForward();     // display list forward
      theList.displayBackward();    // display list backward

      theList.deleteFirst();        // delete first item
      theList.deleteLast();         // delete last item
      theList.deleteKey(11);        // delete item with key 11

      theList.displayForward();     // display list forward

      theList.insertAfter(22, 77);  // insert 77 after 22
      theList.insertAfter(33, 88);  // insert 88 after 33

      theList.displayForward();     // display list forward
      }  // end main()
   }  // end class DoublyLinkedApp
////////////////////////////////////////////////////////////////

 
  
数据结构与算法
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(数据结构与算法)

        

            

                
    
                    
  • Java-后端程序员个人知识总结
                        金肴羽
java开发语言
                        
    文章目录概要1.编程语言2.数据结构与算法3.数据库知识4.框架和库5.服务器管理6.网络知识7.版本控制8.测试9.安全知识10.系统设计11.编码规范与最佳实践12.持续学习和适应能力概要后端程序员，主要负责应用程序的逻辑、数据库交互、服务器配置以及应用的性能优化等。成为一名优秀的后台程序员，需要掌握以下技能：1.编程语言掌握至少一种后台编程语言JavaPythonHtmlJavaScript
    
                    
    • 
                    
  • 海量数据查找最大K个值：数据结构与算法的选择
                        星辰@Sea
数据结构Java数据结构
                        
    在处理大数据集时，经常需要找到数据集中最大的K个元素，这样的需求在很多领域都有广泛应用，例如推荐系统中寻找评分最高的K个商品、数据分析中找出最重要的K个特征、搜索引擎中找到排名前K的结果等等。面对海量数据，传统的排序方法可能不再适用，因为它们通常具有较高的时间复杂度。因此，选择合适的数据结构和算法对于提高效率至关重要。本文将详细介绍如何在海量数据集中查找最大的K个值，探讨不同的数据结构与算法选择，
    
                    
    • 
                    
  • 22级数据结构与算法实验2——链表
                        “世有神明”
链表算法数据结构
                        
    7-1两个有序链表序列的合并分数20全屏浏览题目切换布局作者DS课程组单位浙江大学已知两个非降序链表序列S1与S2，设计函数构造出S1与S2合并后的新的非降序链表S3。输入格式:输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。数字用空格间隔。输出格式:在一行中输出合并后新的非降序链表，数字间用空格分开，结尾不能有多余空格；若新链表为空，输出NU
    
                    
    • 
                    
  • 《数据结构与算法》知识点（四）
                        游戏原画设计

                        
    第七章查找顺序查找、折半查找、索引查找、分块查找是静态查找，动态查找有二叉排序树查找，最优二叉树查找，键树查找，哈希表查找静态查找表顺序表的顺序查找：应用范围：顺序表或线性链表表示的表，表内元素之间无序。查找过程：从表的一端开始逐个进行记录的关键字和给定值的比较。顺序有序表的二分查找。平均查找时间(n+1)/nlog2(n+1)分块查找：将表分成几块，块内无序，块间有序，即前一块中的最大值小于后一
    
                    
    • 
                    
  • 数据结构与算法——7-6 列出连通集 (25分)
                        吃完有点累
数据结构与算法队列算法数据结构DFSBFS
                        
    7-6列出连通集(25分)给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。输入格式:输入第1行给出2个整数N(0#includetypedefintVertexType;typedefintEdgeType;#defineMAXVEX100#defineINFINITY
    
                    
    • 
                    
  • 数据结构与算法 - 贪心算法
                        临界点oc
数据结构与算法贪心算法算法
                        
    一、贪心例子贪心算法或贪婪算法的核心思想是：1.将寻找最优解的问题分为若干个步骤2.每一步骤都采用贪心原则，选取当前最优解3.因为没有考虑所有可能，局部最优的堆叠不一定让最终解最优贪心算法是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望导致结果是最好或最优的算法。这种算法通常用于求解优化问题，如最小生成树、背包问题等。贪心算法的应用：1.背包问题：给定一组物品和一个背包
    
                    
    • 
                    
  • Java数据结构与算法：动态规划之斐波那契数列
                        省赚客APP开发者@聚娃科技
java动态规划代理模式
                        
    Java数据结构与算法：动态规划之斐波那契数列大家好，我是免费搭建查券返利机器人赚佣金就用微赚淘客系统3.0的小编。在这寒冷的季节里，让我们一同探讨Java中的动态规划，重点关注解决问题的经典代表之一——斐波那契数列。动态规划简介动态规划是一种解决问题的数学方法，通常用于优化递归算法。它通过将问题分解为子问题并保存它们的解，避免重复计算，从而提高算法效率。在动态规划的应用中，最常见的问题之一就是求
    
                    
    • 
                    
  • 【数据结构与算法 | 每日一题 | 力扣篇】
                        Vez'nan的幸福生活
leetcode算法数据结构
                        
    1.力扣977：有序数组的平方1.1题目：给你一个按非递减顺序排序的整数数组nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。示例1：输入：nums=[-4,-1,0,3,10]输出：[0,1,9,16,100]解释：平方后，数组变为[16,1,0,9,100]排序后，数组变为[0,1,9,16,100]示例2：输入：nums=[-7,-3,2,3,11]输出：[4,9,9,49,
    
                    
    • 
                    
  • 数据结构与算法 python实现单链表实现对列
                        我只要一发
python数据结构与算法Python实现单链表实现对列
                        
    对列：先来的先走，后来的后走FIFO实现FIFO的实现数据结构：arroylistlinkedlistdoubllinkedlist最基本的操作，push入列pop出列单链表实现appendpopleftclassFullError(Exception):passclassEmptyError(Exception):passclassQueue(object):def__init__(self,m
    
                    
    • 
                    
  • 周四 2020-01-09 08:00 - 24:30 多云 02h10m
                        么得感情的日更机器

                        
    南昌。二〇二〇年一月九日基本科研[1]:1.论文阅读论文--二小时十分2.论文实现实验--小时3.数学SINS推导回顾--O分4.科研参考书【】1)的《》看0/0页-5.科研文档1)组织工作[1]:例会--英语能力[2]:1.听力--十分2.单词--五分3.口语--五分4.英语文档1)编程能力[2]:1.编程语言C语言--O分2.数据结构与算法C语言数据结构--O分3.编程参考书1)陈正冲的《C语
    
                    
    • 
                    
  • github源码指引：共享内存、数据结构与算法：树形结构ListTree
                        初级代码游戏
github源码指引共享内存数据结构与算法github共享内存树链表
                        
    初级代码游戏的专栏介绍与文章目录-CSDN博客我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。专题：共享内存、数据结构与算法_初级代码游戏的博客-CSDN博客本文讲解带有子项的链表。一、介绍与上一篇介绍的单向链表相比，多了一个子项指针。可以理解为原来的链表是兄弟关系，
    
                    
    • 
                    
  • 代码随想录+力扣刷题记录+华为机考准备记录
                        梁慢慢慢慢
leetcode算法数据结构
                        
    为了准备华为机考的刷题记录，已压线过背景：数据结构与算法零基础，此前没有刷过题，会Python。学习路线按照代码随想录的顺序刷题，刷题平台：力扣以上大致过了一遍后开始刷华为机考真题（cdsn上购买的真题，刷题平台是购买的真题中的OJ平台，也是ACM模式）总共用时1个月。完成情况：力扣80个题+华为2024年机考真题。大部分题目都只做过1次，掌握得很不牢固，机考的时候也是压线过。时间比较紧急，做到后
    
                    
    • 
                    
  • “八股文”在程序员面试中的价值：助力还是阻力？
                        精神阿祝
尝鲜面试职场和发展
                        
    文章目录引言1.什么是“八股文”？2.“八股文”的支持者观点2.1理论基础的重要性2.2规范与标准化2.3应对突发问题3.“八股文”的反对者观点3.1实战经验的重视3.2忽视创新与灵活性3.3学习成本与心理压力4.八股文的具体内容分析4.1数据结构与算法4.1.1数据结构的重要性4.1.2算法的应用4.2系统设计4.2.1系统的架构设计4.2.2高并发处理4.3编程语言基础4.4框架与工具的使用5
    
                    
    • 
                    
  • 邓俊辉数据结构与算法学习笔记-第五章
                        xiaodidadada
数据结构与算法
                        
    文章目录树aa1树a2应用a3有根树a4有序树a5路径a6连通图无环图a7深度层次b在计算机中表示b1树的表示b2父节点b3孩子节点b4父亲孩子表示法b5长子兄弟表示法c二叉树c1二叉树概述c2真二叉树c3描述多叉树d二叉树d1BinNode类d2BinNode接口d3BinTree类d4高度更新d5节点插入e相关算法e1-1先序遍历转化策略e1-2遍历规则e1-3递归实现e1-4迭代实现e1-5
    
                    
    • 
                    
  • 【数据结构与算法 | 每日一题力扣篇】
                        Vez'nan的幸福生活
leetcode算法职场和发展
                        
    1.力扣3174：清楚数字1.1题目：给你一个字符串s。你的任务是重复以下操作删除所有数字字符：删除第一个数字字符以及它左边最近的非数字字符。请你返回删除所有数字字符以后剩下的字符串。示例1：输入：s="abc"输出："abc"解释：字符串中没有数字。示例2：输入：s="cb34"输出：""解释：一开始，我们对s[2]执行操作，s变为"c4"。然后对s[1]执行操作，s变为""。提示：1deque
    
                    
    • 
                    
  • 【数据结构与算法 | 基础篇】模拟LinkedList实现的链表(无哨兵)
                        Vez'nan的幸福生活
java数据结构算法
                        
    1.前言我们将LinkdList视作链表,底层设计了内部类Node类,我这里依然没有用到泛型,其实加上泛型依然很简单,即将Node节点的数据域的类型由Int转换为E(),我在此不做赘述.同时实现了增删查改,遍历等操作.2.链表(无哨兵)的代码实现publicclassLinkListTestimplementsIterable{//头指针staticNodehead;//内部类privatesta
    
                    
    • 
                    
  • 数据结构与算法Day25----字符串匹配（一）：借助哈希算法实现
                        墨殇染泪

                        
    一、主串和模式串：  假设在字符串A中查找字符串B，那字符串A就是主串，字符串B就是模式串。把主串的长度记作，模式串的长度记作。因为是在主串中查找模式串，所以。二、暴力匹配算法/朴素匹配算法/BF(BruteForce)算法：1、算法思想：  在主串中，检查起始位置分别是0、1、2···且长度为的个子串，看有没有跟模式串匹配的。2、图示：3、时间复杂度：  在极端情况下，每次都比对个字符，要比对次
    
                    
    • 
                    
  • Java学习 - 数据结构与算法 - 有序数组去重详解
                        泡芙萝莉酱
Javajava学习开发语言算法数据结构
                        
    问题给定一个有序数组，要删除数组重复出现的元素，使得每个元素只出现一次，然后返回移除重复数组后的新长度；示例：假设给定一个数组nums=[1,2,4,4]，删除重复出现的元素4后，原数组变成nums=[1,2,4]，此时新的数组长度为3；解决思路数组原地操作数组原地操作，此时无需创建新的数组，只需要在原来的数组上操作即可。相当于首先要找到数组中重复的元素，然后将重复的元素移除，此时就涉及到数组中的
    
                    
    • 
                    
  • 4. 数据结构与算法：双端队列-
                        sszhang

                        
    双端队列（deque，全名double-endedqueue）是一种具有队列和栈性质的线性数据结构。双端队列也拥有两端：队首（front）、队尾（rear），但与队列不同的是，插入操作在两端（队首和队尾）都可以进行，删除操作也一样。deque()创建双端队列addFront(item)向队首插入项addRear(item)向队尾插入项removeFront()返回队首的项，并从双端队列中删除该项r
    
                    
    • 
                    
  • github源码指引：共享内存、数据结构与算法：字符串池StringPool
                        初级代码游戏
github源码指引共享内存数据结构与算法github共享内存字符串池
                        
    初级代码游戏的专栏介绍与文章目录-CSDN博客我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。专题：共享内存、数据结构与算法_初级代码游戏的博客-CSDN博客本文讲解字符串池的示例代码。字符串池是一个特殊的结构，用来减少重复的字符串存储（现实系统中会存在大量重复的字符
    
                    
    • 
                    
  • 数据结构与算法之哈希表（C语言版）
                        jiangzhangha
算法与数据结构学习笔记算法哈希表
                        
    title:数据结构与算法之哈希表（C语言版）date:2020-07-1921:05:15categories:数据结构与算法tags:-数据结构-算法-哈希表-c数据结构与算法之哈希表（C语言版）哈希表支持一种最有效的检索方法：散列。由于计算哈希值和在数组中进行索引都只消耗固定的时间，因此哈希表最大的亮点在于其是一种运行时间在常量级别的检索方法。绝大多数的哈希函数会将一些不同的键映射到表中相同
    
                    
    • 
                    
  • 数据结构与算法关系(中)：如何评判一个算法的好坏
                        MobotStone

                        
    大家好，我是MicroStone，一个曾在三家世界500强企业担任要职的一线互联网工程师。上一节，我们了解到算法的一些特征，想必大家都掌握了算法设计要求，在学习或工作中根据业务需求设计要设计一个算法，我们要如何评估一个算法的好坏呐？下面我们来看看算法的度量方式。1、算法的效率度量方法我们知道一个算法的效率，抛开性能这些，其实值得注意的就是算法的执行时间，同一台机器上，我们使用相同数据集，利用计算机
    
                    
    • 
                    
  • 聊聊自学数据结构与算法
                        莫天幽
数据结构算法
                        
    聊聊自学数据结构与算法大家好，我是莫幽天很高兴你能够阅读到我的文章。说道自学算法，不知道你是带着一个什么样的心情来学习，我呢是觉得基础太重要了。所以又来尝试深入的学习数据结构与算法。为什么这么说呢，我是一名Java开发的程序猿，现在jdk已经出到18了（时间北京时间：2021-07-28），但是呢开发一般还在用jdk8。一般的Java程序猿也就了解个jdk8的特性。上层变化的太快，想记忆需要长期持
    
                    
    • 
                    
  • github源码指引：共享内存、数据结构与算法：平衡二叉树set带有互斥接口的
                        初级代码游戏
github源码指引共享内存数据结构与算法github哈希算法算法共享内存
                        
    初级代码游戏的专栏介绍与文章目录-CSDN博客我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。目录一、演示代码二、互斥层的实现2.1简单的互斥层实现2.2完整互斥接口的实现2.2.1互斥对象放在哪里2.2.2迭代器的互斥2.2.3方法的互斥三、互斥层的设计思想一、演示
    
                    
    • 
                    
  • github源码指引：共享内存、数据结构与算法：平衡二叉树set的lower_bound
                        初级代码游戏
github源码指引共享内存数据结构与算法github哈希算法算法
                        
    初级代码游戏的专栏介绍与文章目录-CSDN博客我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。本篇专门讲解lower_bound的实现。目录一、STL的lower_bound和upper_bound是什么二、二叉树有没有lower_bound三、演示代码3.1定义数据
    
                    
    • 
                    
  • 编程练习题目集【目录】
                        绯樱殇雪
目录PTAc++javapat考试
                        
    所有负面情绪都源于你的弱小，唯有强大自己才能够百毒不侵。文章目录一、PTA1.练习（1）中国大学MOOC-陈越、何钦铭-数据结构-起步能力自测题（2）DataStructuresandAlgorithms(English)（3）数据结构与算法题目集（中文）（4）团体程序设计天梯赛-练习集（5）基础编程题目集①函数题②编程题2.考试（1）PAT(BasicLevel)Practice（中文）（2）P
    
                    
    • 
                    
  • github源码指引：共享内存、数据结构与算法：作为基础的数组
                        初级代码游戏
github源码指引共享内存数据结构与算法github共享内存数据结构算法可扩展数组
                        
    初级代码游戏的专栏介绍与文章目录-CSDN博客我的github：codetoys，所有代码都将会位于ctfc库中。已经放入库中我会指出在库中的位置。这些代码大部分以Linux为目标但部分代码是纯C++的，可以在任何平台上使用。相关专题：共享内存、数据结构与算法_初级代码游戏的博客-CSDN博客源码位置：shmfc基础：github源码指引：源码结构、编译、运行_github编译-CSDN博客目录一
    
                    
    • 
                    
  • 驾驭高效编程:一探C++ STL的奥秘
                        一叶之秋1412
c++开发语言
                        
    1.什么是STL2.:STL的版本2.1:原始版本2.2:P.J版本2.3:RW版本2.4:SGI版本3:STL的六大组件4:如何学习STL5:STL的缺陷1.什么是STLSTL(standdardtemplatelibrary-标准模板库):是C++标准库的重要组成部分,不仅是一个可复用的组件库,而且是一个包含数据结构与算法软件框架.2.:STL的版本2.1:原始版本AlexanderStepa
    
                    
    • 
                    
  • 【数据结构与算法】从左到右快速幂和从右到左快速幂
                        星眺北海
数据结构与算法算法快速幂
                        
    引出问题在计算机科学中，幂运算是一种非常常见且基础的操作，尤其是在涉及到大数运算时，幂运算的效率对整个计算过程至关重要。设想以下场景：在加密算法中，如RSA算法，常常需要计算大数的幂，且这种计算必须在一定时间内完成，以确保安全性。在数值计算中，我们可能需要反复进行大规模的幂运算，如果采用最直接的计算方法，其计算量和时间将非常庞大。如果我们采用朴素的计算方法，例如计算aba^bab时，通过不断相乘a
    
                    
    • 
                    
  • 我的程序员读书路
                        weixin_30416497
c#javascript大数据ViewUI
                        
    CLRviaC#(第三版)你必须知道的.NET(第二版)编码:隐匿在计算机软硬件背后的语言代码整洁之道重构:改善既有代码的设计数据结构与算法：C#语言描述程序员修炼之道:从小工到专家编程珠玑(第2版)深入理解计算机系统(第2版)数据挖掘概念与技术(第2版)高效程序员的45个习惯:敏捷开发修炼之道面向对象分析与设计(第三版)深入浅出设计模式(c#/java版)代码大全第二版设计模式:可复用面向对象软
    
                    
    • 
                                
  • log4j对象改变日志级别
                                    3213213333332132
javalog4jlevellog4j对象名称日志级别
                                    
    log4j对象改变日志级别可批量的改变所有级别，或是根据条件改变日志级别。 
 
log4j配置文件： 
 
 

log4j.rootLogger=ERROR,FILE,CONSOLE,EXECPTION
 
#log4j.appender.FILE=org.apache.log4j.RollingFileAppender
log4j.appender.FILE=org.apache.l
    
                                
    • 
                                
  • elk+redis 搭建nginx日志分析平台
                                    ronin47
elasticsearchkibanalogstash
                                    
                  elk+redis 搭建nginx日志分析平台 
logstash,elasticsearch,kibana 怎么进行nginx的日志分析呢？首先，架构方面，nginx是有日志文件的，它的每个请求的状态等都有日志文件进行记录。其次，需要有个队 列，redis的l
    
                                
    • 
                                
  • Yii2设置时区
                                    dcj3sjt126com
PHPtimezoneyii2
                                    
    时区这东西，在开发的时候，你说重要吧，也还好，毕竟没它也能正常运行，你说不重要吧，那就纠结了。特别是linux系统，都TMD差上几小时，你能不痛苦吗？win还好一点。有一些常规方法，是大家目前都在采用的1、php.ini中的设置，这个就不谈了，2、程序中公用文件里设置，date_default_timezone_set一下时区3、或者。。。自己写时间处理函数，在遇到时间的时候，用这个函数处理（比较
    
                                
    • 
                                
  • js实现前台动态添加文本框，后台获取文本框内容
                                    171815164
文本框
                                    
    

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://w
    
                                
    • 
                                
  • 持续集成工具
                                    g21121
持续集成
                                    
            持续集成是什么？我们为什么需要持续集成？持续集成带来的好处是什么？什么样的项目需要持续集成？...        持续集成(Continuous integration ,简称CI)，所谓集成可以理解为将互相依赖的工程或模块合并成一个能单独运行
    
                                
    • 
                                
  • 数据结构哈希表(hash)总结
                                    永夜-极光
数据结构
                                    
    1.什么是hash 
来源于百度百科: 
Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入，通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。 
  

    
                                
    • 
                                
  • 乱七八糟
                                    程序员是怎么炼成的

                                    
    eclipse中的jvm字节码查看插件地址： 
http://andrei.gmxhome.de/eclipse/ 
安装该地址的outline 插件  后重启，打开window下的view下的bytecode视图 
http://andrei.gmxhome.de/eclipse/ 
  
jvm博客： 
http://yunshen0909.iteye.com/blog/2
    
                                
    • 
                                
  • 职场人伤害了“上司” 怎样弥补
                                    aijuans
职场
                                    
     由于工作中的失误，或者平时不注意自己的言行“伤害”、“得罪”了自己的上司，怎么办呢？ 
　　在职业生涯中这种问题尽量不要发生。下面提供了一些解决问题的建议： 
　　一、利用一些轻松的场合表示对他的尊重 
　　即使是开明的上司也很注重自己的权威，都希望得到下属的尊重，所以当你与上司冲突后，最好让不愉快成为过去，你不妨在一些轻松的场合，比如会餐、联谊活动等，向上司问个好，敬下酒，表示你对对方的尊重，
    
                                
    • 
                                
  • 深入浅出url编码
                                    antonyup_2006
应用服务器浏览器servletweblogicIE
                                    
    出处：http://blog.csdn.net/yzhz  杨争   
http://blog.csdn.net/yzhz/archive/2007/07/03/1676796.aspx 
 
一、问题： 
        编码问题是JAVA初学者在web开发过程中经常会遇到问题，网上也有大量相关的
    
                                
    • 
                                
  • 建表后创建表的约束关系和增加表的字段
                                    百合不是茶
标的约束关系增加表的字段
                                    
      
下面所有的操作都是在表建立后操作的,主要目的就是熟悉sql的约束,约束语句的万能公式 
  
1,增加字段(student表中增加 姓名字段) 
  
alter table 增加字段的表名 add  增加的字段名   增加字段的数据类型

  alter table student add name varchar2(10);
 
  
&nb
    
                                
    • 
                                
  • Uploadify 3.2 参数属性、事件、方法函数详解
                                    bijian1013
JavaScriptuploadify
                                    
    一.属性     
属性名称   
默认值   
说明     
auto   
true   
设置为true当选择文件后就直接上传了，为false需要点击上传按钮才上传。     
buttonClass   
”   
按钮样式     
buttonCursor   
‘hand’   
鼠标指针悬停在按钮上的样子     
buttonImage   
null   
浏览按钮的图片的路
    
                                
    • 
                                
  • 精通Oracle10编程SQL(16)使用LOB对象
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *使用LOB对象
 */
--LOB(Large Object)是专门用于处理大对象的一种数据类型，其所存放的数据长度可以达到4G字节
--CLOB/NCLOB用于存储大批量字符数据，BLOB用于存储大批量二进制数据，而BFILE则存储着指向OS文件的指针

/*
 *综合实例
 */
--建立表空间 
--#指定区尺寸为128k,如不指定，区尺寸默认为64k 
CR
    
                                
    • 
                                
  • 【Resin一】Resin服务器部署web应用
                                    bit1129
resin
                                    
    工作中，在Resin服务器上部署web应用，通常有如下三种方式： 
  
 
 配置多个web-app 
 配置多个http id 
 为每个应用配置一个propeties、xml以及sh脚本文件 
 配置多个web-app 
  
 
 在resin.xml中,可以为一个host配置多个web-app 
 
  
<cluster id="app&q
    
                                
    • 
                                
  • red5简介及基础知识
                                    白糖_
基础
                                    
      
 
 简介 
 
  
Red5的主要功能和Macromedia公司的FMS类似，提供基于Flash的流媒体服务的一款基于Java的开源流媒体服务器。它由Java语言编写，使用RTMP作为流媒体传输协议，这与FMS完全兼容。它具有流化FLV、MP3文件，实时录制客户端流为FLV文件，共享对象，实时视频播放、Remoting等功能。用Red5替换FMS后,客户端不用更改可正
    
                                
    • 
                                
  • angular.fromJson
                                    boyitech
AngularJSAngularJS 官方APIAngularJS API
                                    
    angular.fromJson   描述:   把Json字符串转为对象    使用方法:   angular.fromJson(json);   参数详解:      Param Type Details   json 
string  
JSON 字符串      返回值:   对象, 数组, 字符串 或者是一个数字   示例:   
<!DOCTYPE HTML>
<h
    
                                
    • 
                                
  • java-颠倒一个句子中的词的顺序。比如： I am a student颠倒后变成：student a am I
                                    bylijinnan
java
                                    
    

public class ReverseWords {

	/**
	 * 题目：颠倒一个句子中的词的顺序。比如： I am a student颠倒后变成：student a am I.词以空格分隔。
	 * 要求：
	 * 1.实现速度最快,移动最少
	 * 2.不能使用String的方法如split,indexOf等等。
	 * 解答：两次翻转。
	 */
	publ
    
                                
    • 
                                
  • web实时通讯
                                    Chen.H
Web浏览器socket脚本
                                    
    关于web实时通讯，做一些监控软件。 
由web服务器组件从消息服务器订阅实时数据，并建立消息服务器到所述web服务器之间的连接，web浏览器利用从所述web服务器下载到web页面的客户端代理与web服务器组件之间的socket连接，建立web浏览器与web服务器之间的持久连接；利用所述客户端代理与web浏览器页面之间的信息交互实现页面本地更新，建立一条从消息服务器到web浏览器页面之间的消息通路
    
                                
    • 
                                
  • [基因与生物]远古生物的基因可以嫁接到现代生物基因组中吗?
                                    comsci
生物
                                    
     
 
      大家仅仅把我说的事情当作一个IT行业的笑话来听吧..没有其它更多的意思 
 
 
    如果我们把大自然看成是一位伟大的程序员,专门为地球上的生态系统编制基因代码,并创造出各种不同的生物来,那么6500万年前的程序员开发的代码,是否兼容现代派的程序员的代码和架构呢? 
 
  
    
                                
    • 
                                
  • oracle 外部表
                                    daizj
oracle外部表external tables
                                    
        oracle外部表是只允许只读访问，不能进行DML操作，不能创建索引，可以对外部表进行的查询，连接，排序，创建视图和创建同义词操作。 
you can select, join, or sort external table data. You can also create views and synonyms for external tables. Ho
    
                                
    • 
                                
  • aop相关的概念及配置
                                    daysinsun
AOP
                                    
    切面(Aspect): 
通常在目标方法执行前后需要执行的方法（如事务、日志、权限），这些方法我们封装到一个类里面，这个类就叫切面。 
 
 
连接点（joinpoint） 
spring里面的连接点指需要切入的方法，通常这个joinpoint可以作为一个参数传入到切面的方法里面（非常有用的一个东西）。 
 
 
通知（Advice） 
通知就是切面里面方法的具体实现，分为前置、后置、最终、异常环
    
                                
    • 
                                
  • 初一上学期难记忆单词背诵第二课
                                    dcj3sjt126com
englishword
                                    
    middle 中间的，中级的 
well 喔，那么；好吧 
phone 电话，电话机 
policeman 警察 
ask 问 
take 拿到；带到 
address 地址 
glad 高兴的，乐意的 
why 为什么  
China 中国 
family 家庭 
grandmother (外)祖母 
grandfather (外)祖父 
wife 妻子 
husband 丈夫 
da
    
                                
    • 
                                
  • Linux日志分析常用命令
                                    dcj3sjt126com
linuxlog
                                    
    1.查看文件内容 
cat 
-n 显示行号 2.分页显示 
more 
Enter 显示下一行 
空格 显示下一页 
F 显示下一屏 
B 显示上一屏 
less 
/get 查询"get"字符串并高亮显示 3.显示文件尾 
tail 
-f 不退出持续显示 
-n 显示文件最后n行 4.显示头文件 
head 
-n 显示文件开始n行 5.内容排序 
sort 
-n 按照
    
                                
    • 
                                
  • JSONP 原理分析
                                    fantasy2005
JavaScriptjsonpjsonp 跨域
                                    
    转自 http://www.nowamagic.net/librarys/veda/detail/224 
JavaScript是一种在Web开发中经常使用的前端动态脚本技术。在JavaScript中，有一个很重要的安全性限制，被称为“Same-Origin Policy”（同源策略）。这一策略对于JavaScript代码能够访问的页面内容做了很重要的限制，即JavaScript只能访问与包含它的
    
                                
    • 
                                
  • 使用connect by进行级联查询
                                    234390216
oracle查询父子Connect by级联
                                    
    使用connect by进行级联查询 
  
       connect by可以用于级联查询，常用于对具有树状结构的记录查询某一节点的所有子孙节点或所有祖辈节点。 
  
       来看一个示例，现假设我们拥有一个菜单表t_menu，其中只有三个字段：
    
                                
    • 
                                
  • 一个不错的能将HTML表格导出为excel,pdf等的jquery插件
                                    jackyrong
jquery插件
                                    
    发现一个老外写的不错的jquery插件，可以实现将HTML 
表格导出为excel,pdf等格式， 
地址在： 
https://github.com/kayalshri/ 
 
下面看个例子，实现导出表格到excel,pdf 
 
 


<html>
			<head>
				<title>Export html table to excel an
    
                                
    • 
                                
  • UI设计中我们为什么需要设计动效
                                    lampcy
UIUI设计
                                    
    关于Unity3D中的Shader的知识 
首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，
    
                                
    • 
                                
  • 如何禁止页面缓存
                                    nannan408
htmljspcache
                                    
    禁止页面使用缓存~ 
------------------------------------------------ 
jsp:页面no cache： 
 
response.setHeader("Pragma","No-cache"); 
response.setHeader("Cache-Control","no-cach
    
                                
    • 
                                
  • 以代码的方式管理quartz定时任务的暂停、重启、删除、添加等
                                    Everyday都不同
定时任务管理spring-quartz
                                    
          【前言】在项目的管理功能中，对定时任务的管理有时会很常见。因为我们不能指望只在配置文件中配置好定时任务就行了，因为如果要控制定时任务的 “暂停” 呢？暂停之后又要在某个时间点 “重启” 该定时任务呢？或者说直接 “删除” 该定时任务呢？要改变某定时任务的触发时间呢？ “添加” 一个定时任务对于系统的使用者而言，是不太现实的，因为一个定时任务的处理逻辑他是不
    
                                
    • 
                                
  • EXT实例
                                    tntxia
ext
                                    
      
（1） 增加一个按钮 
  
JSP: 
  
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
Stri
    
                                
    • 
                                
  • 数学学习在计算机研究领域的作用和重要性
                                    xjnine
Math
                                    
    最近一直有师弟师妹和朋友问我数学和研究的关系，研一要去学什么数学课。毕竟在清华，衡量一个研究生最重要的指标之一就是paper,而没有数学，是肯定上不了世界顶级的期刊和会议的，这在计算机学界尤其重要！你会发现，不论哪个领域有价值的东西，都一定离不开数学！在这样一个信息时代，当google已经让世界没有秘密的时候，一种卓越的数学思维，绝对可以成为你的核心竞争力.  无奈本人实在见地
    
                                
    •