数据结构-第一篇：线性表的应用

/**

• 链式线性表的应用1：两个链式有序表的合并
• 算法步骤：
• 1.初始化指针pa,pb,分别指向链表La,Lb的第一个节点
• 2.初始化链表Lc
• 3.初始化指针pc指向Lc的头节点
• 4.当指针pa,pb都没达到末尾时，比较两者的数据域，值小/值大插入链表Lc（看链表的递增/递减）
• 5.某一个达到末尾，另一个直接插在链表Lc的后面
• 6.释放链表La,Lb
• 小技巧：
• 由于链表节点之间的关系是通过指针指向建立的，所以无需开辟新的空间建立新的链表
• 只需利用原有链表的空间，把原有链表的节点通过指针链接起来即可
• @author hopefully

*/

public class _04linearListOfApplication01 {

	public static void main(String[] args) {
		System.out.println("初始化链表a");
		_04linearList02<Integer> a=new _04linearList02<Integer>();
		for(int i=1;i<=10;i=i+2) {
			a.add(i, 1);
		}
		a.iterator();
		System.out.println(a.size());
		System.out.println("初始化链表b");
		_04linearList02<Integer> b=new _04linearList02<Integer>();
		for(int i=2;i<=10;i=i+2) {
			b.add(i, 1);
		}
		b.iterator();
		System.out.println(b.size());
		_04linearListOfApplication01 app=new _04linearListOfApplication01();
		System.out.println("合并后的链表c");
		_04linearList02<Integer> c = app.merge(a, b);
		c.iterator();
	}
	
	//返回合并后的新链表
	public <T extends Comparable<T>> _04linearList02<T> merge(_04linearList02<T> a,_04linearList02<T> b){
		Node<T> pa=a.getHead().next;
		Node<T> pb=b.getHead().next;
		_04linearList02<T> c=new _04linearList02<T>();
		Node<T> pc=c.getHead();//!null
		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&&pb==null) {
			pc.next=pa;
			pc=pa;
			pa=pa.next;
		}
		while(pb!=null&&pa==null) {
			pc.next=pb;
			pc=pb;
			pb=pb.next;
		}
		a.clear();
		b.clear();
		return c;
	}
}

/**

• 链式线性表的应用2：稀疏多项式的加法
• 多项式项的数据模型：
• 系数、指数-Item
• 构建多项式项-Item
• 链式有序表中的数据元素
• data->Item,next->Node
• 构建多项式->_04linearList02
• 算法步骤：
• 1.获取多项式1、2的项的个数，初始化变量len1、len2
• 两个多项式没遍历完情况有两种：
• 1.指数相等-系数相加
• 2.指数不相等，指数小的放入新的链表中
• 2.一个遍历玩，另一个没遍历玩：
• 直接放到新的链表末
• 灵活运用已定义的链表
• @author hopefully

*/

public class _04linearListOfApplication02 {

	public static void main(String[] args) {
		_04linearList02<Item> b1=new _04linearList02<Item>();
		b1.add(new Item(2, 1), 1);
		b1.add(new Item(5, 3), 2);
		b1.add(new Item(100, 4), 3);
		_04linearList02<Item> b2=new _04linearList02<Item>();
		b2.add(new Item(50, 1), 1);
		b2.add(new Item(50, 5), 2);
		b2.add(new Item(10, 6), 3);
		_04linearListOfApplication02 add=new _04linearListOfApplication02();
		_04linearList02<Item> polyAdd = add.polyAdd(b1, b2);
		polyAdd.iterator();
	}
	//T->Node<T>中的data，这里代表Item
	public <T extends Item> _04linearList02<T> polyAdd(_04linearList02<T> b1,_04linearList02<T> b2){
		_04linearList02<T> b3=new _04linearList02<T>();
		int len1=1;
		int len2=1;
		while(len1<=b1.size()&&len2<=b2.size()) {
			T x1=b1.value(len1);
			T x2=b2.value(len2);
			if(x1.compareTo(x2)<0) {
				b3.add(x1, b3.size()+1);
				len1++;
			}else if(x1.compareTo(x2)>0) {
				b3.add(x2, b3.size()+1);
				len2++;
			}else {
				x1.add(x2);
				b3.add(x1, b3.size()+1);
				len1++;
				len2++;
			}
		}
		while(len1<=b1.size()) {
			b3.add(b1.value(len1), b3.size()+1);
			len1++;
		}
		while(len2<=b2.size()) {
			b3.add(b2.value(len2), b3.size()+1);
			len2++;
		}
	return b3;	
	}
}
class Item implements Comparable<Item>{

	private double ceof;
	private double exp;
	
	public Item(double ceof, double exp) {
		this.ceof=ceof;
		this.exp=exp;
	}
	
	public double getCeof() {
		return ceof;
	}

	public double getExp() {
		return exp;
	}

	@Override
	public int compareTo(Item o) {
		// TODO Auto-generated method stub
		if(exp>o.exp) {
			return 1;
		}else if(exp<o.exp){
			return -1;
		}else {
			return 0;
		}
	}
	
	@Override
	public String toString() {
		return "Item["+ceof+","+exp+"]";
	}
	
	public void add(Item x) {
		if(exp==x.exp) {
			ceof+=x.ceof;
		}
	}
	
	
}

转载请注明出处