大话数据结构学习-------第2-3章

大话数据结构学习-------第2-3章

第二章

函数的渐进增长性

          例：
          		算法A：2n+3
          		算法B：3n+1
          		当n=1时A不如B，n=2时两者效率相同，n>2时A就优于B了。
                给定两个函数f(n)和g(n)，如果存在一个整数N。对于所有n>N时f(n)总>g(n)，那么f(n)渐进增长性快于g(n)。

算法的时间复杂度

		1.时间复杂度为n：
			for(i=0;i<n;i++)
			{
				printf("%d",i);
			}
		2.时间复杂度为1：
			printf("HELLO WORD");
		3.时间复杂度为n^2:
			int i，j；
			for(i=0;i<n;i++)
			{
				for(j=0;j<n;j++)
				{
					/*       */
				}
			}
			
			/*or*/
			int i，j；
			for(i=0;i<n;i++)
			{
				for(j=i;j<n;j++)
				{
					/*       */
				}
			}

常见的时间复杂度

		O(1)<O(logn)<O(n)<O(nlogn)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)
		在编写算法时，尤其是要处理的数据较大时要注意选择时间复杂度较小的算法以保证程序更好的运行。

第三章

线性表的顺序储存

				插入
				Status ListInsert(SqList *L,int i,ElemType e)
				{
					int k;
					if(L->length==MAXSIZE)
						reutrn ERROR;
					if(i<1||i>length+1)
						return ERROR
					if(i<=L->length)
					{
						for(k=L->length-1;k>=i-1;k--)
							L->data[k+1]=L->data[k];
					}
					L->data[i-1]=e;
					L->length++;
					return OK;
				}
				删除
				Status ListDelete(SqList *L,int i,ElemType *e)
				{
					int k;
					if(L->length==0)
						return ERROR;
					if(i<1||i>L->length)
						return ERROR;
					*e=L->data[i-1];
					if(i<L->length)
					{
						for(k=i;k<L->length;k++)
							L->data[k-1]=L->data[k];
					}	
					L->length--;
					return OK;
				}

线性表的链式储存结构

		链表的建立与逆序
		#include <stdio.h>
		#include <stdlib.h>

		typedef struct A {
			int number;
			struct A *next;
		} NODE, *LIST;

		LIST chushihua() {
			LIST head = NULL;
			head = (NODE *)malloc(sizeof(NODE));
			head->next = NULL;
			return head;
		}

		void input(LIST head) {
			NODE *r, *s;
			int number;
			r = head;
			while (1) {
				printf("请输入节点，按0退出\n");
				scanf("%d", &number);
				if (number == 0)
					break;
				s = (NODE *)malloc(sizeof(NODE));
				s->number = number;
				s->next = NULL;
				r->next = s;
				r = s;
			}
			r->next = NULL;
		}

		LIST fanzhuan(LIST head) {
			LIST nhead = NULL;
			nhead = (NODE *)malloc(sizeof(NODE));
			nhead->next = NULL;
			NODE *s, *p;
			while (p) {
				s = (NODE *)malloc(sizeof(NODE));
				s->number = p->number;
				s->next = nhead->next;
				nhead->next = s;
				p = p->next;
			}
			return nhead;
		}

		void output(LIST head) {
			NODE *p;
			p = head->next;
			while (p->next) {
				printf("%d\n", p->number);
				p = p->next;
			}
		}

		main() {
			LIST head;
			head = chushihua();
			input(head);
			head = fanzhuan(head);
			output(head);
		}
		判断环形链表
		bool hasCycle(struct ListNode *head) 
		{
			int flag=0;
			struct ListNode *s,*r,*p;
			s=head;
			r=head;
			while(s&&r&&p)
			 {
    			p=r->next;
    			r=p;
    			p=s->next;
    			if(p==NULL)
        			break;
    			else
        			s=p->next;
    			if(r==s)
    			{
        			flag=1;
        			break;
    			}
		 	}
			if(flag==1)
    			return true;
			else
    			return false;
		}
		
		
		快慢表思想
		struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
		{
			struct ListNode*p=headA;
			struct ListNode*q=headB;
			while(p!=q)
			{
    			if(p!=NULL)
        			p=p->next;
    			else
        			p=headB;
    			if(q!=NULL)
        			q=q->next;
    			else
        			q=headA;
			}
			return p;
			}