数据结构之线性表

以前没有学过数据结构，直接学习的java，感觉编程总是基础不牢靠，所以准备重新自学数据结构，坚持！

线性表分为顺序存储结构和链式存储结构，链式存储结构又分为单向链表和双向链表。

关于线性表存储结构的不同网上有大把的资料，只是在这里贴出自己写的代码，不记得时候常常复习。

定义一个线性表的结构：

package org.list.cn;

/***
 * 线性表的顺序存储结构 
 * @author zzg
 *
 */
public interface ListADT {

	/***
	 * 得到线性表中 的第pos个位置的元素
	 * @param pos
	 * @return
	 */
	Object  value(int pos);
	/***
	 * 在第pos个位置插入元素
	 * @param obj
	 * @param pos
	 * @return
	 */
	boolean add(Object obj,int pos);
	/**
	 * 删除第pos个位置的元素
	 * @param pos
	 * @return
	 */
	Object remove(int pos);
	/**
	 * 从第pos个位置起查找元素
	 * @param obj
	 * @param pos
	 * @return
	 */
	int find(Object obj,int pos);
	/***
	 * 修改线性表中的给定序号的元素
	 * @param obj
	 * @param pos
	 * @return
	 */
	boolean modify(Object obj,int pos);
	/**
	 * 是否为空
	 * @return
	 */
	boolean isEmpty();
	/**
	 * 链表长度
	 * @return
	 */
	int size();
	/***
	 * 正序遍历所元素
	 */
	void nextOrder();
	/**
	 * 反序遍历所有元素
	 */
	void preOrder();
	/**
	 * 清空
	 */
	void clear();
	/**
	 * 排序生成新的链表返回(插入排序)
	 * @return
	 */
	ListADT sort();
}

线性表的顺序存储结构

package org.list.cn;
/**
 * 线性表的顺序存储及其操作
 * @author zzg
 *
 */
public class SequenceList implements ListADT {

	final int maxSize=10;//假定存储线性表的一维数组的初始长度为10
	private Object[] listArray;//存储线性表的一维数组
	private int length;//线性表的当前长度
	public SequenceList() {
		// TODO Auto-generated constructor stub
		length=0;
		listArray=new Object[maxSize];
	}
	public SequenceList(int n){
		if(n<0){
			System.out.println("数组长度大于0");
		}
		length=0;
		listArray=new Object[n];
		
	}
	@Override
	public Object value(int pos) {
		// TODO Auto-generated method stub
		if(pos<1||pos>length){
			System.out.println("pos不合法");
		}
		return listArray[pos-1];
	}

	@Override
	public boolean add(Object obj, int pos) {
		// TODO Auto-generated method stub
		if(pos<1||pos>length+1){
			System.out.println("add-pos不合法");
			return false;
		}
		if(length==listArray.length){
			//对数组用完的情况进行重新分配
			Object[] p=new Object[length*2];
			for(int i=0;i<length;i++){
				p[i]=listArray[i];
			}
			listArray=p;
		}
		for(int i=length;i>=pos;i++){
			listArray[i]=listArray[i-1];//所有元素依次向后移动
		}
		listArray[pos-1]=obj;
		length++;
		return true;
	}

	@Override
	public Object remove(int pos) {
		// TODO Auto-generated method stub
		if(pos<1||pos>length+1){
			System.out.println("remove-pos不合法");
			return null;
		}
		Object x=listArray[pos-1];
		for(int i=pos;i<listArray.length;i++){
			listArray[i-1]=listArray[i];//pos位置之后的元素依次向前移动
		}
		length--;
		return x;
	}

	@Override
	public int find(Object obj, int pos) {
		// TODO Auto-generated method stub
		if(pos<1||pos>length+1){
			System.out.println("find-pos不合法");
		}
		for(int i=pos-1;i<listArray.length;i++){
			if(listArray[i].equals(obj)){
				return i+1;
			}else{
				return 0;
			}
		}
		return -1;//查找失败
	}

	@Override
	public boolean modify(Object obj, int pos) {
		// TODO Auto-generated method stub
		if(pos<1||pos>length+1){
			System.out.println("find-pos不合法");
			return false;
		}
		listArray[pos-1]=obj;
		return true;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return length==0;
	}

	@Override
	public int size() {
		// TODO Auto-generated method stub
		return length;
	}

	@Override
	public void nextOrder() {
		// TODO Auto-generated method stub
		for(int i=0;i<length;i++){
			System.out.println(listArray[i].toString());
		}
	}

	@Override
	public void preOrder() {
		// TODO Auto-generated method stub
		for(int i=length-1;i>=0;i++){
			System.out.println(listArray[i].toString());
		}
	}

	@Override
	public void clear() {
		// TODO Auto-generated method stub
		length=0;
	}
	
	@Override
	public ListADT sort() {
		// TODO Auto-generated method stub
		SequenceList newList=new SequenceList(length);  //定义一个新表
		newList.length=length;
		for(int i=0;i<length;i++){
			newList.listArray[i]=listArray[i];
		}
		int i,j;
		/***
		 * ComParable  int compareTo(T t)  
		 * 此对象与指定对象进行比较
		 * <返回负数
		 * =返回0
		 * >返回正数
		 */
		Comparable x,y;
		for(i=1;i<newList.length;i++){
			x=(Comparable) newList.listArray[i];
			for(j=i-1;j>=0;j--){
				y=(Comparable) newList.listArray[j];
				if(x.compareTo(y)<0){
					newList.listArray[j+1]=newList.listArray[j];
				}else{
					break;
				}
			}
			newList.listArray[j+1]=x;
		}
		return newList;
	}

}

package org.linkedlist.cn;

import org.list.cn.ListADT;

/**
 * 线性表的链式存储结构
 * @author Administrator
 *
 */
public class LinkList implements ListADT {

	private Node head; //表头指针
	private int length;  //线性表的（单链表）的当前长度
	public class Node{
		private Object data;//数据域
		private Node next;  //指针域  存储下一个节点的引用
		public Node(Node next){
			this.next=next;
		}
		public Node(Object obj,Node next){
			this.data=obj;
			this.next=next;
		}
	}
	public LinkList() {
		// TODO Auto-generated constructor stub
		length=0;
		head=new Node(null);//初始建立的由Head指向的头节点
		head.next=head;   //构成单链表的循环空表
	}
	@Override
	public Object value(int pos) {
		// TODO Auto-generated method stub
		if(pos<1||pos>length){
			System.out.println("value--pos不合法");
			return null;
		}
		int num=1;
		Node p=head.next;
		while(num<pos){
			num++;
			p=p.next;
		}
		return p.data;
	}

	@Override
	public boolean add(Object obj, int pos) {
		// TODO Auto-generated method stub
		if(pos<1||pos>length+1){
			System.out.println("add--pos不合法");
			return false;
		}
		int num=1;
		Node p=head;    //p指向前驱节点
		Node q=head.next;  //q指向第一个元素节点
		while(num<pos){
			p=q;
			q=q.next;
			num++;
		}
		p.next=new Node(obj,q);
		length++;
		return true;
	}

	@Override
	public Object remove(int pos) {
		// TODO Auto-generated method stub
		if(pos<1||pos>length+1){
			System.out.println("add--pos不合法");
			return false;
		}
		int num=1;
		Node p=head;
		Node q=head.next;
		while(num<pos){
			num++;
			p=q;
			q=q.next;
		}
		p.next=q.next;
		length--;
		return q.data;
	}

	@Override
	public int find(Object obj, int pos) {
		// TODO Auto-generated method stub
		if(pos<1||pos>length+1){
			System.out.println("add--pos不合法");
			return 0;
		}
		int num=1;
		Node p=head.next;
		while(num<pos){
			num++;
			p=p.next;
		}
		while(p!=head&&!p.data.equals(obj)){
			num++;
			p=p.next;
		}
		if(p==head){
			return -1;
		}else{
			return num;  //查找成功返回节点序号（从0开始）
		}
	}

	@Override
	public boolean modify(Object obj, int pos) {
		// TODO Auto-generated method stub
		if(pos<1||pos>length+1){
			System.out.println("add--pos不合法");
			return false;
		}
		 int num=1;
		 Node p=head.next;
		 while(num<pos){
			 num++;
			 p=p.next;
		 }
		 p.data=obj;
		return true;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		
		return length==0;
	}

	@Override
	public int size() {
		// TODO Auto-generated method stub
		return length;
	}

	@Override
	public void nextOrder() {
		// TODO Auto-generated method stub
		Node p=head.next;
		while(p!=head){
			System.out.println(p.data.toString());
			p=p.next;
		}
	}

	@Override
	public void preOrder() {
		// TODO Auto-generated method stub
		Object[] object=new Object[length];
		int i=0;
		Node p=head.next;
		while(p!=head){
			object[i++]=p.data;
			p=p.next;
		}
		for(i=0;i<length;i++){
			System.out.println(object[i].toString());
		}
		/**
		 * 可以使用递归
		 */
//		preOrder(head.next);
	}
	private void preOrder(Node p){
		if(p==head){
			return;
		}else{
			preOrder(p.next);
			System.out.println(p.data);
		}
		
	}

	@Override
	public void clear() {
		// TODO Auto-generated method stub
		length=0;
		head.next=head;
	}
	@Override
	public ListADT sort() {
		// TODO Auto-generated method stub
		LinkList list=new LinkList();
		Node v=head.next;  //定义v使其指向表头节点
		Comparable x,y;
		while(v!=head){
			x=(Comparable) v.data;
			Node p=list.head;
			Node q=p.next;
			while(q!=list.head){
				y=(Comparable) q.data;
				if(x.compareTo(y)<0){
					break;
				}
				p=q;
				q=q.next;
			}
			p.next=new Node(v.data,q);
			list.length++;
			v=v.next;
		}
		return list;
	}

}